diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index a3b1572..d4fa2af 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,7 +34,7 @@ jobs: id: set-matrix run: | # List of all available parsers - ALL_PARSERS="redshift postgresql cql snowflake tsql doris trino plsql googlesql mysql partiql tidb mariadb cosmosdb" + ALL_PARSERS="redshift postgresql cql snowflake tsql doris starrocks trino plsql googlesql mysql partiql tidb mariadb cosmosdb" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/doris/DorisLexer.g4 b/doris/DorisLexer.g4 new file mode 100644 index 0000000..63c2239 --- /dev/null +++ b/doris/DorisLexer.g4 @@ -0,0 +1,707 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Copied from Apache Spark and modified for Apache Doris + +lexer grammar DorisLexer; + +// @members section removed - Java code not compatible with Go target +// Original predicates isValidDecimal() and isNoBackslashEscapes removed + +SEMICOLON: ';'; + +LEFT_PAREN: '('; +RIGHT_PAREN: ')'; +COMMA: ','; +DOT: '.'; +DOTDOTDOT: '...'; +LEFT_BRACKET: '['; +RIGHT_BRACKET: ']'; +LEFT_BRACE: '{'; +RIGHT_BRACE: '}'; + +// TODO: add a doc to list reserved words + +//============================ +// Start of the keywords list +//============================ +//--DORIS-KEYWORD-LIST-START +ACCOUNT_LOCK: 'ACCOUNT_LOCK'; +ACCOUNT_UNLOCK: 'ACCOUNT_UNLOCK'; +ACTIONS: 'ACTIONS'; +ADD: 'ADD'; +ADMIN: 'ADMIN'; +AFTER: 'AFTER'; +AGG_STATE: 'AGG_STATE'; +AGGREGATE: 'AGGREGATE'; +ALIAS: 'ALIAS'; +ALL: 'ALL'; +ALTER: 'ALTER'; +ANALYZE: 'ANALYZE'; +ANALYZED: 'ANALYZED'; +ANALYZER: 'ANALYZER'; +AND: 'AND'; +ANTI: 'ANTI'; +APPEND: 'APPEND'; +ARRAY: 'ARRAY'; +AS: 'AS'; +ASC: 'ASC'; +AT: 'AT'; +AUTHORS: 'AUTHORS'; +AUTO: 'AUTO'; +AUTO_INCREMENT: 'AUTO_INCREMENT'; +ALWAYS: 'ALWAYS'; +BACKEND: 'BACKEND'; +BACKENDS: 'BACKENDS'; +BACKUP: 'BACKUP'; +BEGIN: 'BEGIN'; +BELONG: 'BELONG'; +BETWEEN: 'BETWEEN'; +BIGINT: 'BIGINT'; +BIN: 'BIN'; +BINARY: 'BINARY'; +BINLOG: 'BINLOG'; +BITAND: 'BITAND'; +BITMAP: 'BITMAP'; +BITMAP_EMPTY: 'BITMAP_EMPTY'; +BITMAP_UNION: 'BITMAP_UNION'; +BITOR: 'BITOR'; +BITXOR: 'BITXOR'; +BLOB: 'BLOB'; +BOOLEAN: 'BOOLEAN'; +BOTH: 'BOTH'; +BRANCH: 'BRANCH'; +BRIEF: 'BRIEF'; +BROKER: 'BROKER'; +BUCKETS: 'BUCKETS'; +BUILD: 'BUILD'; +BUILTIN: 'BUILTIN'; +BULK: 'BULK'; +BY: 'BY'; +CACHE: 'CACHE'; +CACHED: 'CACHED'; +CALL: 'CALL'; +CANCEL: 'CANCEL'; +CASE: 'CASE'; +CAST: 'CAST'; +CATALOG: 'CATALOG'; +CATALOGS: 'CATALOGS'; +CHAIN: 'CHAIN'; +CHAR: 'CHAR' | 'CHARACTER'; +CHARSET: 'CHARSET'; +CHAR_FILTER: 'CHAR_FILTER'; +CHECK: 'CHECK'; +CLEAN: 'CLEAN'; +CLUSTER: 'CLUSTER'; +CLUSTERS: 'CLUSTERS'; +COLLATE: 'COLLATE'; +COLLATION: 'COLLATION'; +COLLECT: 'COLLECT'; +COLOCATE: 'COLOCATE'; +COLUMN: 'COLUMN'; +COLUMNS: 'COLUMNS'; +COMMENT: 'COMMENT'; +COMMIT: 'COMMIT'; +COMMITTED: 'COMMITTED'; +COMPACT: 'COMPACT'; +COMPLETE: 'COMPLETE'; +COMPRESS_TYPE: 'COMPRESS_TYPE'; +COMPUTE: 'COMPUTE'; +CONDITIONS: 'CONDITIONS'; +CONFIG: 'CONFIG'; +CONNECTION: 'CONNECTION'; +CONNECTION_ID: 'CONNECTION_ID'; +CONSISTENT: 'CONSISTENT'; +CONSTRAINT: 'CONSTRAINT'; +CONSTRAINTS: 'CONSTRAINTS'; +CONVERT: 'CONVERT'; +CONVERT_LSC: 'CONVERT_LIGHT_SCHEMA_CHANGE_PROCESS'; +COPY: 'COPY'; +COUNT: 'COUNT'; +CREATE: 'CREATE'; +CREATION: 'CREATION'; +CRON: 'CRON'; +CROSS: 'CROSS'; +CUBE: 'CUBE'; +CURRENT: 'CURRENT'; +CURRENT_CATALOG: 'CURRENT_CATALOG'; +CURRENT_DATE: 'CURRENT_DATE'; +CURRENT_TIME: 'CURRENT_TIME'; +CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; +CURRENT_USER: 'CURRENT_USER'; +DATA: 'DATA'; +DATABASE: 'DATABASE'; +DATABASES: 'DATABASES'; +DATE: 'DATE'; +DATETIME: 'DATETIME'; +DATETIMEV2: 'DATETIMEV2'; +DATEV2: 'DATEV2'; +DATETIMEV1: 'DATETIMEV1'; +DATEV1: 'DATEV1'; +DAY: 'DAY'; +DAY_SECOND: 'DAY_SECOND'; +DAYS: 'DAYS'; +DAY_HOUR: 'DAY_HOUR'; +DECIMAL: 'DECIMAL'; +DECIMALV2: 'DECIMALV2'; +DECIMALV3: 'DECIMALV3'; +DECOMMISSION: 'DECOMMISSION'; +DEFAULT: 'DEFAULT'; +DEFERRED: 'DEFERRED'; +DELETE: 'DELETE'; +DEMAND: 'DEMAND'; +DESC: 'DESC'; +DESCRIBE: 'DESCRIBE'; +DIAGNOSE: 'DIAGNOSE'; +DIAGNOSIS: 'DIAGNOSIS'; +DICTIONARIES: 'DICTIONARIES'; +DICTIONARY: 'DICTIONARY'; +DISK: 'DISK'; +DISTINCT: 'DISTINCT'; +DISTINCTPC: 'DISTINCTPC'; +DISTINCTPCSA: 'DISTINCTPCSA'; +DISTRIBUTED: 'DISTRIBUTED'; +DISTRIBUTION: 'DISTRIBUTION'; +DIV: 'DIV'; +DO: 'DO'; +DORIS_INTERNAL_TABLE_ID: 'DORIS_INTERNAL_TABLE_ID'; +DOUBLE: 'DOUBLE'; +DROP: 'DROP'; +DROPP: 'DROPP'; +DUAL: 'DUAL'; +DUMP: 'DUMP'; +DUPLICATE: 'DUPLICATE'; +DYNAMIC: 'DYNAMIC'; +E:'E'; +ELSE: 'ELSE'; +ENABLE: 'ENABLE'; +ENCRYPTION: 'ENCRYPTION'; +ENCRYPTKEY: 'ENCRYPTKEY'; +ENCRYPTKEYS: 'ENCRYPTKEYS'; +END: 'END'; +ENDS: 'ENDS'; +ENGINE: 'ENGINE'; +ENGINES: 'ENGINES'; +ENTER: 'ENTER'; +ERRORS: 'ERRORS'; +ESCAPE: 'ESCAPE'; +EVENTS: 'EVENTS'; +EVERY: 'EVERY'; +EXCEPT: 'EXCEPT'; +EXCLUDE: 'EXCLUDE'; +EXECUTE: 'EXECUTE'; +EXISTS: 'EXISTS'; +EXPIRED: 'EXPIRED'; +EXPLAIN: 'EXPLAIN'; +EXPORT: 'EXPORT'; +EXTENDED: 'EXTENDED'; +EXTERNAL: 'EXTERNAL'; +EXTRACT: 'EXTRACT'; +FAILED_LOGIN_ATTEMPTS: 'FAILED_LOGIN_ATTEMPTS'; +FALSE: 'FALSE'; +FAST: 'FAST'; +FEATURE: 'FEATURE'; +FIELDS: 'FIELDS'; +FILE: 'FILE'; +FILTER: 'FILTER'; +FIRST: 'FIRST'; +FLOAT: 'FLOAT'; +FOLLOWER: 'FOLLOWER'; +FOLLOWING: 'FOLLOWING'; +FOR: 'FOR'; +FOREIGN: 'FOREIGN'; +FORCE: 'FORCE'; +FORMAT: 'FORMAT'; +FREE: 'FREE'; +FROM: 'FROM'; +FRONTEND: 'FRONTEND'; +FRONTENDS: 'FRONTENDS'; +FULL: 'FULL'; +FUNCTION: 'FUNCTION'; +FUNCTIONS: 'FUNCTIONS'; +GENERATED: 'GENERATED'; +GENERIC: 'GENERIC'; +GLOBAL: 'GLOBAL'; +GRANT: 'GRANT'; +GRANTS: 'GRANTS'; +GRAPH: 'GRAPH'; +GROUP: 'GROUP'; +GROUPING: 'GROUPING'; +GROUPS: 'GROUPS'; +GROUP_CONCAT: 'GROUP_CONCAT'; +HASH: 'HASH'; +HASH_MAP: 'HASH_MAP'; +HAVING: 'HAVING'; +HDFS: 'HDFS'; +HELP: 'HELP'; +HISTOGRAM: 'HISTOGRAM'; +HLL: 'HLL'; +HLL_UNION: 'HLL_UNION'; +HOSTNAME: 'HOSTNAME'; +HOTSPOT: 'HOTSPOT'; +HOUR: 'HOUR'; +HOURS: 'HOURS'; +HUB: 'HUB'; +IDENTIFIED: 'IDENTIFIED'; +IF: 'IF'; +IGNORE: 'IGNORE'; +IMMEDIATE: 'IMMEDIATE'; +IN: 'IN'; +INCREMENTAL: 'INCREMENTAL'; +INDEX: 'INDEX'; +INDEXES: 'INDEXES'; +INFILE: 'INFILE'; +INNER: 'INNER'; +INSERT: 'INSERT'; +INSTALL: 'INSTALL'; +INT: 'INT'; +INTEGER: 'INTEGER'; +INTERMEDIATE: 'INTERMEDIATE'; +INTERSECT: 'INTERSECT'; +INTERVAL: 'INTERVAL'; +INTO: 'INTO'; +INVERTED: 'INVERTED'; +IP_TRIE: 'IP_TRIE'; +IPV4: 'IPV4'; +IPV6: 'IPV6'; +IS: 'IS'; +IS_NOT_NULL_PRED: 'IS_NOT_NULL_PRED'; +IS_NULL_PRED: 'IS_NULL_PRED'; +ISNULL: 'ISNULL'; +ISOLATION: 'ISOLATION'; +JOB: 'JOB'; +JOBS: 'JOBS'; +JOIN: 'JOIN'; +JSON: 'JSON'; +JSONB: 'JSONB'; +KEY: 'KEY'; +KEYS: 'KEYS'; +KILL: 'KILL'; +LABEL: 'LABEL'; +LARGEINT: 'LARGEINT'; +LAYOUT: 'LAYOUT'; +LAST: 'LAST'; +LATERAL: 'LATERAL'; +LDAP: 'LDAP'; +LDAP_ADMIN_PASSWORD: 'LDAP_ADMIN_PASSWORD'; +LEADING: 'LEADING'; +LEFT: 'LEFT'; +LESS: 'LESS'; +LEVEL: 'LEVEL'; +LIKE: 'LIKE'; +LIMIT: 'LIMIT'; +LINES: 'LINES'; +LINK: 'LINK'; +LIST: 'LIST'; +LOAD: 'LOAD'; +LOCAL: 'LOCAL'; +LOCALTIME: 'LOCALTIME'; +LOCALTIMESTAMP: 'LOCALTIMESTAMP'; +LOCATION: 'LOCATION'; +LOCK: 'LOCK'; +LOGICAL: 'LOGICAL'; +LOW_PRIORITY: 'LOW_PRIORITY'; +MANUAL: 'MANUAL'; +MAP: 'MAP'; +MATCH: 'MATCH'; +MATCHED: 'MATCHED'; +MATCH_ALL: 'MATCH_ALL'; +MATCH_ANY: 'MATCH_ANY'; +MATCH_NAME: 'MATCH_NAME'; +MATCH_NAME_GLOB: 'MATCH_NAME_GLOB'; +MATCH_PHRASE: 'MATCH_PHRASE'; +MATCH_PHRASE_EDGE: 'MATCH_PHRASE_EDGE'; +MATCH_PHRASE_PREFIX: 'MATCH_PHRASE_PREFIX'; +MATCH_REGEXP: 'MATCH_REGEXP'; +MATERIALIZED: 'MATERIALIZED'; +MAX: 'MAX'; +MAXVALUE: 'MAXVALUE'; +MEMO:'MEMO'; +MERGE: 'MERGE'; +MID: 'MID'; +MIGRATE: 'MIGRATE'; +MIGRATIONS: 'MIGRATIONS'; +MIN: 'MIN'; +MINUS: 'MINUS'; +MINUTE: 'MINUTE'; +MINUTES: 'MINUTES'; +MINUTE_SECOND: 'MINUTE_SECOND'; +MODIFY: 'MODIFY'; +MONTH: 'MONTH'; +MTMV: 'MTMV'; +NAME: 'NAME'; +NAMES: 'NAMES'; +NATURAL: 'NATURAL'; +NEGATIVE: 'NEGATIVE'; +NEVER: 'NEVER'; +NEXT: 'NEXT'; +NGRAM_BF: 'NGRAM_BF'; +ANN: 'ANN'; +NO: 'NO'; +NO_USE_MV: 'NO_USE_MV'; +NON_NULLABLE: 'NON_NULLABLE'; +NOT: 'NOT'; +NULL: 'NULL'; +NULLS: 'NULLS'; +OBSERVER: 'OBSERVER'; +OF: 'OF'; +OFFSET: 'OFFSET'; +ON: 'ON'; +OFF: 'OFF'; +ONLY: 'ONLY'; +OPEN: 'OPEN'; +OPTIMIZE: 'OPTIMIZE'; +OPTIMIZED: 'OPTIMIZED'; +OR: 'OR'; +ORDER: 'ORDER'; +OUTER: 'OUTER'; +OUTFILE: 'OUTFILE'; +OVER: 'OVER'; +OVERWRITE: 'OVERWRITE'; +PARAMETER: 'PARAMETER'; +PARSED: 'PARSED'; +PARTITION: 'PARTITION'; +PARTITIONS: 'PARTITIONS'; +PASSWORD: 'PASSWORD'; +PASSWORD_EXPIRE: 'PASSWORD_EXPIRE'; +PASSWORD_HISTORY: 'PASSWORD_HISTORY'; +PASSWORD_LOCK_TIME: 'PASSWORD_LOCK_TIME'; +PASSWORD_REUSE: 'PASSWORD_REUSE'; +PATH: 'PATH'; +PAUSE: 'PAUSE'; +PERCENT: 'PERCENT'; +PERIOD: 'PERIOD'; +PERMISSIVE: 'PERMISSIVE'; +PHYSICAL: 'PHYSICAL'; +PI: 'PI'; +PLACEHOLDER: '?'; +PLAN: 'PLAN'; +PLAY: 'PLAY'; +PRIVILEGES: 'PRIVILEGES'; +PROCESS: 'PROCESS'; +PLUGIN: 'PLUGIN'; +PLUGINS: 'PLUGINS'; +POLICY: 'POLICY'; +POSITION: 'POSITION'; +PRECEDING: 'PRECEDING'; +PREPARE: 'PREPARE'; +PRIMARY: 'PRIMARY'; +PROC: 'PROC'; +PROCEDURE: 'PROCEDURE'; +PROCESSLIST: 'PROCESSLIST'; +PROFILE: 'PROFILE'; +PROPERTIES: 'PROPERTIES'; +PROPERTY: 'PROPERTY'; +QUANTILE_STATE: 'QUANTILE_STATE'; +QUANTILE_UNION: 'QUANTILE_UNION'; +QUERY: 'QUERY'; +QUEUED: 'QUEUED'; +QUOTA: 'QUOTA'; +QUALIFY: 'QUALIFY'; +QUARTER: 'QUARTER'; +RANDOM: 'RANDOM'; +RANGE: 'RANGE'; +READ: 'READ'; +REAL: 'REAL'; +REBALANCE: 'REBALANCE'; +RECENT: 'RECENT'; +RECOVER: 'RECOVER'; +RECYCLE: 'RECYCLE'; +REFRESH: 'REFRESH'; +REFERENCES: 'REFERENCES'; +REGEXP: 'REGEXP'; +RELEASE: 'RELEASE'; +RENAME: 'RENAME'; +REPAIR: 'REPAIR'; +REPEATABLE: 'REPEATABLE'; +REPLACE: 'REPLACE'; +REPLACE_IF_NOT_NULL: 'REPLACE_IF_NOT_NULL'; +REPLAYER: 'REPLAYER'; +REPLICA: 'REPLICA'; +REPOSITORIES: 'REPOSITORIES'; +REPOSITORY: 'REPOSITORY'; +RESOURCE: 'RESOURCE'; +RESOURCES: 'RESOURCES'; +RESTORE: 'RESTORE'; +RESTRICTIVE: 'RESTRICTIVE'; +RESUME: 'RESUME'; +RETAIN: 'RETAIN'; +RETENTION: 'RETENTION'; +RETURNS: 'RETURNS'; +REVOKE: 'REVOKE'; +REWRITTEN: 'REWRITTEN'; +RIGHT: 'RIGHT'; +RLIKE: 'RLIKE'; +ROLE: 'ROLE'; +ROLES: 'ROLES'; +ROLLBACK: 'ROLLBACK'; +ROLLUP: 'ROLLUP'; +ROOT: 'ROOT'; +ROTATE: 'ROTATE'; +ROUTINE: 'ROUTINE'; +ROW: 'ROW'; +ROWS: 'ROWS'; +S3: 'S3'; +SAMPLE: 'SAMPLE'; +SCHEDULE: 'SCHEDULE'; +SCHEDULER: 'SCHEDULER'; +SCHEMA: 'SCHEMA'; +SCHEMAS: 'SCHEMAS'; +SECOND: 'SECOND'; +SELECT: 'SELECT'; +SEMI: 'SEMI'; +SEPARATOR: 'SEPARATOR'; +SERIALIZABLE: 'SERIALIZABLE'; +SESSION: 'SESSION'; +SESSION_USER: 'SESSION_USER'; +SET: 'SET'; +SETS: 'SETS'; +SET_SESSION_VARIABLE: 'SET_SESSION_VARIABLE'; +SHAPE: 'SHAPE'; +SHOW: 'SHOW'; +SIGNED: 'SIGNED'; +SKEW: 'SKEW'; +SMALLINT: 'SMALLINT'; +SNAPSHOT: 'SNAPSHOT'; +SNAPSHOTS: 'SNAPSHOTS'; +SONAME: 'SONAME'; +SPLIT: 'SPLIT'; +SQL: 'SQL'; +SQL_BLOCK_RULE: 'SQL_BLOCK_RULE'; +STAGE: 'STAGE'; +STAGES: 'STAGES'; +START: 'START'; +STARTS: 'STARTS'; +STATS: 'STATS'; +STATUS: 'STATUS'; +STOP: 'STOP'; +STORAGE: 'STORAGE'; +STREAM: 'STREAM'; +STREAMING: 'STREAMING'; +STRING: 'STRING'; +STRUCT: 'STRUCT'; +SUBSTR: 'SUBSTR'; +SUBSTRING: 'SUBSTRING'; +SUM: 'SUM'; +SUPERUSER: 'SUPERUSER'; +SWITCH: 'SWITCH'; +SYNC: 'SYNC'; +SYSTEM: 'SYSTEM'; +TABLE: 'TABLE'; +TABLES: 'TABLES'; +TABLESAMPLE: 'TABLESAMPLE'; +TABLET: 'TABLET'; +TABLETS: 'TABLETS'; +TAG: 'TAG'; +TASK: 'TASK'; +TASKS: 'TASKS'; +TDE: 'TDE'; +TEMPORARY: 'TEMPORARY'; +TERMINATED: 'TERMINATED'; +TEXT: 'TEXT'; +THAN: 'THAN'; +THEN: 'THEN'; +TIME: 'TIME'; +TIMESTAMP: 'TIMESTAMP'; +TINYINT: 'TINYINT'; +TO: 'TO'; +TOKENIZER: 'TOKENIZER'; +TOKEN_FILTER: 'TOKEN_FILTER'; +TRAILING: 'TRAILING'; +TRANSACTION: 'TRANSACTION'; +TRASH: 'TRASH'; +TREE: 'TREE'; +TRIGGERS: 'TRIGGERS'; +TRIM: 'TRIM'; +TRUE: 'TRUE'; +TRUNCATE: 'TRUNCATE'; +TRY_CAST: 'TRY_CAST'; +TYPE: 'TYPE'; +TYPECAST: 'TYPE_CAST'; +TYPES: 'TYPES'; +UNBOUNDED: 'UNBOUNDED'; +UNCOMMITTED: 'UNCOMMITTED'; +UNINSTALL: 'UNINSTALL'; +UNION: 'UNION'; +UNIQUE: 'UNIQUE'; +UNLOCK: 'UNLOCK'; +UNSET: 'UNSET'; +UNSIGNED: 'UNSIGNED'; +UP: 'UP'; +UPDATE: 'UPDATE'; +USE: 'USE'; +USER: 'USER'; +USE_MV: 'USE_MV'; +USING: 'USING'; +VALUE: 'VALUE'; +VALUES: 'VALUES'; +VARBINARY: 'VARBINARY'; +VARCHAR: 'VARCHAR'; +VARIABLE: 'VARIABLE'; +VARIABLES: 'VARIABLES'; +VARIANT: 'VARIANT'; +VAULT: 'VAULT'; +VAULTS: 'VAULTS'; +VERBOSE: 'VERBOSE'; +VERSION: 'VERSION'; +VIEW: 'VIEW'; +VIEWS: 'VIEWS'; +WARM: 'WARM'; +WARNINGS: 'WARNINGS'; +WEEK: 'WEEK'; +WHEN: 'WHEN'; +WHERE: 'WHERE'; +WHITELIST: 'WHITELIST'; +WITH: 'WITH'; +WORK: 'WORK'; +WORKLOAD: 'WORKLOAD'; +WRITE: 'WRITE'; +XOR: 'XOR'; +YEAR: 'YEAR'; +//--DORIS-KEYWORD-LIST-END +//============================ +// End of the keywords list +//============================ + +EQ : '=' | '=='; +NSEQ: '<=>'; +NEQ : '<>' | '!='; +LT : '<'; +LTE : '<=' | '!>'; +GT : '>'; +GTE : '>=' | '!<'; + +PLUS: '+'; +SUBTRACT: '-'; +ASTERISK: '*'; +SLASH: '/'; +MOD: '%'; +TILDE: '~'; +AMPERSAND: '&'; +LOGICALAND: '&&'; +LOGICALNOT: '!'; +PIPE: '|'; +DOUBLEPIPES: '||'; +HAT: '^'; +COLON: ':'; +ARROW: '->'; +HINT_START: '/*+'; +HINT_END: '*/'; +COMMENT_START: '/*'; +ATSIGN: '@'; +DOUBLEATSIGN: '@@'; + +STRING_LITERAL + : '\'' ( '\\'. | '\'\'' | ~('\'' | '\\'))* '\'' + | '"' ( '\\'. | '""' | ~('"'| '\\'))* '"' + ; + +VARBINARY_LITERAL + : [Xx]'\'' HEXDIGIT* '\'' + | [Xx]'"' HEXDIGIT* '"' + ; + +LEADING_STRING + : LEFT_BRACE + | RIGHT_BRACE + | LEFT_BRACKET + | RIGHT_BRACKET + ; + +BIGINT_LITERAL + : DIGIT+ 'L' + ; + +SMALLINT_LITERAL + : DIGIT+ 'S' + ; + +TINYINT_LITERAL + : DIGIT+ 'Y' + ; + +INTEGER_VALUE + : DIGIT+ + ; + +EXPONENT_VALUE + : DIGIT+ EXPONENT + | DECIMAL_DIGITS EXPONENT + ; + +DECIMAL_VALUE + : DECIMAL_DIGITS + ; + +BIGDECIMAL_LITERAL + : DIGIT+ EXPONENT? 'BD' + | DECIMAL_DIGITS EXPONENT? 'BD' + ; + +IDENTIFIER + : (LETTER | DIGIT | '_')+ + ; + +BACKQUOTED_IDENTIFIER + : '`' ( ~'`' | '``' )* '`' + ; + +fragment DECIMAL_DIGITS + : DIGIT+ '.' DIGIT* + | '.' DIGIT+ + ; + +fragment EXPONENT + : 'E' [+-]? DIGIT+ + ; + +fragment DIGIT + : [0-9] + ; + +fragment HEXDIGIT + : [0-9a-fA-F] + ; + +fragment LETTER + : [a-zA-Z$_] // these are the "java letters" below 0x7F + | ~[\u0000-\u007F\uD800-\uDBFF] // covers all characters above 0x7F which are not a surrogate + | [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + ; + +SIMPLE_COMMENT + : '--' ('\\\n' | ~[\r\n])* '\r'? '\n'? -> channel(HIDDEN) + ; + +BRACKETED_COMMENT + : COMMENT_START ( BRACKETED_COMMENT | . )*? '*/' -> channel(2) + ; + + +FROM_DUAL + : 'FROM' WS+ 'DUAL' -> channel(HIDDEN); + +WS + : [ \r\n\t]+ -> channel(HIDDEN) + ; + +// Catch-all for anything we can't recognize. +// We use this to be able to ignore and recover all the text +// when splitting statements with DelimiterLexer +UNRECOGNIZED + : . + ; diff --git a/doris/DorisParser.g4 b/doris/DorisParser.g4 new file mode 100644 index 0000000..5019d58 --- /dev/null +++ b/doris/DorisParser.g4 @@ -0,0 +1,2258 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Copied from Apache Spark and modified for Apache Doris + +parser grammar DorisParser; + +options { tokenVocab = DorisLexer; } + +// @members section removed - Java code not compatible with Go target +// Original predicate ansiSQLSyntax removed + +multiStatements + : SEMICOLON* statement? (SEMICOLON+ statement)* SEMICOLON* EOF + ; + +singleStatement + : SEMICOLON* statement? SEMICOLON* EOF + ; + +expressionWithEof + : expression EOF + ; + +statement + : statementBase # statementBaseAlias + | CALL name=multipartIdentifier LEFT_PAREN (expression (COMMA expression)*)? RIGHT_PAREN #callProcedure + | (ALTER | CREATE (OR REPLACE)? | REPLACE) (PROCEDURE | PROC) name=multipartIdentifier LEFT_PAREN .*? RIGHT_PAREN .*? #createProcedure + | DROP (PROCEDURE | PROC) (IF EXISTS)? name=multipartIdentifier #dropProcedure + | SHOW (PROCEDURE | FUNCTION) STATUS (LIKE pattern=valueExpression | whereClause)? #showProcedureStatus + | SHOW CREATE PROCEDURE name=multipartIdentifier #showCreateProcedure + // FIXME: like should be wildWhere? FRONTEND should not contain FROM backendid + | ADMIN? SHOW type=(FRONTEND | BACKEND) CONFIG (LIKE pattern=valueExpression)? (FROM backendId=INTEGER_VALUE)? #showConfig + ; + +statementBase + : explain? query outFileClause? #statementDefault + | supportedDmlStatement #supportedDmlStatementAlias + | supportedCreateStatement #supportedCreateStatementAlias + | supportedAlterStatement #supportedAlterStatementAlias + | materializedViewStatement #materializedViewStatementAlias + | supportedJobStatement #supportedJobStatementAlias + | constraintStatement #constraintStatementAlias + | supportedCleanStatement #supportedCleanStatementAlias + | supportedDescribeStatement #supportedDescribeStatementAlias + | supportedDropStatement #supportedDropStatementAlias + | supportedSetStatement #supportedSetStatementAlias + | supportedUnsetStatement #supportedUnsetStatementAlias + | supportedRefreshStatement #supportedRefreshStatementAlias + | supportedShowStatement #supportedShowStatementAlias + | supportedLoadStatement #supportedLoadStatementAlias + | supportedCancelStatement #supportedCancelStatementAlias + | supportedRecoverStatement #supportedRecoverStatementAlias + | supportedAdminStatement #supportedAdminStatementAlias + | supportedUseStatement #supportedUseStatementAlias + | supportedOtherStatement #supportedOtherStatementAlias + | supportedKillStatement #supportedKillStatementAlias + | supportedStatsStatement #supportedStatsStatementAlias + | supportedTransactionStatement #supportedTransactionStatementAlias + | supportedGrantRevokeStatement #supportedGrantRevokeStatementAlias + ; + +materializedViewStatement + : CREATE MATERIALIZED VIEW (IF NOT EXISTS)? mvName=multipartIdentifier + (LEFT_PAREN cols=simpleColumnDefs RIGHT_PAREN)? buildMode? + (REFRESH refreshMethod? refreshTrigger?)? + ((DUPLICATE)? KEY keys=identifierList)? + (COMMENT STRING_LITERAL)? + (PARTITION BY LEFT_PAREN mvPartition RIGHT_PAREN)? + (DISTRIBUTED BY (HASH hashKeys=identifierList | RANDOM) + (BUCKETS (INTEGER_VALUE | AUTO))?)? + propertyClause? + AS? query #createMTMV + | REFRESH MATERIALIZED VIEW mvName=multipartIdentifier (partitionSpec | COMPLETE | AUTO) #refreshMTMV + | ALTER MATERIALIZED VIEW mvName=multipartIdentifier ((RENAME newName=identifier) + | (REFRESH (refreshMethod | refreshTrigger | refreshMethod refreshTrigger)) + | REPLACE WITH MATERIALIZED VIEW newName=identifier propertyClause? + | (SET LEFT_PAREN fileProperties=propertyItemList RIGHT_PAREN)) #alterMTMV + | DROP MATERIALIZED VIEW (IF EXISTS)? mvName=multipartIdentifier + (ON tableName=multipartIdentifier)? #dropMV + | PAUSE MATERIALIZED VIEW JOB ON mvName=multipartIdentifier #pauseMTMV + | RESUME MATERIALIZED VIEW JOB ON mvName=multipartIdentifier #resumeMTMV + | CANCEL MATERIALIZED VIEW TASK taskId=INTEGER_VALUE ON mvName=multipartIdentifier #cancelMTMVTask + | SHOW CREATE MATERIALIZED VIEW mvName=multipartIdentifier #showCreateMTMV + ; +supportedJobStatement + : CREATE JOB label=multipartIdentifier propertyClause? + ON (STREAMING | SCHEDULE( + (EVERY timeInterval=INTEGER_VALUE timeUnit=identifier + (STARTS (startTime=STRING_LITERAL | CURRENT_TIMESTAMP))? + (ENDS endsTime=STRING_LITERAL)?) + | + (AT (atTime=STRING_LITERAL | CURRENT_TIMESTAMP)) + ) + ) + commentSpec? + DO supportedDmlStatement #createScheduledJob + | PAUSE JOB WHERE (jobNameKey=identifier) EQ (jobNameValue=STRING_LITERAL) #pauseJob + | ALTER JOB (jobName=multipartIdentifier) (propertyClause | supportedDmlStatement | propertyClause supportedDmlStatement) #alterJob + | DROP JOB (IF EXISTS)? WHERE (jobNameKey=identifier) EQ (jobNameValue=STRING_LITERAL) #dropJob + | RESUME JOB WHERE (jobNameKey=identifier) EQ (jobNameValue=STRING_LITERAL) #resumeJob + | CANCEL TASK WHERE (jobNameKey=identifier) EQ (jobNameValue=STRING_LITERAL) AND (taskIdKey=identifier) EQ (taskIdValue=INTEGER_VALUE) #cancelJobTask + ; +constraintStatement + : ALTER TABLE table=multipartIdentifier + ADD CONSTRAINT constraintName=errorCapturingIdentifier + constraint #addConstraint + | ALTER TABLE table=multipartIdentifier + DROP CONSTRAINT constraintName=errorCapturingIdentifier #dropConstraint + | SHOW CONSTRAINTS FROM table=multipartIdentifier #showConstraint + ; + +optSpecBranch + : ATSIGN BRANCH LEFT_PAREN name=identifier RIGHT_PAREN + ; + +supportedDmlStatement + : explain? cte? INSERT (INTO | OVERWRITE TABLE) + (tableName=multipartIdentifier (optSpecBranch)? | DORIS_INTERNAL_TABLE_ID LEFT_PAREN tableId=INTEGER_VALUE RIGHT_PAREN) + partitionSpec? // partition define + (WITH LABEL labelName=identifier)? cols=identifierList? // label and columns define + (LEFT_BRACKET hints=identifierSeq RIGHT_BRACKET)? // hint define + query #insertTable + | explain? cte? UPDATE tableName=multipartIdentifier tableAlias + SET updateAssignmentSeq + fromClause? + whereClause? #update + | explain? cte? DELETE FROM tableName=multipartIdentifier + partitionSpec? tableAlias + (USING relations)? + whereClause? #delete + | explain? cte? MERGE INTO targetTable=multipartIdentifier + (AS? identifier)? USING srcRelation=relationPrimary + ON expression + (mergeMatchedClause | mergeNotMatchedClause)+ #mergeInto + | LOAD LABEL lableName=multipartIdentifier + LEFT_PAREN dataDescs+=dataDesc (COMMA dataDescs+=dataDesc)* RIGHT_PAREN + (withRemoteStorageSystem)? + propertyClause? + (commentSpec)? #load + | EXPORT TABLE tableName=multipartIdentifier + (PARTITION partition=identifierList)? + (whereClause)? + TO filePath=STRING_LITERAL + (propertyClause)? + (withRemoteStorageSystem)? #export + | replayCommand #replay + | COPY INTO selectHint? name=multipartIdentifier columns=identifierList? FROM + (stageAndPattern | (LEFT_PAREN SELECT selectColumnClause + FROM stageAndPattern whereClause? RIGHT_PAREN)) + properties=propertyClause? #copyInto + | TRUNCATE TABLE multipartIdentifier specifiedPartition? FORCE? #truncateTable + ; + +mergeMatchedClause + : WHEN MATCHED (AND casePredicate=expression)? THEN + (UPDATE SET updateAssignmentSeq | DELETE) + ; + +mergeNotMatchedClause + : WHEN NOT MATCHED (AND casePredicate=expression)? THEN + INSERT cols=identifierList? VALUES rowConstructor + ; + +supportedCreateStatement + : CREATE (EXTERNAL | TEMPORARY)? TABLE (IF NOT EXISTS)? name=multipartIdentifier + ((ctasCols=identifierList)? | (LEFT_PAREN columnDefs (COMMA indexDefs)? COMMA? RIGHT_PAREN)) + (ENGINE EQ engine=identifier)? + ((AGGREGATE | UNIQUE | DUPLICATE) KEY keys=identifierList + (CLUSTER BY clusterKeys=identifierList)?)? + (COMMENT STRING_LITERAL)? + (partition=partitionTable)? + (DISTRIBUTED BY (HASH hashKeys=identifierList | RANDOM) + (BUCKETS (INTEGER_VALUE | autoBucket=AUTO))?)? + (ROLLUP LEFT_PAREN rollupDefs RIGHT_PAREN)? + properties=propertyClause? + (BROKER extProperties=propertyClause)? + (AS? query)? #createTable + | CREATE (OR REPLACE)? VIEW (IF NOT EXISTS)? name=multipartIdentifier + (LEFT_PAREN cols=simpleColumnDefs RIGHT_PAREN)? + (COMMENT STRING_LITERAL)? AS? query #createView + | CREATE FILE name=STRING_LITERAL + ((FROM | IN) database=identifier)? properties=propertyClause #createFile + | CREATE (EXTERNAL | TEMPORARY)? TABLE (IF NOT EXISTS)? name=multipartIdentifier + LIKE existedTable=multipartIdentifier + (WITH ROLLUP (rollupNames=identifierList)?)? #createTableLike + | CREATE ROLE (IF NOT EXISTS)? name=identifierOrText (COMMENT STRING_LITERAL)? #createRole + | CREATE WORKLOAD GROUP (IF NOT EXISTS)? + name=identifierOrText (FOR computeGroup=identifierOrText)? properties=propertyClause? #createWorkloadGroup + | CREATE CATALOG (IF NOT EXISTS)? catalogName=identifier + (WITH RESOURCE resourceName=identifier)? + (COMMENT STRING_LITERAL)? properties=propertyClause? #createCatalog + | CREATE ROW POLICY (IF NOT EXISTS)? name=identifier + ON table=multipartIdentifier + AS type=(RESTRICTIVE | PERMISSIVE) + TO (user=userIdentify | ROLE roleName=identifierOrText) + USING LEFT_PAREN booleanExpression RIGHT_PAREN #createRowPolicy + | CREATE STORAGE POLICY (IF NOT EXISTS)? + name=identifier properties=propertyClause? #createStoragePolicy + | BUILD INDEX (name=identifier)? ON tableName=multipartIdentifier + partitionSpec? #buildIndex + | CREATE INDEX (IF NOT EXISTS)? name=identifier + ON tableName=multipartIdentifier identifierList + (USING (BITMAP | NGRAM_BF | INVERTED | ANN))? + properties=propertyClause? (COMMENT STRING_LITERAL)? #createIndex + | CREATE WORKLOAD POLICY (IF NOT EXISTS)? name=identifierOrText + (CONDITIONS LEFT_PAREN workloadPolicyConditions RIGHT_PAREN)? + (ACTIONS LEFT_PAREN workloadPolicyActions RIGHT_PAREN)? + properties=propertyClause? #createWorkloadPolicy + | CREATE SQL_BLOCK_RULE (IF NOT EXISTS)? + name=identifier properties=propertyClause? #createSqlBlockRule + | CREATE ENCRYPTKEY (IF NOT EXISTS)? multipartIdentifier AS STRING_LITERAL #createEncryptkey + | CREATE statementScope? + (TABLES | AGGREGATE)? FUNCTION (IF NOT EXISTS)? + functionIdentifier LEFT_PAREN functionArguments? RIGHT_PAREN + RETURNS returnType=dataType (INTERMEDIATE intermediateType=dataType)? + properties=propertyClause? #createUserDefineFunction + | CREATE statementScope? ALIAS FUNCTION (IF NOT EXISTS)? + functionIdentifier LEFT_PAREN functionArguments? RIGHT_PAREN + WITH PARAMETER LEFT_PAREN parameters=identifierSeq? RIGHT_PAREN + AS expression #createAliasFunction + | CREATE USER (IF NOT EXISTS)? grantUserIdentify + (SUPERUSER | DEFAULT ROLE role=STRING_LITERAL)? + passwordOption commentSpec? #createUser + | CREATE (DATABASE | SCHEMA) (IF NOT EXISTS)? name=multipartIdentifier + properties=propertyClause? #createDatabase + | CREATE (READ ONLY)? REPOSITORY name=identifier WITH storageBackend #createRepository + | CREATE EXTERNAL? RESOURCE (IF NOT EXISTS)? + name=identifierOrText properties=propertyClause? #createResource + | CREATE DICTIONARY (IF NOT EXISTS)? name = multipartIdentifier + USING source = multipartIdentifier + LEFT_PAREN dictionaryColumnDefs RIGHT_PAREN + LAYOUT LEFT_PAREN layoutType=identifier RIGHT_PAREN + properties=propertyClause? # createDictionary + | CREATE STAGE (IF NOT EXISTS)? name=identifier properties=propertyClause? #createStage + | CREATE STORAGE VAULT (IF NOT EXISTS)? + name=identifierOrText properties=propertyClause? #createStorageVault + | CREATE INVERTED INDEX ANALYZER (IF NOT EXISTS)? + name=identifier properties=propertyClause? #createIndexAnalyzer + | CREATE INVERTED INDEX TOKENIZER (IF NOT EXISTS)? + name=identifier properties=propertyClause? #createIndexTokenizer + | CREATE INVERTED INDEX TOKEN_FILTER (IF NOT EXISTS)? + name=identifier properties=propertyClause? #createIndexTokenFilter + | CREATE INVERTED INDEX CHAR_FILTER (IF NOT EXISTS)? + name=identifier properties=propertyClause? #createIndexCharFilter + ; + +dictionaryColumnDefs: + dictionaryColumnDef (COMMA dictionaryColumnDef)*; + +dictionaryColumnDef: + colName = identifier columnType = (KEY | VALUE) ; + +supportedAlterStatement + : ALTER SYSTEM alterSystemClause #alterSystem + | ALTER VIEW name=multipartIdentifier + (MODIFY commentSpec | + (LEFT_PAREN cols=simpleColumnDefs RIGHT_PAREN)? + (COMMENT STRING_LITERAL)? AS query) #alterView + | ALTER CATALOG name=identifier RENAME newName=identifier #alterCatalogRename + | ALTER ROLE role=identifierOrText commentSpec #alterRole + | ALTER STORAGE VAULT name=multipartIdentifier properties=propertyClause #alterStorageVault + | ALTER WORKLOAD GROUP name=identifierOrText (FOR computeGroup=identifierOrText)? + properties=propertyClause? #alterWorkloadGroup + | ALTER COMPUTE GROUP name=identifierOrText + properties=propertyClause? #alterComputeGroup + | ALTER CATALOG name=identifier SET PROPERTIES + LEFT_PAREN propertyItemList RIGHT_PAREN #alterCatalogProperties + | ALTER WORKLOAD POLICY name=identifierOrText + properties=propertyClause? #alterWorkloadPolicy + | ALTER SQL_BLOCK_RULE name=identifier properties=propertyClause? #alterSqlBlockRule + | ALTER CATALOG name=identifier MODIFY COMMENT comment=STRING_LITERAL #alterCatalogComment + | ALTER DATABASE name=identifier RENAME newName=identifier #alterDatabaseRename + | ALTER STORAGE POLICY name=identifierOrText + properties=propertyClause #alterStoragePolicy + | ALTER TABLE tableName=multipartIdentifier + alterTableClause (COMMA alterTableClause)* #alterTable + | ALTER TABLE tableName=multipartIdentifier EXECUTE actionName=identifier + LEFT_PAREN propertyItemList? RIGHT_PAREN partitionSpec? (WHERE whereExpression=booleanExpression)? #alterTableExecute + | ALTER TABLE tableName=multipartIdentifier ADD ROLLUP + addRollupClause (COMMA addRollupClause)* #alterTableAddRollup + | ALTER TABLE tableName=multipartIdentifier DROP ROLLUP + dropRollupClause (COMMA dropRollupClause)* #alterTableDropRollup + | ALTER TABLE name=multipartIdentifier + SET LEFT_PAREN propertyItemList RIGHT_PAREN #alterTableProperties + | ALTER DATABASE name=identifier SET (DATA | REPLICA | TRANSACTION) + QUOTA (quota=identifier | INTEGER_VALUE) #alterDatabaseSetQuota + | ALTER DATABASE name=identifier SET PROPERTIES + LEFT_PAREN propertyItemList RIGHT_PAREN #alterDatabaseProperties + | ALTER SYSTEM RENAME COMPUTE GROUP name=identifier newName=identifier #alterSystemRenameComputeGroup + | ALTER RESOURCE name=identifierOrText properties=propertyClause? #alterResource + | ALTER REPOSITORY name=identifier properties=propertyClause? #alterRepository + | ALTER ROUTINE LOAD FOR name=multipartIdentifier + (loadProperty (COMMA loadProperty)*)? + properties=propertyClause? + (FROM type=identifier LEFT_PAREN propertyItemList RIGHT_PAREN)? #alterRoutineLoad + | ALTER COLOCATE GROUP name=multipartIdentifier + SET LEFT_PAREN propertyItemList RIGHT_PAREN #alterColocateGroup + | ALTER USER (IF EXISTS)? grantUserIdentify + passwordOption (COMMENT STRING_LITERAL)? #alterUser + ; + +supportedDropStatement + : DROP CATALOG RECYCLE BIN WHERE idType=STRING_LITERAL EQ id=INTEGER_VALUE #dropCatalogRecycleBin + | DROP ENCRYPTKEY (IF EXISTS)? name=multipartIdentifier #dropEncryptkey + | DROP ROLE (IF EXISTS)? name=identifierOrText #dropRole + | DROP SQL_BLOCK_RULE (IF EXISTS)? identifierSeq #dropSqlBlockRule + | DROP USER (IF EXISTS)? userIdentify #dropUser + | DROP STORAGE POLICY (IF EXISTS)? name=identifier #dropStoragePolicy + | DROP WORKLOAD GROUP (IF EXISTS)? name=identifierOrText (FOR computeGroup=identifierOrText)? #dropWorkloadGroup + | DROP CATALOG (IF EXISTS)? name=identifier #dropCatalog + | DROP FILE name=STRING_LITERAL + ((FROM | IN) database=identifier)? properties=propertyClause #dropFile + | DROP WORKLOAD POLICY (IF EXISTS)? name=identifierOrText #dropWorkloadPolicy + | DROP REPOSITORY name=identifier #dropRepository + | DROP TEMPORARY? TABLE (IF EXISTS)? name=multipartIdentifier FORCE? #dropTable + | DROP (DATABASE | SCHEMA) (IF EXISTS)? name=multipartIdentifier FORCE? #dropDatabase + | DROP statementScope? FUNCTION (IF EXISTS)? + functionIdentifier LEFT_PAREN functionArguments? RIGHT_PAREN #dropFunction + | DROP INDEX (IF EXISTS)? name=identifier ON tableName=multipartIdentifier #dropIndex + | DROP RESOURCE (IF EXISTS)? name=identifierOrText #dropResource + | DROP ROW POLICY (IF EXISTS)? policyName=identifier + ON tableName=multipartIdentifier + (FOR (userIdentify | ROLE roleName=identifier))? #dropRowPolicy + | DROP DICTIONARY (IF EXISTS)? name=multipartIdentifier #dropDictionary + | DROP STAGE (IF EXISTS)? name=identifier #dropStage + | DROP VIEW (IF EXISTS)? name=multipartIdentifier #dropView + | DROP INVERTED INDEX ANALYZER (IF EXISTS)? name=identifier #dropIndexAnalyzer + | DROP INVERTED INDEX TOKENIZER (IF EXISTS)? name=identifier #dropIndexTokenizer + | DROP INVERTED INDEX TOKEN_FILTER (IF EXISTS)? name=identifier #dropIndexTokenFilter + | DROP INVERTED INDEX CHAR_FILTER (IF EXISTS)? name=identifier #dropIndexCharFilter + ; + +supportedShowStatement + : SHOW statementScope? VARIABLES wildWhere? #showVariables + | SHOW AUTHORS #showAuthors + | SHOW ALTER TABLE (ROLLUP | (MATERIALIZED VIEW) | COLUMN) + ((FROM | IN) database=multipartIdentifier)? wildWhere? + sortClause? limitClause? #showAlterTable + | SHOW CREATE (DATABASE | SCHEMA) name=multipartIdentifier #showCreateDatabase + | SHOW BACKUP ((FROM | IN) database=identifier)? wildWhere? #showBackup + | SHOW BROKER #showBroker + | SHOW BUILD INDEX ((FROM | IN) database=identifier)? + wildWhere? sortClause? limitClause? #showBuildIndex + | SHOW DYNAMIC PARTITION TABLES ((FROM | IN) database=multipartIdentifier)? #showDynamicPartition + | SHOW EVENTS ((FROM | IN) database=multipartIdentifier)? wildWhere? #showEvents + | SHOW EXPORT ((FROM | IN) database=multipartIdentifier)? wildWhere? + sortClause? limitClause? #showExport + | SHOW LAST INSERT #showLastInsert + | SHOW ((CHAR SET) | CHARSET) #showCharset + | SHOW DELETE ((FROM | IN) database=multipartIdentifier)? #showDelete + | SHOW CREATE statementScope? FUNCTION functionIdentifier + LEFT_PAREN functionArguments? RIGHT_PAREN + ((FROM | IN) database=multipartIdentifier)? #showCreateFunction + | SHOW FULL? BUILTIN? FUNCTIONS + ((FROM | IN) database=multipartIdentifier)? (LIKE STRING_LITERAL)? #showFunctions + | SHOW GLOBAL FULL? FUNCTIONS (LIKE STRING_LITERAL)? #showGlobalFunctions + | SHOW ALL? GRANTS #showGrants + | SHOW GRANTS FOR userIdentify #showGrantsForUser + | SHOW CREATE USER userIdentify #showCreateUser + | SHOW SNAPSHOT ON repo=identifier wildWhere? #showSnapshot + | SHOW LOAD PROFILE loadIdPath=STRING_LITERAL? limitClause? #showLoadProfile + | SHOW CREATE REPOSITORY FOR identifier #showCreateRepository + | SHOW VIEW + (FROM |IN) tableName=multipartIdentifier + ((FROM | IN) database=identifier)? #showView + | SHOW PLUGINS #showPlugins + | SHOW STORAGE (VAULT | VAULTS) #showStorageVault + | SHOW REPOSITORIES #showRepositories + | SHOW ENCRYPTKEYS ((FROM | IN) database=multipartIdentifier)? + (LIKE STRING_LITERAL)? #showEncryptKeys + | SHOW BRIEF? CREATE TABLE name=multipartIdentifier #showCreateTable + | SHOW FULL? PROCESSLIST #showProcessList + | SHOW TEMPORARY? PARTITIONS FROM tableName=multipartIdentifier + wildWhere? sortClause? limitClause? #showPartitions + | SHOW BRIEF? RESTORE ((FROM | IN) database=identifier)? wildWhere? #showRestore + | SHOW ROLES #showRoles + | SHOW PARTITION partitionId=INTEGER_VALUE #showPartitionId + | SHOW PRIVILEGES #showPrivileges + | SHOW PROC path=STRING_LITERAL #showProc + | SHOW FILE ((FROM | IN) database=multipartIdentifier)? #showSmallFiles + | SHOW STORAGE? ENGINES #showStorageEngines + | SHOW CREATE CATALOG name=identifier #showCreateCatalog + | SHOW CATALOG name=identifier #showCatalog + | SHOW CATALOGS wildWhere? #showCatalogs + | SHOW PROPERTY (FOR user=identifierOrText)? (LIKE STRING_LITERAL)? #showUserProperties + | SHOW ALL PROPERTIES (LIKE STRING_LITERAL)? #showAllProperties + | SHOW COLLATION wildWhere? #showCollation + | SHOW ROW POLICY (FOR (userIdentify | (ROLE role=identifier)))? #showRowPolicy + | SHOW STORAGE POLICY (USING (FOR policy=identifierOrText)?)? #showStoragePolicy + | SHOW SQL_BLOCK_RULE (FOR ruleName=identifier)? #showSqlBlockRule + | SHOW CREATE VIEW name=multipartIdentifier #showCreateView + | SHOW CREATE STORAGE VAULT identifier #showCreateStorageVault + | SHOW DATA TYPES #showDataTypes + | SHOW DATA (ALL)? (FROM tableName=multipartIdentifier)? + sortClause? propertyClause? #showData + | SHOW CREATE MATERIALIZED VIEW mvName=identifier + ON tableName=multipartIdentifier #showCreateMaterializedView + | SHOW (WARNINGS | ERRORS) limitClause? #showWarningErrors + | SHOW COUNT LEFT_PAREN ASTERISK RIGHT_PAREN (WARNINGS | ERRORS) #showWarningErrorCount + | SHOW BACKENDS #showBackends + | SHOW STAGES #showStages + | SHOW REPLICA DISTRIBUTION FROM baseTableRef #showReplicaDistribution + | SHOW RESOURCES wildWhere? sortClause? limitClause? #showResources + | SHOW STREAM? LOAD ((FROM | IN) database=identifier)? wildWhere? + sortClause? limitClause? #showLoad + | SHOW LOAD WARNINGS ((((FROM | IN) database=identifier)? + wildWhere? limitClause?) | (ON url=STRING_LITERAL)) #showLoadWarings + | SHOW FULL? TRIGGERS ((FROM | IN) database=multipartIdentifier)? wildWhere? #showTriggers + | SHOW TABLET DIAGNOSIS tabletId=INTEGER_VALUE #showDiagnoseTablet + | SHOW OPEN TABLES ((FROM | IN) database=multipartIdentifier)? wildWhere? #showOpenTables + | SHOW FRONTENDS name=identifier? #showFrontends + | SHOW DATABASE databaseId=INTEGER_VALUE #showDatabaseId + | SHOW FULL? (COLUMNS | FIELDS) (FROM | IN) tableName=multipartIdentifier + ((FROM | IN) database=multipartIdentifier)? wildWhere? #showColumns + | SHOW TABLE tableId=INTEGER_VALUE #showTableId + | SHOW TRASH (ON backend=STRING_LITERAL)? #showTrash + | SHOW TYPECAST ((FROM | IN) database=identifier)? #showTypeCast + | SHOW (CLUSTERS | (COMPUTE GROUPS)) #showClusters + | SHOW statementScope? STATUS #showStatus + | SHOW WHITELIST #showWhitelist + | SHOW TABLETS BELONG + tabletIds+=INTEGER_VALUE (COMMA tabletIds+=INTEGER_VALUE)* #showTabletsBelong + | SHOW DATA SKEW FROM baseTableRef #showDataSkew + | SHOW TABLE CREATION ((FROM | IN) database=multipartIdentifier)? + (LIKE STRING_LITERAL)? #showTableCreation + | SHOW TABLET STORAGE FORMAT VERBOSE? #showTabletStorageFormat + | SHOW QUERY PROFILE queryIdPath=STRING_LITERAL? limitClause? #showQueryProfile + | SHOW CONVERT_LSC ((FROM | IN) database=multipartIdentifier)? #showConvertLsc + | SHOW FULL? TABLES ((FROM | IN) database=multipartIdentifier)? wildWhere? #showTables + | SHOW FULL? VIEWS ((FROM | IN) database=multipartIdentifier)? wildWhere? #showViews + | SHOW TABLE STATUS ((FROM | IN) database=multipartIdentifier)? wildWhere? #showTableStatus + | SHOW (DATABASES | SCHEMAS) (FROM catalog=identifier)? wildWhere? #showDatabases + | SHOW TABLETS FROM tableName=multipartIdentifier partitionSpec? + wildWhere? sortClause? limitClause? #showTabletsFromTable + | SHOW CATALOG RECYCLE BIN (WHERE expression)? #showCatalogRecycleBin + | SHOW TABLET tabletId=INTEGER_VALUE #showTabletId + | SHOW DICTIONARIES wildWhere? #showDictionaries + | SHOW TRANSACTION ((FROM | IN) database=multipartIdentifier)? wildWhere? #showTransaction + | SHOW REPLICA STATUS FROM baseTableRef whereClause? #showReplicaStatus + | SHOW WORKLOAD GROUPS (LIKE STRING_LITERAL)? #showWorkloadGroups + | SHOW COPY ((FROM | IN) database=identifier)? + whereClause? sortClause? limitClause? #showCopy + | SHOW QUERY STATS ((FOR database=identifier) + | (FROM tableName=multipartIdentifier (ALL VERBOSE?)?))? #showQueryStats + | SHOW (KEY | KEYS | INDEX | INDEXES) + (FROM |IN) tableName=multipartIdentifier + ((FROM | IN) database=multipartIdentifier)? #showIndex + | SHOW WARM UP JOB wildWhere? #showWarmUpJob + ; + +supportedLoadStatement + : SYNC #sync + | SHOW CREATE LOAD FOR label=multipartIdentifier #showCreateLoad + | createRoutineLoad #createRoutineLoadAlias + | LOAD mysqlDataDesc + (PROPERTIES LEFT_PAREN properties=propertyItemList RIGHT_PAREN)? + (commentSpec)? #mysqlLoad + | SHOW ALL? CREATE ROUTINE LOAD FOR label=multipartIdentifier #showCreateRoutineLoad + | PAUSE ROUTINE LOAD FOR label=multipartIdentifier #pauseRoutineLoad + | PAUSE ALL ROUTINE LOAD #pauseAllRoutineLoad + | RESUME ROUTINE LOAD FOR label=multipartIdentifier #resumeRoutineLoad + | RESUME ALL ROUTINE LOAD #resumeAllRoutineLoad + | STOP ROUTINE LOAD FOR label=multipartIdentifier #stopRoutineLoad + | SHOW ALL? ROUTINE LOAD ((FOR label=multipartIdentifier) | (LIKE STRING_LITERAL)?) #showRoutineLoad + | SHOW ROUTINE LOAD TASK ((FROM | IN) database=identifier)? wildWhere? #showRoutineLoadTask + | SHOW INVERTED INDEX ANALYZER #showIndexAnalyzer + | SHOW INVERTED INDEX TOKENIZER #showIndexTokenizer + | SHOW INVERTED INDEX TOKEN_FILTER #showIndexTokenFilter + | SHOW INVERTED INDEX CHAR_FILTER #showIndexCharFilter + ; + +supportedKillStatement + : KILL (CONNECTION)? INTEGER_VALUE #killConnection + | KILL QUERY (INTEGER_VALUE | STRING_LITERAL) #killQuery + ; + +supportedOtherStatement + : HELP mark=identifierOrText #help + | UNLOCK TABLES #unlockTables + | INSTALL PLUGIN FROM source=identifierOrText properties=propertyClause? #installPlugin + | UNINSTALL PLUGIN name=identifierOrText #uninstallPlugin + | LOCK TABLES (lockTable (COMMA lockTable)*)? #lockTables + | RESTORE SNAPSHOT label=multipartIdentifier FROM repo=identifier + ((ON | EXCLUDE) LEFT_PAREN baseTableRef (COMMA baseTableRef)* RIGHT_PAREN)? + properties=propertyClause? #restore + | WARM UP (CLUSTER | COMPUTE GROUP) destination=identifier WITH + ((CLUSTER | COMPUTE GROUP) source=identifier | + (warmUpItem (AND warmUpItem)*)) FORCE? + properties=propertyClause? #warmUpCluster + | explain? WARM UP SELECT namedExpressionSeq + FROM warmUpSingleTableRef whereClause? #warmUpSelect + | BACKUP SNAPSHOT label=multipartIdentifier TO repo=identifier + ((ON | EXCLUDE) LEFT_PAREN baseTableRef (COMMA baseTableRef)* RIGHT_PAREN)? + properties=propertyClause? #backup + | START TRANSACTION (WITH CONSISTENT SNAPSHOT)? #unsupportedStartTransaction + ; + + warmUpItem + : TABLE tableName=multipartIdentifier (PARTITION partitionName=identifier)? + ; + +warmUpSingleTableRef + : multipartIdentifier tableAlias? + ; + +lockTable + : name=multipartIdentifier (AS alias=identifierOrText)? + (READ (LOCAL)? | (LOW_PRIORITY)? WRITE) + ; + +createRoutineLoad + : CREATE ROUTINE LOAD label=multipartIdentifier (ON table=identifier)? + (WITH (APPEND | DELETE | MERGE))? + (loadProperty (COMMA loadProperty)*)? propertyClause? FROM type=identifier + LEFT_PAREN customProperties=propertyItemList RIGHT_PAREN + commentSpec? + ; + +loadProperty + : COLUMNS TERMINATED BY STRING_LITERAL #separator + | importColumnsStatement #importColumns + | importPrecedingFilterStatement #importPrecedingFilter + | importWhereStatement #importWhere + | importDeleteOnStatement #importDeleteOn + | importSequenceStatement #importSequence + | partitionSpec #importPartitions + ; + +importSequenceStatement + : ORDER BY identifier + ; + +importDeleteOnStatement + : DELETE ON booleanExpression + ; + +importWhereStatement + : WHERE booleanExpression + ; + +importPrecedingFilterStatement + : PRECEDING FILTER booleanExpression + ; + +importColumnsStatement + : COLUMNS LEFT_PAREN importColumnDesc (COMMA importColumnDesc)* RIGHT_PAREN + ; + +importColumnDesc + : name=identifier (EQ booleanExpression)? + | LEFT_PAREN name=identifier (EQ booleanExpression)? RIGHT_PAREN + ; + +supportedRefreshStatement + : REFRESH CATALOG name=identifier propertyClause? #refreshCatalog + | REFRESH DATABASE name=multipartIdentifier propertyClause? #refreshDatabase + | REFRESH TABLE name=multipartIdentifier #refreshTable + | REFRESH DICTIONARY name=multipartIdentifier #refreshDictionary + | REFRESH LDAP (ALL | (FOR user=identifierOrText)) #refreshLdap + ; + +supportedCleanStatement + : CLEAN ALL PROFILE #cleanAllProfile + | CLEAN LABEL label=identifier? (FROM | IN) database=identifier #cleanLabel + | CLEAN QUERY STATS ((FOR database=identifier) + | ((FROM | IN) table=multipartIdentifier)) #cleanQueryStats + | CLEAN ALL QUERY STATS #cleanAllQueryStats + ; + +supportedCancelStatement + : CANCEL LOAD ((FROM | IN) database=identifier)? wildWhere? #cancelLoad + | CANCEL EXPORT ((FROM | IN) database=identifier)? wildWhere? #cancelExport + | CANCEL WARM UP JOB wildWhere? #cancelWarmUpJob + | CANCEL DECOMMISSION BACKEND hostPorts+=STRING_LITERAL + (COMMA hostPorts+=STRING_LITERAL)* #cancelDecommisionBackend + | CANCEL BACKUP ((FROM | IN) database=identifier)? #cancelBackup + | CANCEL RESTORE ((FROM | IN) database=identifier)? #cancelRestore + | CANCEL BUILD INDEX ON tableName=multipartIdentifier + (LEFT_PAREN jobIds+=INTEGER_VALUE + (COMMA jobIds+=INTEGER_VALUE)* RIGHT_PAREN)? #cancelBuildIndex + | CANCEL ALTER TABLE (ROLLUP | (MATERIALIZED VIEW) | COLUMN) + FROM tableName=multipartIdentifier (LEFT_PAREN jobIds+=INTEGER_VALUE + (COMMA jobIds+=INTEGER_VALUE)* RIGHT_PAREN)? #cancelAlterTable + ; + +supportedAdminStatement + : ADMIN SHOW REPLICA DISTRIBUTION FROM baseTableRef #adminShowReplicaDistribution + | ADMIN REBALANCE DISK (ON LEFT_PAREN backends+=STRING_LITERAL + (COMMA backends+=STRING_LITERAL)* RIGHT_PAREN)? #adminRebalanceDisk + | ADMIN CANCEL REBALANCE DISK (ON LEFT_PAREN backends+=STRING_LITERAL + (COMMA backends+=STRING_LITERAL)* RIGHT_PAREN)? #adminCancelRebalanceDisk + | ADMIN DIAGNOSE TABLET tabletId=INTEGER_VALUE #adminDiagnoseTablet + | ADMIN SHOW REPLICA STATUS FROM baseTableRef (WHERE STATUS EQ|NEQ STRING_LITERAL)? #adminShowReplicaStatus + | ADMIN COMPACT TABLE baseTableRef (WHERE TYPE EQ STRING_LITERAL)? #adminCompactTable + | ADMIN CHECK tabletList properties=propertyClause? #adminCheckTablets + | ADMIN SHOW TABLET STORAGE FORMAT VERBOSE? #adminShowTabletStorageFormat + | ADMIN SET (FRONTEND | (ALL FRONTENDS)) CONFIG + (LEFT_PAREN propertyItemList RIGHT_PAREN)? ALL? #adminSetFrontendConfig + | ADMIN CLEAN TRASH + (ON LEFT_PAREN backends+=STRING_LITERAL + (COMMA backends+=STRING_LITERAL)* RIGHT_PAREN)? #adminCleanTrash + | ADMIN SET REPLICA VERSION PROPERTIES LEFT_PAREN propertyItemList RIGHT_PAREN #adminSetReplicaVersion + | ADMIN SET TABLE name=multipartIdentifier STATUS properties=propertyClause? #adminSetTableStatus + | ADMIN SET REPLICA STATUS PROPERTIES LEFT_PAREN propertyItemList RIGHT_PAREN #adminSetReplicaStatus + | ADMIN REPAIR TABLE baseTableRef #adminRepairTable + | ADMIN CANCEL REPAIR TABLE baseTableRef #adminCancelRepairTable + | ADMIN COPY TABLET tabletId=INTEGER_VALUE properties=propertyClause? #adminCopyTablet + | ADMIN SET ENCRYPTION ROOT KEY PROPERTIES LEFT_PAREN propertyItemList RIGHT_PAREN #adminSetEncryptionRootKey + | ADMIN SET TABLE name=multipartIdentifier + PARTITION VERSION properties=propertyClause? #adminSetPartitionVersion + | ADMIN CREATE CLUSTER SNAPSHOT propertyClause? #adminCreateClusterSnapshot + | ADMIN SET AUTO CLUSTER SNAPSHOT propertyClause? #adminSetAutoClusterSnapshot + | ADMIN DROP CLUSTER SNAPSHOT WHERE (key=identifier) EQ (value=STRING_LITERAL) #adminDropClusterSnapshot + | ADMIN SET CLUSTER SNAPSHOT FEATURE (ON | OFF) #adminSetClusterSnapshotFeatureSwitch + | ADMIN ROTATE TDE ROOT KEY properties=propertyClause? #adminRotateTdeRootKey + ; + +supportedRecoverStatement + : RECOVER DATABASE name=identifier id=INTEGER_VALUE? (AS alias=identifier)? #recoverDatabase + | RECOVER TABLE name=multipartIdentifier + id=INTEGER_VALUE? (AS alias=identifier)? #recoverTable + | RECOVER PARTITION name=identifier id=INTEGER_VALUE? (AS alias=identifier)? + FROM tableName=multipartIdentifier #recoverPartition + ; + +baseTableRef + : multipartIdentifier optScanParams? tableSnapshot? specifiedPartition? + tabletList? tableAlias sample? relationHint? + ; + +wildWhere + : LIKE STRING_LITERAL + | WHERE expression + ; + +supportedTransactionStatement + : BEGIN (WITH LABEL identifier?)? #transactionBegin + | COMMIT WORK? (AND NO? CHAIN)? (NO? RELEASE)? #transcationCommit + | ROLLBACK WORK? (AND NO? CHAIN)? (NO? RELEASE)? #transactionRollback + ; + +supportedGrantRevokeStatement + : GRANT privilegeList ON multipartIdentifierOrAsterisk + TO (userIdentify | ROLE identifierOrText) #grantTablePrivilege + | GRANT privilegeList ON + (RESOURCE | CLUSTER | COMPUTE GROUP | STAGE | STORAGE VAULT | WORKLOAD GROUP) + identifierOrTextOrAsterisk TO (userIdentify | ROLE identifierOrText) #grantResourcePrivilege + | GRANT roles+=identifierOrText (COMMA roles+=identifierOrText)* TO userIdentify #grantRole + | REVOKE roles+=identifierOrText (COMMA roles+=identifierOrText)* FROM userIdentify #revokeRole + | REVOKE privilegeList ON + (RESOURCE | CLUSTER | COMPUTE GROUP | STAGE | STORAGE VAULT | WORKLOAD GROUP) + identifierOrTextOrAsterisk FROM (userIdentify | ROLE identifierOrText) #revokeResourcePrivilege + | REVOKE privilegeList ON multipartIdentifierOrAsterisk + FROM (userIdentify | ROLE identifierOrText) #revokeTablePrivilege + ; + +privilege + : name=identifier columns=identifierList? + | ALL + ; + +privilegeList + : privilege (COMMA privilege)* + ; + +alterSystemClause + : ADD BACKEND hostPorts+=STRING_LITERAL (COMMA hostPorts+=STRING_LITERAL)* + properties=propertyClause? #addBackendClause + | (DROP | DROPP) BACKEND hostPorts+=STRING_LITERAL + (COMMA hostPorts+=STRING_LITERAL)* #dropBackendClause + | DECOMMISSION BACKEND hostPorts+=STRING_LITERAL + (COMMA hostPorts+=STRING_LITERAL)* #decommissionBackendClause + | ADD OBSERVER hostPort=STRING_LITERAL #addObserverClause + | DROP OBSERVER hostPort=STRING_LITERAL #dropObserverClause + | ADD FOLLOWER hostPort=STRING_LITERAL #addFollowerClause + | DROP FOLLOWER hostPort=STRING_LITERAL #dropFollowerClause + | ADD BROKER name=identifierOrText hostPorts+=STRING_LITERAL + (COMMA hostPorts+=STRING_LITERAL)* #addBrokerClause + | DROP BROKER name=identifierOrText hostPorts+=STRING_LITERAL + (COMMA hostPorts+=STRING_LITERAL)* #dropBrokerClause + | DROP ALL BROKER name=identifierOrText #dropAllBrokerClause + | SET LOAD ERRORS HUB properties=propertyClause? #alterLoadErrorUrlClause + | MODIFY BACKEND hostPorts+=STRING_LITERAL + (COMMA hostPorts+=STRING_LITERAL)* + SET LEFT_PAREN propertyItemList RIGHT_PAREN #modifyBackendClause + | MODIFY (FRONTEND | BACKEND) hostPort=STRING_LITERAL + HOSTNAME hostName=STRING_LITERAL #modifyFrontendOrBackendHostNameClause + ; + +dropRollupClause + : rollupName=identifier properties=propertyClause? + ; + +addRollupClause + : rollupName=identifier columns=identifierList + (DUPLICATE KEY dupKeys=identifierList)? fromRollup? + properties=propertyClause? + ; + +alterTableClause + : ADD COLUMN columnDef columnPosition? toRollup? properties=propertyClause? #addColumnClause + | ADD COLUMN LEFT_PAREN columnDefs RIGHT_PAREN + toRollup? properties=propertyClause? #addColumnsClause + | DROP COLUMN name=identifier fromRollup? properties=propertyClause? #dropColumnClause + | MODIFY COLUMN columnDef columnPosition? fromRollup? + properties=propertyClause? #modifyColumnClause + | ORDER BY identifierList fromRollup? properties=propertyClause? #reorderColumnsClause + | ADD TEMPORARY? partitionDef + (DISTRIBUTED BY (HASH hashKeys=identifierList | RANDOM) + (BUCKETS (INTEGER_VALUE | autoBucket=AUTO))?)? + properties=propertyClause? #addPartitionClause + | DROP TEMPORARY? PARTITION (IF EXISTS)? partitionName=identifier FORCE? + (FROM INDEX indexName=identifier)? #dropPartitionClause + | MODIFY TEMPORARY? PARTITION + (partitionName=identifier | partitionNames=identifierList + | LEFT_PAREN ASTERISK RIGHT_PAREN) + SET LEFT_PAREN partitionProperties=propertyItemList RIGHT_PAREN #modifyPartitionClause + | REPLACE partitions=partitionSpec? WITH tempPartitions=partitionSpec? + FORCE? properties=propertyClause? #replacePartitionClause + | REPLACE WITH TABLE name=identifier properties=propertyClause? FORCE? #replaceTableClause + | RENAME newName=identifier #renameClause + | RENAME ROLLUP name=identifier newName=identifier #renameRollupClause + | RENAME PARTITION name=identifier newName=identifier #renamePartitionClause + | RENAME COLUMN name=identifier newName=identifier #renameColumnClause + | ADD indexDef #addIndexClause + | DROP INDEX (IF EXISTS)? name=identifier #dropIndexClause + | ENABLE FEATURE name=STRING_LITERAL (WITH properties=propertyClause)? #enableFeatureClause + | MODIFY DISTRIBUTION (DISTRIBUTED BY (HASH hashKeys=identifierList | RANDOM) + (BUCKETS (INTEGER_VALUE | autoBucket=AUTO))?)? #modifyDistributionClause + | MODIFY COMMENT comment=STRING_LITERAL #modifyTableCommentClause + | MODIFY COLUMN name=identifier COMMENT comment=STRING_LITERAL #modifyColumnCommentClause + | MODIFY ENGINE TO name=identifier properties=propertyClause? #modifyEngineClause + | ADD TEMPORARY? PARTITIONS + FROM from=partitionValueList TO to=partitionValueList + INTERVAL INTEGER_VALUE unit=identifier? properties=propertyClause? #alterMultiPartitionClause + | createOrReplaceTagClause #createOrReplaceTagClauses + | createOrReplaceBranchClause #createOrReplaceBranchClauses + | dropBranchClause #dropBranchClauses + | dropTagClause #dropTagClauses + | ADD PARTITION KEY partitionTransform (AS partitionFieldName=identifier)? #addPartitionFieldClause + | DROP PARTITION KEY (partitionFieldName=identifier | partitionTransform) #dropPartitionFieldClause + | REPLACE PARTITION KEY + (oldPartitionFieldName=identifier | oldPartitionTransform=partitionTransform) + WITH newPartitionTransform=partitionTransform (AS newPartitionFieldName=identifier)? + #replacePartitionFieldClause + ; + +createOrReplaceTagClause + : CREATE TAG (IF NOT EXISTS)? name=identifier ops=tagOptions + | (CREATE OR)? REPLACE TAG name=identifier ops=tagOptions + ; + +createOrReplaceBranchClause + : CREATE BRANCH (IF NOT EXISTS)? name=identifier ops=branchOptions + | (CREATE OR)? REPLACE BRANCH name=identifier ops=branchOptions + ; + +tagOptions + : (AS OF VERSION version=INTEGER_VALUE)? (retainTime)? + ; + +branchOptions + : (AS OF VERSION version=INTEGER_VALUE)? (retainTime)? (retentionSnapshot)? + ; + +retainTime + : RETAIN timeValueWithUnit + ; + +retentionSnapshot + : WITH SNAPSHOT RETENTION minSnapshotsToKeep + | WITH SNAPSHOT RETENTION timeValueWithUnit + | WITH SNAPSHOT RETENTION minSnapshotsToKeep timeValueWithUnit + ; + +minSnapshotsToKeep + : value=INTEGER_VALUE SNAPSHOTS + ; + +timeValueWithUnit + : timeValue=INTEGER_VALUE timeUnit=(DAYS | HOURS | MINUTES) + ; + +dropBranchClause + : DROP BRANCH (IF EXISTS)? name=identifier + ; + +dropTagClause + : DROP TAG (IF EXISTS)? name=identifier + ; + +partitionTransform + : identifier LEFT_PAREN INTEGER_VALUE COMMA identifier RIGHT_PAREN #partitionTransformWithArgs + | identifier LEFT_PAREN identifier RIGHT_PAREN #partitionTransformWithColumn + | identifier #partitionTransformIdentity + ; + +columnPosition + : FIRST + | AFTER position=identifier + ; + +toRollup + : (TO | IN) rollup=identifier + ; + +fromRollup + : FROM rollup=identifier + ; + +supportedStatsStatement + : SHOW AUTO? ANALYZE (jobId=INTEGER_VALUE | tableName=multipartIdentifier)? + (WHERE (stateKey=identifier) EQ (stateValue=STRING_LITERAL))? #showAnalyze + | SHOW QUEUED ANALYZE JOBS tableName=multipartIdentifier? + (WHERE (stateKey=identifier) EQ (stateValue=STRING_LITERAL))? #showQueuedAnalyzeJobs + | SHOW COLUMN HISTOGRAM tableName=multipartIdentifier + columnList=identifierList #showColumnHistogramStats + | SHOW COLUMN CACHED? STATS tableName=multipartIdentifier + columnList=identifierList? partitionSpec? #showColumnStats + | SHOW ANALYZE TASK STATUS jobId=INTEGER_VALUE #showAnalyzeTask + | ANALYZE DATABASE name=multipartIdentifier + (WITH analyzeProperties)* propertyClause? #analyzeDatabase + | ANALYZE TABLE name=multipartIdentifier partitionSpec? + columns=identifierList? (WITH analyzeProperties)* propertyClause? #analyzeTable + | ALTER TABLE name=multipartIdentifier SET STATS + LEFT_PAREN propertyItemList RIGHT_PAREN partitionSpec? #alterTableStats + | ALTER TABLE name=multipartIdentifier (INDEX indexName=identifier)? + MODIFY COLUMN columnName=identifier + SET STATS LEFT_PAREN propertyItemList RIGHT_PAREN partitionSpec? #alterColumnStats + | SHOW INDEX STATS tableName=multipartIdentifier indexId=identifier #showIndexStats + | DROP STATS tableName=multipartIdentifier + columns=identifierList? partitionSpec? #dropStats + | DROP CACHED STATS tableName=multipartIdentifier #dropCachedStats + | DROP EXPIRED STATS #dropExpiredStats + | KILL ANALYZE jobId=INTEGER_VALUE #killAnalyzeJob + | DROP ANALYZE JOB INTEGER_VALUE #dropAnalyzeJob + | SHOW TABLE STATS tableName=multipartIdentifier + partitionSpec? columnList=identifierList? #showTableStats + | SHOW TABLE STATS tableId=INTEGER_VALUE #showTableStats + ; + +analyzeProperties + : SYNC + | INCREMENTAL + | FULL + | SQL + | HISTOGRAM + | (SAMPLE ((ROWS rows=INTEGER_VALUE) | (PERCENT percent=INTEGER_VALUE)) ) + | (BUCKETS bucket=INTEGER_VALUE) + | (PERIOD periodInSecond=INTEGER_VALUE) + | (CRON crontabExpr=STRING_LITERAL) + ; + +workloadPolicyActions + : workloadPolicyAction (COMMA workloadPolicyAction)* + ; + +workloadPolicyAction + : SET_SESSION_VARIABLE STRING_LITERAL + | identifier (STRING_LITERAL)? + ; + +workloadPolicyConditions + : workloadPolicyCondition (COMMA workloadPolicyCondition)* + ; + +workloadPolicyCondition + : metricName=identifier comparisonOperator (number | STRING_LITERAL) + ; + +storageBackend + : (BROKER | S3 | HDFS | LOCAL) brokerName=identifier? + ON LOCATION STRING_LITERAL properties=propertyClause? + ; + +passwordOption + : (PASSWORD_HISTORY (historyDefault=DEFAULT | historyValue=INTEGER_VALUE))? + (PASSWORD_EXPIRE (expireDefault=DEFAULT | expireNever=NEVER + | INTERVAL expireValue=INTEGER_VALUE expireTimeUnit=(DAY | HOUR | SECOND)))? + (PASSWORD_REUSE INTERVAL (reuseDefault=DEFAULT | reuseValue=INTEGER_VALUE DAY))? + (FAILED_LOGIN_ATTEMPTS attemptsValue=INTEGER_VALUE)? + (PASSWORD_LOCK_TIME (lockUnbounded=UNBOUNDED + | lockValue=INTEGER_VALUE lockTimeUint=(DAY | HOUR | SECOND)))? + (ACCOUNT_LOCK | ACCOUNT_UNLOCK)? + ; + +functionArguments + : DOTDOTDOT + | dataTypeList + | dataTypeList COMMA DOTDOTDOT + ; + +dataTypeList + : dataType (COMMA dataType)* + ; + +supportedSetStatement + : SET (optionWithType | optionWithoutType) + (COMMA (optionWithType | optionWithoutType))* #setOptions + | SET identifier AS DEFAULT STORAGE VAULT #setDefaultStorageVault + | SET PROPERTY (FOR user=identifierOrText)? propertyItemList #setUserProperties + | SET statementScope? TRANSACTION + ( transactionAccessMode + | isolationLevel + | transactionAccessMode COMMA isolationLevel + | isolationLevel COMMA transactionAccessMode) #setTransaction + ; + +optionWithType + : statementScope identifier EQ (expression | DEFAULT | ON | ALL) #setVariableWithType + ; + +optionWithoutType + : NAMES EQ expression #setNames + | (CHAR SET | CHARSET) (charsetName=identifierOrText | DEFAULT) #setCharset + | NAMES (charsetName=identifierOrText | DEFAULT) + (COLLATE collateName=identifierOrText | DEFAULT)? #setCollate + | PASSWORD (FOR userIdentify)? EQ (pwd=STRING_LITERAL + | (isPlain=PASSWORD LEFT_PAREN pwd=STRING_LITERAL RIGHT_PAREN)) #setPassword + | LDAP_ADMIN_PASSWORD EQ (pwd=STRING_LITERAL + | (PASSWORD LEFT_PAREN pwd=STRING_LITERAL RIGHT_PAREN)) #setLdapAdminPassword + | variable #setVariableWithoutType + ; + +variable + : (DOUBLEATSIGN (statementScope DOT)?)? identifier EQ + (expression | DEFAULT | ON | ALL) #setSystemVariable + | ATSIGN identifier EQ expression #setUserVariable + ; + +transactionAccessMode + : READ (ONLY | WRITE) + ; + +isolationLevel + : ISOLATION LEVEL ((READ UNCOMMITTED) | (READ COMMITTED) | (REPEATABLE READ) | (SERIALIZABLE)) + ; + +supportedUnsetStatement + : UNSET statementScope? VARIABLE (ALL | identifier) + | UNSET DEFAULT STORAGE VAULT + ; + +supportedUseStatement + : SWITCH catalog=identifier #switchCatalog + | USE (catalog=identifier DOT)? database=identifier #useDatabase + | USE ((catalog=identifier DOT)? database=identifier)? ATSIGN cluster=identifier #useCloudCluster + ; + +stageAndPattern + : ATSIGN (stage=identifier | TILDE) + (LEFT_PAREN pattern=STRING_LITERAL RIGHT_PAREN)? + ; + +supportedDescribeStatement + : explainCommand FUNCTION tvfName=identifier LEFT_PAREN + (properties=propertyItemList)? RIGHT_PAREN tableAlias #describeTableValuedFunction + | explainCommand multipartIdentifier ALL #describeTableAll + | explainCommand multipartIdentifier specifiedPartition? #describeTable + | explainCommand DICTIONARY multipartIdentifier #describeDictionary + ; + +constraint + : PRIMARY KEY slots=identifierList + | UNIQUE slots=identifierList + | FOREIGN KEY slots=identifierList + REFERENCES referenceTable=multipartIdentifier + referencedSlots=identifierList + ; + +partitionSpec + : TEMPORARY? (PARTITION | PARTITIONS) partitions=identifierList + | TEMPORARY? PARTITION partition=errorCapturingIdentifier + | (PARTITION | PARTITIONS) LEFT_PAREN ASTERISK RIGHT_PAREN // for auto detect partition in overwriting + // TODO: support analyze external table partition spec https://github.com/apache/doris/pull/24154 + // | PARTITIONS WITH RECENT + ; + +partitionTable + : ((autoPartition=AUTO)? PARTITION BY (RANGE | LIST)? partitionList=identityOrFunctionList + (LEFT_PAREN (partitions=partitionsDef)? RIGHT_PAREN)) + ; + +identityOrFunctionList + : LEFT_PAREN identityOrFunction (COMMA partitions+=identityOrFunction)* RIGHT_PAREN + ; + +identityOrFunction + : (identifier | functionCallExpression) + ; + +dataDesc + : ((WITH)? mergeType)? DATA INFILE LEFT_PAREN filePaths+=STRING_LITERAL (COMMA filePath+=STRING_LITERAL)* RIGHT_PAREN + (negative=NEGATIVE)? + INTO TABLE targetTableName=identifier + (partitionSpec)? + (COLUMNS TERMINATED BY comma=STRING_LITERAL)? + (LINES TERMINATED BY separator=STRING_LITERAL)? + (FORMAT AS format=identifierOrText)? + (COMPRESS_TYPE AS compressType=identifierOrText)? + (columns=identifierList)? + (columnsFromPath=colFromPath)? + (columnMapping=colMappingList)? + (preFilter=preFilterClause)? + (where=whereClause)? + (deleteOn=deleteOnClause)? + (sequenceColumn=sequenceColClause)? + (propertyClause)? + | ((WITH)? mergeType)? DATA FROM TABLE sourceTableName=identifier + (negative=NEGATIVE)? + INTO TABLE targetTableName=identifier + (PARTITION partition=identifierList)? + (columnMapping=colMappingList)? + (where=whereClause)? + (deleteOn=deleteOnClause)? + (propertyClause)? + ; + +// -----------------Command accessories----------------- +statementScope + : (GLOBAL | SESSION | LOCAL) + ; + +buildMode + : BUILD (IMMEDIATE | DEFERRED) + ; + +refreshTrigger + : ON MANUAL + | ON SCHEDULE refreshSchedule + | ON COMMIT + ; + +refreshSchedule + : EVERY INTEGER_VALUE refreshUnit = identifier (STARTS STRING_LITERAL)? + ; + +refreshMethod + : COMPLETE | AUTO + ; + +mvPartition + : partitionKey = identifier + | partitionExpr = functionCallExpression + ; + +identifierOrText + : identifier + | STRING_LITERAL + ; + +identifierOrTextOrAsterisk + : identifier + | STRING_LITERAL + | ASTERISK + ; + +multipartIdentifierOrAsterisk + : parts+=identifierOrAsterisk (DOT parts+=identifierOrAsterisk)* + ; + +identifierOrAsterisk + : identifierOrText + | ASTERISK + ; + +userIdentify + : user=identifierOrText (ATSIGN (host=identifierOrText + | LEFT_PAREN host=identifierOrText RIGHT_PAREN))? + ; + +grantUserIdentify + : userIdentify (IDENTIFIED BY PASSWORD? STRING_LITERAL)? + ; + +explain + : explainCommand planType? + level=(VERBOSE | TREE | GRAPH | PLAN | DUMP)? + PROCESS? + ; + +explainCommand + : EXPLAIN + | DESC + | DESCRIBE + ; + +planType + : PARSED + | ANALYZED + | REWRITTEN | LOGICAL // same type + | OPTIMIZED | PHYSICAL // same type + | SHAPE + | MEMO + | DISTRIBUTED + | ALL // default type + ; + +replayCommand + : PLAN REPLAYER replayType; + +replayType + : DUMP query + | PLAY filePath=STRING_LITERAL; + +mergeType + : APPEND + | DELETE + | MERGE + ; + +preFilterClause + : PRECEDING FILTER expression + ; + +deleteOnClause + : DELETE ON expression + ; + +sequenceColClause + : ORDER BY identifier + ; + +colFromPath + : COLUMNS FROM PATH AS identifierList + ; + +colMappingList + : SET LEFT_PAREN mappingSet+=mappingExpr (COMMA mappingSet+=mappingExpr)* RIGHT_PAREN + ; + +mappingExpr + : (mappingCol=identifier EQ expression) + ; + +withRemoteStorageSystem + : resourceDesc + | WITH S3 LEFT_PAREN + brokerProperties=propertyItemList + RIGHT_PAREN + | WITH HDFS LEFT_PAREN + brokerProperties=propertyItemList + RIGHT_PAREN + | WITH LOCAL LEFT_PAREN + brokerProperties=propertyItemList + RIGHT_PAREN + | WITH BROKER brokerName=identifierOrText + (LEFT_PAREN + brokerProperties=propertyItemList + RIGHT_PAREN)? + ; + +resourceDesc + : WITH RESOURCE resourceName=identifierOrText (LEFT_PAREN propertyItemList RIGHT_PAREN)? + ; + +mysqlDataDesc + : DATA LOCAL? + INFILE filePath=STRING_LITERAL + INTO TABLE tableName=multipartIdentifier + (PARTITION partition=identifierList)? + (COLUMNS TERMINATED BY comma=STRING_LITERAL)? + (LINES TERMINATED BY separator=STRING_LITERAL)? + (skipLines)? + (columns=identifierList)? + (colMappingList)? + (propertyClause)? + ; + +skipLines : IGNORE lines=INTEGER_VALUE LINES | IGNORE lines=INTEGER_VALUE ROWS ; + +// -----------------Query----------------- +// add queryOrganization for parse (q1) union (q2) union (q3) order by keys, otherwise 'order' will be recognized to be +// identifier. + +outFileClause + : INTO OUTFILE filePath=constant + (FORMAT AS format=identifier)? + (propertyClause)? + ; + +query + : cte? queryTerm queryOrganization + ; + +queryTerm + : queryPrimary #queryTermDefault + | left=queryTerm operator=INTERSECT setQuantifier? right=queryTerm #setOperation + | left=queryTerm operator=(UNION | EXCEPT | MINUS) + setQuantifier? right=queryTerm #setOperation + ; + +setQuantifier + : DISTINCT + | ALL + ; + +queryPrimary + : querySpecification #queryPrimaryDefault + | LEFT_PAREN query RIGHT_PAREN #subquery + | inlineTable #valuesTable + ; + +querySpecification + : selectClause + intoClause? + fromClause? + whereClause? + aggClause? + havingClause? + qualifyClause? + queryOrganization? #regularQuerySpecification + ; + +cte + : WITH aliasQuery (COMMA aliasQuery)* + ; + +aliasQuery + : identifier columnAliases? AS LEFT_PAREN query RIGHT_PAREN + ; + +columnAliases + : LEFT_PAREN identifier (COMMA identifier)* RIGHT_PAREN + ; + +selectClause + : SELECT (DISTINCT|ALL)? selectColumnClause + ; + +selectColumnClause + : namedExpressionSeq + ; + +whereClause + : WHERE booleanExpression + ; + +fromClause + : FROM relations + ; + +// For PL-SQL +intoClause + : bulkCollectClause? INTO (tableRow | identifier) (COMMA (tableRow | identifier))* + ; + +bulkCollectClause : + BULK COLLECT + ; + +tableRow : + identifier LEFT_PAREN INTEGER_VALUE RIGHT_PAREN + ; + +relations + : relation (COMMA relation)* + ; + +relation + : relationPrimary joinRelation* + ; + +joinRelation + : (joinType) JOIN distributeType? right=relationPrimary joinCriteria? + ; + +// Just like `opt_plan_hints` in legacy CUP parser. +distributeType + : LEFT_BRACKET identifier skewHint? RIGHT_BRACKET + | HINT_START identifier skewHint? HINT_END + ; + +skewHint + : LEFT_BRACKET identifier LEFT_PAREN qualifiedName constantList RIGHT_PAREN RIGHT_BRACKET + ; + +constantList + : LEFT_PAREN values+=constant (COMMA values+=constant)* RIGHT_PAREN + ; + +relationHint + : LEFT_BRACKET identifier (COMMA identifier)* RIGHT_BRACKET #bracketRelationHint + | HINT_START identifier (COMMA identifier)* HINT_END #commentRelationHint + ; + +expressionWithOrder + : expression ordering = (ASC | DESC)? + ; + +aggClause + : GROUP BY groupingElement + ; + +groupingElement + : ROLLUP LEFT_PAREN (expression (COMMA expression)*)? RIGHT_PAREN + | CUBE LEFT_PAREN (expression (COMMA expression)*)? RIGHT_PAREN + | GROUPING SETS LEFT_PAREN groupingSet (COMMA groupingSet)* RIGHT_PAREN + | expressionWithOrder (COMMA expressionWithOrder)* (WITH ROLLUP)? + ; + +groupingSet + : LEFT_PAREN (expression (COMMA expression)*)? RIGHT_PAREN + ; + +havingClause + : HAVING booleanExpression + ; + +qualifyClause + : QUALIFY booleanExpression + ; + +selectHint: hintStatements+=hintStatement (COMMA? hintStatements+=hintStatement)* HINT_END; + +hintStatement + : hintName (LEFT_PAREN parameters+=hintAssignment (COMMA? parameters+=hintAssignment)* RIGHT_PAREN)? + | (USE_MV | NO_USE_MV) (LEFT_PAREN tableList+=multipartIdentifier (COMMA tableList+=multipartIdentifier)* RIGHT_PAREN)? + ; + +hintName + : identifier + | LEADING + ; + +hintAssignment + : key=identifierOrText skew=skewHint? (EQ (constantValue=constant | identifierValue=identifier))? + | constant + ; + +updateAssignment + : col=multipartIdentifier EQ (expression | DEFAULT) + ; + +updateAssignmentSeq + : assignments+=updateAssignment (COMMA assignments+=updateAssignment)* + ; + +lateralView + : LATERAL VIEW functionName=identifier LEFT_PAREN (expression (COMMA expression)*)? RIGHT_PAREN + tableName=identifier AS columnNames+=identifier (COMMA columnNames+=identifier)* + ; + +queryOrganization + : sortClause? limitClause? + ; + +sortClause + : ORDER BY sortItem (COMMA sortItem)* + ; + +sortItem + : expression ordering = (ASC | DESC)? (NULLS (FIRST | LAST))? + ; + +limitClause + : (LIMIT limit=INTEGER_VALUE) + | (LIMIT limit=INTEGER_VALUE OFFSET offset=INTEGER_VALUE) + | (LIMIT offset=INTEGER_VALUE COMMA limit=INTEGER_VALUE) + ; + +partitionClause + : PARTITION BY (LEFT_BRACKET identifier RIGHT_BRACKET)? expression (COMMA expression)* + ; + +joinType + : INNER? + | CROSS + | LEFT OUTER? + | RIGHT OUTER? + | FULL OUTER? + | LEFT SEMI + | RIGHT SEMI + | LEFT ANTI + | RIGHT ANTI + ; + +joinCriteria + : ON booleanExpression + | USING identifierList + ; + +identifierList + : LEFT_PAREN identifierSeq RIGHT_PAREN + ; + +identifierSeq + : ident+=errorCapturingIdentifier (COMMA ident+=errorCapturingIdentifier)* + ; + +optScanParams + : ATSIGN funcName=identifier LEFT_PAREN (mapParams=propertyItemList | listParams=identifierSeq)? RIGHT_PAREN + ; + +relationPrimary + : multipartIdentifier optScanParams? materializedViewName? tableSnapshot? specifiedPartition? + tabletList? tableAlias sample? relationHint? lateralView* #tableName + | LEFT_PAREN query RIGHT_PAREN tableAlias lateralView* #aliasedQuery + | tvfName=identifier LEFT_PAREN + (properties=propertyItemList)? + RIGHT_PAREN tableAlias #tableValuedFunction + | LEFT_PAREN relations RIGHT_PAREN #relationList + ; + +materializedViewName + : INDEX indexName=identifier + ; + +propertyClause + : PROPERTIES LEFT_PAREN fileProperties=propertyItemList RIGHT_PAREN + ; + +propertyItemList + : properties+=propertyItem (COMMA properties+=propertyItem)* + ; + +propertyItem + : key=propertyKey EQ value=propertyValue + ; + +propertyKey : identifier | constant ; + +propertyValue : identifier | constant ; + +tableAlias + : (AS? strictIdentifier identifierList?)? + ; + +multipartIdentifier + : parts+=errorCapturingIdentifier (DOT parts+=errorCapturingIdentifier)* + ; + +// ----------------Create Table Fields---------- +simpleColumnDefs + : cols+=simpleColumnDef (COMMA cols+=simpleColumnDef)* + ; + +simpleColumnDef + : colName=identifier (COMMENT comment=STRING_LITERAL)? + ; + +columnDefs + : cols+=columnDef (COMMA cols+=columnDef)* + ; + +columnDef + : colName=identifier type=dataType + KEY? + (aggType=aggTypeDef)? + ((GENERATED ALWAYS)? AS LEFT_PAREN generatedExpr=expression RIGHT_PAREN)? + ((NOT)? nullable=NULL)? + (AUTO_INCREMENT (LEFT_PAREN autoIncInitValue=number RIGHT_PAREN)?)? + (DEFAULT (nullValue=NULL | SUBTRACT? INTEGER_VALUE | SUBTRACT? DECIMAL_VALUE | PI | E | BITMAP_EMPTY | stringValue=STRING_LITERAL + | CURRENT_DATE | defaultTimestamp=CURRENT_TIMESTAMP (LEFT_PAREN defaultValuePrecision=number RIGHT_PAREN)?))? + (ON UPDATE CURRENT_TIMESTAMP (LEFT_PAREN onUpdateValuePrecision=number RIGHT_PAREN)?)? + (COMMENT comment=STRING_LITERAL)? + ; + +indexDefs + : indexes+=indexDef (COMMA indexes+=indexDef)* + ; + +indexDef + : INDEX (ifNotExists=IF NOT EXISTS)? indexName=identifier cols=identifierList (USING indexType=(BITMAP | INVERTED | NGRAM_BF | ANN ))? (PROPERTIES LEFT_PAREN properties=propertyItemList RIGHT_PAREN)? (COMMENT comment=STRING_LITERAL)? + ; + +partitionsDef + : partitions+=partitionDef (COMMA partitions+=partitionDef)* + ; + +partitionDef + : (lessThanPartitionDef | fixedPartitionDef | stepPartitionDef | inPartitionDef) (LEFT_PAREN partitionProperties=propertyItemList RIGHT_PAREN)? + ; + +lessThanPartitionDef + : PARTITION (IF NOT EXISTS)? partitionName=identifier VALUES LESS THAN (MAXVALUE | partitionValueList) + ; + +fixedPartitionDef + : PARTITION (IF NOT EXISTS)? partitionName=identifier VALUES LEFT_BRACKET lower=partitionValueList COMMA upper=partitionValueList RIGHT_PAREN + ; + +stepPartitionDef + : FROM from=partitionValueList TO to=partitionValueList INTERVAL unitsAmount=INTEGER_VALUE unit=unitIdentifier? + ; + +inPartitionDef + : PARTITION (IF NOT EXISTS)? partitionName=identifier ((VALUES IN)? ((LEFT_PAREN partitionValueLists+=partitionValueList + (COMMA partitionValueLists+=partitionValueList)* RIGHT_PAREN) | constants=partitionValueList))? + ; + +partitionValueList + : LEFT_PAREN values+=partitionValueDef (COMMA values+=partitionValueDef)* RIGHT_PAREN + ; + +partitionValueDef + : SUBTRACT? INTEGER_VALUE | STRING_LITERAL | MAXVALUE | NULL + ; + +rollupDefs + : rollups+=rollupDef (COMMA rollups+=rollupDef)* + ; + +rollupDef + : rollupName=identifier rollupCols=identifierList (DUPLICATE KEY dupKeys=identifierList)? properties=propertyClause? + ; + +aggTypeDef + : MAX | MIN | SUM | REPLACE | REPLACE_IF_NOT_NULL | HLL_UNION | BITMAP_UNION | QUANTILE_UNION | GENERIC + ; + +tabletList + : TABLET LEFT_PAREN tabletIdList+=INTEGER_VALUE (COMMA tabletIdList+=INTEGER_VALUE)* RIGHT_PAREN + ; + + +inlineTable + : VALUES rowConstructor (COMMA rowConstructor)* + ; + +// -----------------Expression----------------- +namedExpression + : expression (AS? (identifierOrText))? + ; + +namedExpressionSeq + : namedExpression (COMMA namedExpression)* + ; + +expression + : booleanExpression + ; + +funcExpression + : expression + | lambdaExpression + ; + +lambdaExpression + : args+=errorCapturingIdentifier ARROW body=booleanExpression + | LEFT_PAREN + args+=errorCapturingIdentifier (COMMA args+=errorCapturingIdentifier)+ + RIGHT_PAREN + ARROW body=booleanExpression + ; + +booleanExpression + : LOGICALNOT booleanExpression #logicalNot + | EXISTS LEFT_PAREN query RIGHT_PAREN #exist + | (ISNULL | IS_NULL_PRED) LEFT_PAREN valueExpression RIGHT_PAREN #isnull + | IS_NOT_NULL_PRED LEFT_PAREN valueExpression RIGHT_PAREN #is_not_null_pred + | valueExpression predicate? #predicated + | NOT booleanExpression #logicalNot + | left=booleanExpression operator=(AND | LOGICALAND) right=booleanExpression #logicalBinary + | left=booleanExpression operator=XOR right=booleanExpression #logicalBinary + | left=booleanExpression operator=OR right=booleanExpression #logicalBinary + | left=booleanExpression operator=DOUBLEPIPES right=booleanExpression #doublePipes + ; + +rowConstructor + : LEFT_PAREN (rowConstructorItem (COMMA rowConstructorItem)*)? RIGHT_PAREN + ; + +rowConstructorItem + : constant // duplicate constant rule for improve the parse of `insert into tbl values` + | DEFAULT + | namedExpression + ; + +predicate + : NOT? kind=BETWEEN lower=valueExpression AND upper=valueExpression + | NOT? kind=(REGEXP | RLIKE) pattern=valueExpression + | NOT? kind=LIKE pattern=valueExpression (ESCAPE escape=valueExpression)? + | NOT? kind=(MATCH | MATCH_ANY | MATCH_ALL | MATCH_PHRASE | MATCH_PHRASE_PREFIX | MATCH_REGEXP | MATCH_PHRASE_EDGE) pattern=valueExpression + | NOT? kind=IN LEFT_PAREN query RIGHT_PAREN + | NOT? kind=IN LEFT_PAREN expression (COMMA expression)* RIGHT_PAREN + | IS NOT? kind=NULL + | IS NOT? kind=(TRUE | FALSE) + ; + +valueExpression + : primaryExpression #valueExpressionDefault + | operator=(SUBTRACT | PLUS | TILDE) valueExpression #arithmeticUnary + // split arithmeticBinary from 1 to 5 due to they have different operator precedence + | left=valueExpression operator=HAT right=valueExpression #arithmeticBinary + | left=valueExpression operator=(ASTERISK | SLASH | MOD | DIV) right=valueExpression #arithmeticBinary + | left=valueExpression operator=(PLUS | SUBTRACT) right=valueExpression #arithmeticBinary + | left=valueExpression operator=AMPERSAND right=valueExpression #arithmeticBinary + | left=valueExpression operator=PIPE right=valueExpression #arithmeticBinary + | left=valueExpression comparisonOperator right=valueExpression #comparison + ; + +primaryExpression + : name=CURRENT_DATE #currentDate + | name=CURRENT_TIME #currentTime + | name=CURRENT_TIMESTAMP #currentTimestamp + | name=LOCALTIME #localTime + | name=LOCALTIMESTAMP #localTimestamp + | name=CURRENT_USER #currentUser + | name=SESSION_USER #sessionUser + | CASE whenClause+ (ELSE elseExpression=expression)? END #searchedCase + | CASE value=expression whenClause+ (ELSE elseExpression=expression)? END #simpleCase + | name=CAST LEFT_PAREN expression AS castDataType RIGHT_PAREN #cast + | name=TRY_CAST LEFT_PAREN expression AS castDataType RIGHT_PAREN #tryCast + | constant #constantDefault + | interval #intervalLiteral + | ASTERISK (exceptOrReplace)* #star + | qualifiedName DOT ASTERISK (exceptOrReplace)* #star + | CHAR LEFT_PAREN + arguments+=expression (COMMA arguments+=expression)* + (USING charSet=identifierOrText)? + RIGHT_PAREN #charFunction + | CONVERT LEFT_PAREN argument=expression USING charSet=identifierOrText RIGHT_PAREN #convertCharSet + | CONVERT LEFT_PAREN argument=expression COMMA castDataType RIGHT_PAREN #convertType + | GROUP_CONCAT LEFT_PAREN (DISTINCT|ALL)? + (LEFT_BRACKET identifier RIGHT_BRACKET)? + argument=expression + (ORDER BY sortItem (COMMA sortItem)*)? + (SEPARATOR sep=expression)? RIGHT_PAREN + (OVER windowSpec)? #groupConcat + | GET_FORMAT LEFT_PAREN + expression COMMA expression RIGHT_PAREN #getFormatFunction + | TRIM LEFT_PAREN + ((BOTH | LEADING | TRAILING) expression? | expression) FROM expression RIGHT_PAREN #trim + | (SUBSTR | SUBSTRING | MID) LEFT_PAREN + expression FROM expression (FOR expression)? RIGHT_PAREN #substring + | POSITION LEFT_PAREN expression IN expression RIGHT_PAREN #position + | functionCallExpression #functionCall + | value=primaryExpression LEFT_BRACKET index=valueExpression RIGHT_BRACKET #elementAt + | value=primaryExpression LEFT_BRACKET begin=valueExpression + COLON (end=valueExpression)? RIGHT_BRACKET #arraySlice + | LEFT_PAREN query RIGHT_PAREN #subqueryExpression + | ATSIGN identifierOrText #userVariable + | DOUBLEATSIGN (kind=(GLOBAL | SESSION) DOT)? identifier #systemVariable + | BINARY? identifier #columnReference + | base=primaryExpression DOT fieldName=identifier #dereference + | LEFT_PAREN expression RIGHT_PAREN #parenthesizedExpression + | KEY (dbName=identifier DOT)? keyName=identifier #encryptKey + | EXTRACT LEFT_PAREN field=identifier FROM (DATE | TIMESTAMP)? + source=valueExpression RIGHT_PAREN #extract + | primaryExpression COLLATE (identifier | STRING_LITERAL | DEFAULT) #collate + ; + +exceptOrReplace + : EXCEPT LEFT_PAREN namedExpressionSeq RIGHT_PAREN #except + | REPLACE LEFT_PAREN namedExpressionSeq RIGHT_PAREN #replace + ; + +castDataType + : dataType + |(SIGNED|UNSIGNED) (INT|INTEGER)? + ; + +functionCallExpression + : functionIdentifier + LEFT_PAREN ( + (DISTINCT|ALL)? + (LEFT_BRACKET identifier RIGHT_BRACKET)? + arguments+=funcExpression (COMMA arguments+=funcExpression)* + (ORDER BY sortItem (COMMA sortItem)*)? + )? RIGHT_PAREN + (OVER windowSpec)? + ; + +functionIdentifier + : (dbName=identifier DOT)? functionNameIdentifier + ; + +functionNameIdentifier + : identifier + | ADD + | CONNECTION_ID + | CURRENT_CATALOG + | CURRENT_USER + | DATABASE + | IF + | LEFT + | LIKE + | PASSWORD + | REGEXP + | RIGHT + | SCHEMA + | SESSION_USER + | TRIM + | USER + ; + +windowSpec + // todo: name for windowRef; we haven't support it + // : name=identifier + // | LEFT_PAREN name=identifier RIGHT_PAREN + : LEFT_PAREN + partitionClause? + sortClause? + windowFrame? + RIGHT_PAREN + ; + +windowFrame + : frameUnits start=frameBoundary + | frameUnits BETWEEN start=frameBoundary AND end=frameBoundary + ; + +frameUnits + : ROWS + | RANGE + ; + +frameBoundary + : UNBOUNDED boundType=(PRECEDING | FOLLOWING) + | boundType=CURRENT ROW + | expression boundType=(PRECEDING | FOLLOWING) + ; + +qualifiedName + : identifier (DOT identifier)* + ; + +specifiedPartition + : TEMPORARY? PARTITION (identifier | identifierList) + | TEMPORARY? PARTITIONS identifierList + ; + +constant + : NULL #nullLiteral + | type=(DATE | DATEV1 | DATEV2 | TIMESTAMP) STRING_LITERAL #typeConstructor + | number #numericLiteral + | booleanValue #booleanLiteral + | BINARY? STRING_LITERAL #stringLiteral + | VARBINARY_LITERAL #varbinaryLiteral + | LEFT_BRACKET (items+=constant)? (COMMA items+=constant)* RIGHT_BRACKET #arrayLiteral + | LEFT_BRACE (items+=constant COLON items+=constant)? + (COMMA items+=constant COLON items+=constant)* RIGHT_BRACE #mapLiteral + | LEFT_BRACE items+=constant (COMMA items+=constant)* RIGHT_BRACE #structLiteral + | PLACEHOLDER #placeholder + ; + +comparisonOperator + : EQ | NEQ | LT | LTE | GT | GTE | NSEQ + ; + +booleanValue + : TRUE | FALSE + ; + +whenClause + : WHEN condition=expression THEN result=expression + ; + +interval + : INTERVAL value=expression unit=unitIdentifier + ; + +unitIdentifier + : YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND | DAY_SECOND | DAY_HOUR + | MINUTE_SECOND + ; + +dataTypeWithNullable + : dataType ((NOT)? NULL)? + ; + +dataType + : complex=ARRAY LT dataType GT #complexDataType + | complex=MAP LT dataType COMMA dataType GT #complexDataType + | complex=STRUCT LT complexColTypeList GT #complexDataType + | complex=variantTypeDefinitions #variantPredefinedFields + | AGG_STATE LT functionNameIdentifier + LEFT_PAREN dataTypes+=dataTypeWithNullable + (COMMA dataTypes+=dataTypeWithNullable)* RIGHT_PAREN GT #aggStateDataType + | primitiveColType (LEFT_PAREN (INTEGER_VALUE | ASTERISK) + (COMMA INTEGER_VALUE)* RIGHT_PAREN)? #primitiveDataType + ; + +primitiveColType + : type=TINYINT + | type=SMALLINT + | type=(INT | INTEGER) + | type=BIGINT + | type=LARGEINT + | type=BOOLEAN + | type=FLOAT + | type=DOUBLE + | type=DATE + | type=DATETIME + | type=TIME + | type=DATEV2 + | type=DATETIMEV2 + | type=DATEV1 + | type=DATETIMEV1 + | type=BITMAP + | type=QUANTILE_STATE + | type=HLL + | type=AGG_STATE + | type=STRING + | type=JSON + | type=JSONB + | type=TEXT + | type=VARCHAR + | type=CHAR + | type=DECIMAL + | type=DECIMALV2 + | type=DECIMALV3 + | type=IPV4 + | type=IPV6 + | type=VARBINARY + | type=VARIANT + | type=ALL + ; + +complexColTypeList + : complexColType (COMMA complexColType)* + ; + +complexColType + : identifier COLON dataType commentSpec? + ; + +variantTypeDefinitions + : VARIANT LT variantSubColTypeList COMMA properties=propertyClause GT #variant + | VARIANT LT variantSubColTypeList GT #variant + | VARIANT LT properties=propertyClause GT #variant + | VARIANT #variant + ; + +variantSubColTypeList + : variantSubColType (COMMA variantSubColType)* + ; +variantSubColType + : variantSubColMatchType? STRING_LITERAL COLON dataType commentSpec? + ; +variantSubColMatchType + : (MATCH_NAME | MATCH_NAME_GLOB) + ; + +commentSpec + : COMMENT STRING_LITERAL + ; + +sample + : TABLESAMPLE LEFT_PAREN sampleMethod? RIGHT_PAREN (REPEATABLE seed=INTEGER_VALUE)? + ; + +sampleMethod + : percentage=INTEGER_VALUE PERCENT #sampleByPercentile + | INTEGER_VALUE ROWS #sampleByRows + ; + +tableSnapshot + : FOR VERSION AS OF version=(INTEGER_VALUE | STRING_LITERAL) + | FOR TIME AS OF time=(STRING_LITERAL | INTEGER_VALUE) + ; + +// this rule is used for explicitly capturing wrong identifiers such as test-table, which should actually be `test-table` +// replace identifier with errorCapturingIdentifier where the immediate follow symbol is not an expression, otherwise +// valid expressions such as "a-b" can be recognized as an identifier +errorCapturingIdentifier + : identifier errorCapturingIdentifierExtra + ; + +// extra left-factoring grammar +errorCapturingIdentifierExtra + : (SUBTRACT identifier)+ #errorIdent + | #realIdent + ; + +identifier + : strictIdentifier + ; + +strictIdentifier + : IDENTIFIER #unquotedIdentifier + | quotedIdentifier #quotedIdentifierAlternative + | nonReserved #unquotedIdentifier + ; + +quotedIdentifier + : BACKQUOTED_IDENTIFIER + ; + +number + : SUBTRACT? INTEGER_VALUE #integerLiteral + | SUBTRACT? (EXPONENT_VALUE | DECIMAL_VALUE) #decimalLiteral + ; + +// there are 1 kinds of keywords in Doris. +// - Non-reserved keywords: +// normal version of non-reserved keywords. +// The non-reserved keywords are listed in `nonReserved`. +// TODO: need to stay consistent with the legacy +nonReserved +//--DEFAULT-NON-RESERVED-START + : ACTIONS + | AFTER + | AGG_STATE + | AGGREGATE + | ALIAS + | ALWAYS + | ANALYZED + | ANN + | ARRAY + | AT + | AUTHORS + | AUTO_INCREMENT + | BACKENDS + | BACKUP + | BEGIN + | BELONG + | BIN + | BITAND + | BITMAP + | BITMAP_EMPTY + | BITMAP_UNION + | BITOR + | BITXOR + | BLOB + | BOOLEAN + | BRANCH + | BRIEF + | BROKER + | BUCKETS + | BUILD + | BUILTIN + | BULK + | CACHE + | CACHED + | CALL + | CATALOG + | CATALOGS + | CHAIN + | CHAR + | CHARSET + | CHECK + | CLUSTER + | CLUSTERS + | COLLATION + | COLLECT + | COLOCATE + | COLUMNS + | COMMENT + | COMMENT_START + | COMMIT + | COMMITTED + | COMPACT + | COMPLETE + | COMPRESS_TYPE + | COMPUTE + | CONDITIONS + | CONFIG + | CONNECTION + | CONNECTION_ID + | CONSISTENT + | CONSTRAINTS + | CONVERT + | CONVERT_LSC + | COPY + | COUNT + | CREATION + | CRON + | CURRENT_CATALOG + | CURRENT_DATE + | CURRENT_TIME + | CURRENT_TIMESTAMP + | CURRENT_USER + | DATA + | DATE + | DATETIME + | DATETIMEV1 + | DATETIMEV2 + | DATEV1 + | DATEV2 + | DAY + | DAYS + | DECIMAL + | DECIMALV2 + | DECIMALV3 + | DEFERRED + | DEMAND + | DIAGNOSE + | DIAGNOSIS + | DICTIONARIES + | DICTIONARY + | DISTINCTPC + | DISTINCTPCSA + | DO + | DORIS_INTERNAL_TABLE_ID + | DUAL + | DYNAMIC + | E + | ENABLE + | ENCRYPTION + | ENCRYPTKEY + | ENCRYPTKEYS + | END + | ENDS + | ENGINE + | ENGINES + | ERRORS + | ESCAPE + | EVENTS + | EVERY + | EXCLUDE + | EXPIRED + | EXTERNAL + | FAILED_LOGIN_ATTEMPTS + | FAST + | FEATURE + | FIELDS + | FILE + | FILTER + | FIRST + | FORMAT + | FREE + | FRONTENDS + | FUNCTION + | GENERATED + | GET_FORMAT + | GENERIC + | GLOBAL + | GRAPH + | GROUPING + | GROUPS + | GROUP_CONCAT + | HASH + | HASH_MAP + | HDFS + | HELP + | HINT_END + | HINT_START + | HISTOGRAM + | HLL_UNION + | HOSTNAME + | HOTSPOT + | HOUR + | HOURS + | HUB + | IDENTIFIED + | IGNORE + | IMMEDIATE + | INCREMENTAL + | INDEXES + | INSERT + | INVERTED + | IP_TRIE + | IPV4 + | IPV6 + | IS_NOT_NULL_PRED + | IS_NULL_PRED + | ISNULL + | ISOLATION + | JOB + | JOBS + | JSON + | JSONB + | LABEL + | LAST + | LDAP + | LDAP_ADMIN_PASSWORD + | LEFT_BRACE + | LESS + | LEVEL + | LINES + | LINK + | LOCAL + | LOCALTIME + | LOCALTIMESTAMP + | LOCATION + | LOCK + | LOGICAL + | MANUAL + | MAP + | MATCHED + | MATCH_ALL + | MATCH_ANY + | MATCH_PHRASE + | MATCH_PHRASE_EDGE + | MATCH_PHRASE_PREFIX + | MATCH_REGEXP + | MATCH_NAME + | MATCH_NAME_GLOB + | MATERIALIZED + | MAX + | MEMO + | MERGE + | MID + | MIGRATE + | MIGRATIONS + | MIN + | MINUTE + | MINUTES + | MODIFY + | MONTH + | MTMV + | NAME + | NAMES + | NEGATIVE + | NEVER + | NEXT + | NGRAM_BF + | NO + | NON_NULLABLE + | NULLS + | OF + | OFF + | OFFSET + | ONLY + | OPEN + | OPTIMIZE + | OPTIMIZED + | PARAMETER + | PARSED + | PASSWORD + | PASSWORD_EXPIRE + | PASSWORD_HISTORY + | PASSWORD_LOCK_TIME + | PASSWORD_REUSE + | PARTITIONS + | PATH + | PAUSE + | PERCENT + | PERIOD + | PERMISSIVE + | PHYSICAL + | PI + | PLAN + | PLUGIN + | PLUGINS + | POLICY + | POSITION + | PRIVILEGES + | PROC + | PROCESS + | PROCESSLIST + | PROFILE + | PROPERTIES + | PROPERTY + | QUANTILE_STATE + | QUANTILE_UNION + | QUARTER + | QUERY + | QUOTA + | QUALIFY + | QUEUED + | RANDOM + | RECENT + | RECOVER + | RECYCLE + | REFRESH + | REPEATABLE + | REPLACE + | REPLACE_IF_NOT_NULL + | REPLAYER + | REPOSITORIES + | REPOSITORY + | RESOURCE + | RESOURCES + | RESTORE + | RESTRICTIVE + | RESUME + | RETAIN + | RETENTION + | RETURNS + | REWRITTEN + | RIGHT_BRACE + | RLIKE + | ROLLBACK + | ROLLUP + | ROOT + | ROTATE + | ROUTINE + | S3 + | SAMPLE + | SCHEDULE + | SCHEDULER + | SCHEMA + | SECOND + | SEPARATOR + | SERIALIZABLE + | SET_SESSION_VARIABLE + | SESSION + | SESSION_USER + | SHAPE + | SKEW + | SNAPSHOT + | SNAPSHOTS + | SONAME + | SPLIT + | SQL + | STAGE + | STAGES + | START + | STARTS + | STATS + | STATUS + | STOP + | STORAGE + | STREAM + | STREAMING + | STRING + | STRUCT + | SUBSTR + | SUBSTRING + | SUM + | TABLES + | TAG + | TASK + | TASKS + | TDE + | TEMPORARY + | TEXT + | THAN + | TIME + | TIMESTAMP + | TRANSACTION + | TREE + | TRIGGERS + | TRUNCATE + | TYPE + | TYPES + | UNCOMMITTED + | UNLOCK + | UNSET + | UP + | USER + | VALUE + | VARBINARY + | VARCHAR + | VARIABLE + | VARIABLES + | VARIANT + | VAULT + | VAULTS + | VERBOSE + | VERSION + | VIEW + | VIEWS + | WARM + | WARNINGS + | WEEK + | WORK + | YEAR +//--DEFAULT-NON-RESERVED-END + ; diff --git a/doris/Makefile b/doris/Makefile index c850450..88e2f84 100644 --- a/doris/Makefile +++ b/doris/Makefile @@ -1,7 +1,7 @@ all: build test build: - antlr -Dlanguage=Go -package doris -visitor -o . DorisSQLLex.g4 DorisSQL.g4 + antlr -Dlanguage=Go -package doris -visitor -o . DorisLexer.g4 DorisParser.g4 test: - go test -v -run TestDorisSQLParser + go test -v -run TestDorisParser diff --git a/doris/README.md b/doris/README.md index f10b4ac..d304ed3 100644 --- a/doris/README.md +++ b/doris/README.md @@ -1,32 +1,47 @@ -The doris-parser is a parser for DORIS SQL. It is based on the [ANTLR4](https://github.com/antlr/antlr4). +# Apache Doris SQL Parser -## Build +An ANTLR4-based SQL parser for Apache Doris, built using the official Apache Doris grammar files. + +## About + +This parser is generated from the official Apache Doris ANTLR4 grammar files, providing accurate SQL parsing capabilities for Apache Doris SQL dialect. -Before build, you need to install the ANTLR4. +## Grammar Source -requirements: -- https://github.com/antlr/antlr4/blob/master/doc/getting-started.md -- https://github.com/antlr/antlr4/blob/master/doc/go-target.md +The grammar files are sourced from the official Apache Doris repository: +- [DorisLexer.g4](https://github.com/apache/doris/blob/master/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4) +- [DorisParser.g4](https://github.com/apache/doris/blob/master/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4) + +## Build + +Generate the parser from the ANTLR4 grammar files: ```bash -./build.sh +make build ``` -## Update grammar +This command uses ANTLR4 to generate the Go lexer, parser, listener, and visitor files. + +## Test -### Manually change the grammar file in this project +Run the test suite: -1. run `./build.sh` to generate the parser code. +```bash +make test +``` -## Test the parser +## Development -Run `TestDorisSQLDBSQLParser` in `parser_test.go` to test the parser. +After modifying the grammar files, always regenerate the parser: ```bash -go test -v +make build +make test ``` ## References -- ANTLR4 Getting Started https://github.com/antlr/antlr4/blob/master/doc/getting-started.md -- ANTLR4 Go Garget https://github.com/antlr/antlr4/blob/master/doc/go-target.md \ No newline at end of file +- [Apache Doris](https://doris.apache.org/) +- [Apache Doris GitHub Repository](https://github.com/apache/doris) +- [ANTLR4](https://www.antlr.org/) +- [ANTLR4 Documentation](https://github.com/antlr/antlr4/blob/master/doc/index.md) diff --git a/doris/doris_lexer.go b/doris/doris_lexer.go new file mode 100644 index 0000000..917bd22 --- /dev/null +++ b/doris/doris_lexer.go @@ -0,0 +1,3535 @@ +// Code generated from DorisLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package doris + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type DorisLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var DorisLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func dorislexerLexerInit() { + staticData := &DorisLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "';'", "'('", "')'", "','", "'.'", "'...'", "'['", "']'", "'{'", + "'}'", "'ACCOUNT_LOCK'", "'ACCOUNT_UNLOCK'", "'ACTIONS'", "'ADD'", "'ADMIN'", + "'AFTER'", "'AGG_STATE'", "'AGGREGATE'", "'ALIAS'", "'ALL'", "'ALTER'", + "'ANALYZE'", "'ANALYZED'", "'ANALYZER'", "'AND'", "'ANTI'", "'APPEND'", + "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORS'", "'AUTO'", "'AUTO_INCREMENT'", + "'ALWAYS'", "'BACKEND'", "'BACKENDS'", "'BACKUP'", "'BEGIN'", "'BELONG'", + "'BETWEEN'", "'BIGINT'", "'BIN'", "'BINARY'", "'BINLOG'", "'BITAND'", + "'BITMAP'", "'BITMAP_EMPTY'", "'BITMAP_UNION'", "'BITOR'", "'BITXOR'", + "'BLOB'", "'BOOLEAN'", "'BOTH'", "'BRANCH'", "'BRIEF'", "'BROKER'", + "'BUCKETS'", "'BUILD'", "'BUILTIN'", "'BULK'", "'BY'", "'CACHE'", "'CACHED'", + "'CALL'", "'CANCEL'", "'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'", + "'CHAIN'", "", "'CHARSET'", "'CHAR_FILTER'", "'CHECK'", "'CLEAN'", "'CLUSTER'", + "'CLUSTERS'", "'COLLATE'", "'COLLATION'", "'COLLECT'", "'COLOCATE'", + "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMMITTED'", "'COMPACT'", + "'COMPLETE'", "'COMPRESS_TYPE'", "'COMPUTE'", "'CONDITIONS'", "'CONFIG'", + "'CONNECTION'", "'CONNECTION_ID'", "'CONSISTENT'", "'CONSTRAINT'", "'CONSTRAINTS'", + "'CONVERT'", "'CONVERT_LIGHT_SCHEMA_CHANGE_PROCESS'", "'COPY'", "'COUNT'", + "'CREATE'", "'CREATION'", "'CRON'", "'CROSS'", "'CUBE'", "'CURRENT'", + "'CURRENT_CATALOG'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'DATA'", "'DATABASE'", "'DATABASES'", "'DATE'", "'DATETIME'", + "'DATETIMEV2'", "'DATEV2'", "'DATETIMEV1'", "'DATEV1'", "'DAY'", "'DAY_SECOND'", + "'DAYS'", "'DAY_HOUR'", "'DECIMAL'", "'DECIMALV2'", "'DECIMALV3'", "'DECOMMISSION'", + "'DEFAULT'", "'DEFERRED'", "'DELETE'", "'DEMAND'", "'DESC'", "'DESCRIBE'", + "'DIAGNOSE'", "'DIAGNOSIS'", "'DICTIONARIES'", "'DICTIONARY'", "'DISK'", + "'DISTINCT'", "'DISTINCTPC'", "'DISTINCTPCSA'", "'DISTRIBUTED'", "'DISTRIBUTION'", + "'DIV'", "'DO'", "'DORIS_INTERNAL_TABLE_ID'", "'DOUBLE'", "'DROP'", + "'DROPP'", "'DUAL'", "'DUMP'", "'DUPLICATE'", "'DYNAMIC'", "'E'", "'ELSE'", + "'ENABLE'", "'ENCRYPTION'", "'ENCRYPTKEY'", "'ENCRYPTKEYS'", "'END'", + "'ENDS'", "'ENGINE'", "'ENGINES'", "'ENTER'", "'ERRORS'", "'ESCAPE'", + "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCLUDE'", "'EXECUTE'", "'EXISTS'", + "'EXPIRED'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", + "'FAILED_LOGIN_ATTEMPTS'", "'FALSE'", "'FAST'", "'FEATURE'", "'FIELDS'", + "'FILE'", "'FILTER'", "'FIRST'", "'FLOAT'", "'FOLLOWER'", "'FOLLOWING'", + "'FOR'", "'FOREIGN'", "'FORCE'", "'FORMAT'", "'FREE'", "'FROM'", "'FRONTEND'", + "'FRONTENDS'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GENERATED'", + "'GENERIC'", "'GLOBAL'", "'GRANT'", "'GRANTS'", "'GRAPH'", "'GROUP'", + "'GROUPING'", "'GROUPS'", "'GROUP_CONCAT'", "'HASH'", "'HASH_MAP'", + "'HAVING'", "'HDFS'", "'HELP'", "'HISTOGRAM'", "'HLL'", "'HLL_UNION'", + "'HOSTNAME'", "'HOTSPOT'", "'HOUR'", "'HOURS'", "'HUB'", "'IDENTIFIED'", + "'IF'", "'IGNORE'", "'IMMEDIATE'", "'IN'", "'INCREMENTAL'", "'INDEX'", + "'INDEXES'", "'INFILE'", "'INNER'", "'INSERT'", "'INSTALL'", "'INT'", + "'INTEGER'", "'INTERMEDIATE'", "'INTERSECT'", "'INTERVAL'", "'INTO'", + "'INVERTED'", "'IP_TRIE'", "'IPV4'", "'IPV6'", "'IS'", "'IS_NOT_NULL_PRED'", + "'IS_NULL_PRED'", "'ISNULL'", "'ISOLATION'", "'JOB'", "'JOBS'", "'JOIN'", + "'JSON'", "'JSONB'", "'KEY'", "'KEYS'", "'KILL'", "'LABEL'", "'LARGEINT'", + "'LAYOUT'", "'LAST'", "'LATERAL'", "'LDAP'", "'LDAP_ADMIN_PASSWORD'", + "'LEADING'", "'LEFT'", "'LESS'", "'LEVEL'", "'LIKE'", "'LIMIT'", "'LINES'", + "'LINK'", "'LIST'", "'LOAD'", "'LOCAL'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'LOCATION'", "'LOCK'", "'LOGICAL'", "'LOW_PRIORITY'", "'MANUAL'", "'MAP'", + "'MATCH'", "'MATCHED'", "'MATCH_ALL'", "'MATCH_ANY'", "'MATCH_NAME'", + "'MATCH_NAME_GLOB'", "'MATCH_PHRASE'", "'MATCH_PHRASE_EDGE'", "'MATCH_PHRASE_PREFIX'", + "'MATCH_REGEXP'", "'MATERIALIZED'", "'MAX'", "'MAXVALUE'", "'MEMO'", + "'MERGE'", "'MID'", "'MIGRATE'", "'MIGRATIONS'", "'MIN'", "'MINUS'", + "'MINUTE'", "'MINUTES'", "'MINUTE_SECOND'", "'MODIFY'", "'MONTH'", "'MTMV'", + "'NAME'", "'NAMES'", "'NATURAL'", "'NEGATIVE'", "'NEVER'", "'NEXT'", + "'NGRAM_BF'", "'ANN'", "'NO'", "'NO_USE_MV'", "'NON_NULLABLE'", "'NOT'", + "'NULL'", "'NULLS'", "'OBSERVER'", "'OF'", "'OFFSET'", "'ON'", "'OFF'", + "'ONLY'", "'OPEN'", "'OPTIMIZE'", "'OPTIMIZED'", "'OR'", "'ORDER'", + "'OUTER'", "'OUTFILE'", "'OVER'", "'OVERWRITE'", "'PARAMETER'", "'PARSED'", + "'PARTITION'", "'PARTITIONS'", "'PASSWORD'", "'PASSWORD_EXPIRE'", "'PASSWORD_HISTORY'", + "'PASSWORD_LOCK_TIME'", "'PASSWORD_REUSE'", "'PATH'", "'PAUSE'", "'PERCENT'", + "'PERIOD'", "'PERMISSIVE'", "'PHYSICAL'", "'PI'", "'?'", "'PLAN'", "'PLAY'", + "'PRIVILEGES'", "'PROCESS'", "'PLUGIN'", "'PLUGINS'", "'POLICY'", "'POSITION'", + "'PRECEDING'", "'PREPARE'", "'PRIMARY'", "'PROC'", "'PROCEDURE'", "'PROCESSLIST'", + "'PROFILE'", "'PROPERTIES'", "'PROPERTY'", "'QUANTILE_STATE'", "'QUANTILE_UNION'", + "'QUERY'", "'QUEUED'", "'QUOTA'", "'QUALIFY'", "'QUARTER'", "'RANDOM'", + "'RANGE'", "'READ'", "'REAL'", "'REBALANCE'", "'RECENT'", "'RECOVER'", + "'RECYCLE'", "'REFRESH'", "'REFERENCES'", "'REGEXP'", "'RELEASE'", "'RENAME'", + "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'REPLACE_IF_NOT_NULL'", "'REPLAYER'", + "'REPLICA'", "'REPOSITORIES'", "'REPOSITORY'", "'RESOURCE'", "'RESOURCES'", + "'RESTORE'", "'RESTRICTIVE'", "'RESUME'", "'RETAIN'", "'RETENTION'", + "'RETURNS'", "'REVOKE'", "'REWRITTEN'", "'RIGHT'", "'RLIKE'", "'ROLE'", + "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROOT'", "'ROTATE'", "'ROUTINE'", + "'ROW'", "'ROWS'", "'S3'", "'SAMPLE'", "'SCHEDULE'", "'SCHEDULER'", + "'SCHEMA'", "'SCHEMAS'", "'SECOND'", "'SELECT'", "'SEMI'", "'SEPARATOR'", + "'SERIALIZABLE'", "'SESSION'", "'SESSION_USER'", "'SET'", "'SETS'", + "'SET_SESSION_VARIABLE'", "'SHAPE'", "'SHOW'", "'SIGNED'", "'SKEW'", + "'SMALLINT'", "'SNAPSHOT'", "'SNAPSHOTS'", "'SONAME'", "'SPLIT'", "'SQL'", + "'SQL_BLOCK_RULE'", "'STAGE'", "'STAGES'", "'START'", "'STARTS'", "'STATS'", + "'STATUS'", "'STOP'", "'STORAGE'", "'STREAM'", "'STREAMING'", "'STRING'", + "'STRUCT'", "'SUBSTR'", "'SUBSTRING'", "'SUM'", "'SUPERUSER'", "'SWITCH'", + "'SYNC'", "'SYSTEM'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TABLET'", + "'TABLETS'", "'TAG'", "'TASK'", "'TASKS'", "'TDE'", "'TEMPORARY'", "'TERMINATED'", + "'TEXT'", "'THAN'", "'THEN'", "'TIME'", "'TIMESTAMP'", "'TINYINT'", + "'TO'", "'TOKENIZER'", "'TOKEN_FILTER'", "'TRAILING'", "'TRANSACTION'", + "'TRASH'", "'TREE'", "'TRIGGERS'", "'TRIM'", "'TRUE'", "'TRUNCATE'", + "'TRY_CAST'", "'TYPE'", "'TYPE_CAST'", "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", + "'UNINSTALL'", "'UNION'", "'UNIQUE'", "'UNLOCK'", "'UNSET'", "'UNSIGNED'", + "'UP'", "'UPDATE'", "'USE'", "'USER'", "'USE_MV'", "'USING'", "'VALUE'", + "'VALUES'", "'VARBINARY'", "'VARCHAR'", "'VARIABLE'", "'VARIABLES'", + "'VARIANT'", "'VAULT'", "'VAULTS'", "'VERBOSE'", "'VERSION'", "'VIEW'", + "'VIEWS'", "'WARM'", "'WARNINGS'", "'WEEK'", "'WHEN'", "'WHERE'", "'WHITELIST'", + "'WITH'", "'WORK'", "'WORKLOAD'", "'WRITE'", "'XOR'", "'YEAR'", "", + "'<=>'", "", "'<'", "", "'>'", "", "'+'", "'-'", "'*'", "'/'", "'%'", + "'~'", "'&'", "'&&'", "'!'", "'|'", "'||'", "'^'", "':'", "'->'", "'/*+'", + "'*/'", "'/*'", "'@'", "'@@'", + } + staticData.SymbolicNames = []string{ + "", "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "DOTDOTDOT", + "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "ACCOUNT_LOCK", + "ACCOUNT_UNLOCK", "ACTIONS", "ADD", "ADMIN", "AFTER", "AGG_STATE", "AGGREGATE", + "ALIAS", "ALL", "ALTER", "ANALYZE", "ANALYZED", "ANALYZER", "AND", "ANTI", + "APPEND", "ARRAY", "AS", "ASC", "AT", "AUTHORS", "AUTO", "AUTO_INCREMENT", + "ALWAYS", "BACKEND", "BACKENDS", "BACKUP", "BEGIN", "BELONG", "BETWEEN", + "BIGINT", "BIN", "BINARY", "BINLOG", "BITAND", "BITMAP", "BITMAP_EMPTY", + "BITMAP_UNION", "BITOR", "BITXOR", "BLOB", "BOOLEAN", "BOTH", "BRANCH", + "BRIEF", "BROKER", "BUCKETS", "BUILD", "BUILTIN", "BULK", "BY", "CACHE", + "CACHED", "CALL", "CANCEL", "CASE", "CAST", "CATALOG", "CATALOGS", "CHAIN", + "CHAR", "CHARSET", "CHAR_FILTER", "CHECK", "CLEAN", "CLUSTER", "CLUSTERS", + "COLLATE", "COLLATION", "COLLECT", "COLOCATE", "COLUMN", "COLUMNS", + "COMMENT", "COMMIT", "COMMITTED", "COMPACT", "COMPLETE", "COMPRESS_TYPE", + "COMPUTE", "CONDITIONS", "CONFIG", "CONNECTION", "CONNECTION_ID", "CONSISTENT", + "CONSTRAINT", "CONSTRAINTS", "CONVERT", "CONVERT_LSC", "COPY", "COUNT", + "CREATE", "CREATION", "CRON", "CROSS", "CUBE", "CURRENT", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "DATA", "DATABASE", "DATABASES", "DATE", "DATETIME", "DATETIMEV2", "DATEV2", + "DATETIMEV1", "DATEV1", "DAY", "DAY_SECOND", "DAYS", "DAY_HOUR", "DECIMAL", + "DECIMALV2", "DECIMALV3", "DECOMMISSION", "DEFAULT", "DEFERRED", "DELETE", + "DEMAND", "DESC", "DESCRIBE", "DIAGNOSE", "DIAGNOSIS", "DICTIONARIES", + "DICTIONARY", "DISK", "DISTINCT", "DISTINCTPC", "DISTINCTPCSA", "DISTRIBUTED", + "DISTRIBUTION", "DIV", "DO", "DORIS_INTERNAL_TABLE_ID", "DOUBLE", "DROP", + "DROPP", "DUAL", "DUMP", "DUPLICATE", "DYNAMIC", "E", "ELSE", "ENABLE", + "ENCRYPTION", "ENCRYPTKEY", "ENCRYPTKEYS", "END", "ENDS", "ENGINE", + "ENGINES", "ENTER", "ERRORS", "ESCAPE", "EVENTS", "EVERY", "EXCEPT", + "EXCLUDE", "EXECUTE", "EXISTS", "EXPIRED", "EXPLAIN", "EXPORT", "EXTENDED", + "EXTERNAL", "EXTRACT", "FAILED_LOGIN_ATTEMPTS", "FALSE", "FAST", "FEATURE", + "FIELDS", "FILE", "FILTER", "FIRST", "FLOAT", "FOLLOWER", "FOLLOWING", + "FOR", "FOREIGN", "FORCE", "FORMAT", "FREE", "FROM", "FRONTEND", "FRONTENDS", + "FULL", "FUNCTION", "FUNCTIONS", "GENERATED", "GENERIC", "GLOBAL", "GRANT", + "GRANTS", "GRAPH", "GROUP", "GROUPING", "GROUPS", "GROUP_CONCAT", "HASH", + "HASH_MAP", "HAVING", "HDFS", "HELP", "HISTOGRAM", "HLL", "HLL_UNION", + "HOSTNAME", "HOTSPOT", "HOUR", "HOURS", "HUB", "IDENTIFIED", "IF", "IGNORE", + "IMMEDIATE", "IN", "INCREMENTAL", "INDEX", "INDEXES", "INFILE", "INNER", + "INSERT", "INSTALL", "INT", "INTEGER", "INTERMEDIATE", "INTERSECT", + "INTERVAL", "INTO", "INVERTED", "IP_TRIE", "IPV4", "IPV6", "IS", "IS_NOT_NULL_PRED", + "IS_NULL_PRED", "ISNULL", "ISOLATION", "JOB", "JOBS", "JOIN", "JSON", + "JSONB", "KEY", "KEYS", "KILL", "LABEL", "LARGEINT", "LAYOUT", "LAST", + "LATERAL", "LDAP", "LDAP_ADMIN_PASSWORD", "LEADING", "LEFT", "LESS", + "LEVEL", "LIKE", "LIMIT", "LINES", "LINK", "LIST", "LOAD", "LOCAL", + "LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCK", "LOGICAL", "LOW_PRIORITY", + "MANUAL", "MAP", "MATCH", "MATCHED", "MATCH_ALL", "MATCH_ANY", "MATCH_NAME", + "MATCH_NAME_GLOB", "MATCH_PHRASE", "MATCH_PHRASE_EDGE", "MATCH_PHRASE_PREFIX", + "MATCH_REGEXP", "MATERIALIZED", "MAX", "MAXVALUE", "MEMO", "MERGE", + "MID", "MIGRATE", "MIGRATIONS", "MIN", "MINUS", "MINUTE", "MINUTES", + "MINUTE_SECOND", "MODIFY", "MONTH", "MTMV", "NAME", "NAMES", "NATURAL", + "NEGATIVE", "NEVER", "NEXT", "NGRAM_BF", "ANN", "NO", "NO_USE_MV", "NON_NULLABLE", + "NOT", "NULL", "NULLS", "OBSERVER", "OF", "OFFSET", "ON", "OFF", "ONLY", + "OPEN", "OPTIMIZE", "OPTIMIZED", "OR", "ORDER", "OUTER", "OUTFILE", + "OVER", "OVERWRITE", "PARAMETER", "PARSED", "PARTITION", "PARTITIONS", + "PASSWORD", "PASSWORD_EXPIRE", "PASSWORD_HISTORY", "PASSWORD_LOCK_TIME", + "PASSWORD_REUSE", "PATH", "PAUSE", "PERCENT", "PERIOD", "PERMISSIVE", + "PHYSICAL", "PI", "PLACEHOLDER", "PLAN", "PLAY", "PRIVILEGES", "PROCESS", + "PLUGIN", "PLUGINS", "POLICY", "POSITION", "PRECEDING", "PREPARE", "PRIMARY", + "PROC", "PROCEDURE", "PROCESSLIST", "PROFILE", "PROPERTIES", "PROPERTY", + "QUANTILE_STATE", "QUANTILE_UNION", "QUERY", "QUEUED", "QUOTA", "QUALIFY", + "QUARTER", "RANDOM", "RANGE", "READ", "REAL", "REBALANCE", "RECENT", + "RECOVER", "RECYCLE", "REFRESH", "REFERENCES", "REGEXP", "RELEASE", + "RENAME", "REPAIR", "REPEATABLE", "REPLACE", "REPLACE_IF_NOT_NULL", + "REPLAYER", "REPLICA", "REPOSITORIES", "REPOSITORY", "RESOURCE", "RESOURCES", + "RESTORE", "RESTRICTIVE", "RESUME", "RETAIN", "RETENTION", "RETURNS", + "REVOKE", "REWRITTEN", "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK", + "ROLLUP", "ROOT", "ROTATE", "ROUTINE", "ROW", "ROWS", "S3", "SAMPLE", + "SCHEDULE", "SCHEDULER", "SCHEMA", "SCHEMAS", "SECOND", "SELECT", "SEMI", + "SEPARATOR", "SERIALIZABLE", "SESSION", "SESSION_USER", "SET", "SETS", + "SET_SESSION_VARIABLE", "SHAPE", "SHOW", "SIGNED", "SKEW", "SMALLINT", + "SNAPSHOT", "SNAPSHOTS", "SONAME", "SPLIT", "SQL", "SQL_BLOCK_RULE", + "STAGE", "STAGES", "START", "STARTS", "STATS", "STATUS", "STOP", "STORAGE", + "STREAM", "STREAMING", "STRING", "STRUCT", "SUBSTR", "SUBSTRING", "SUM", + "SUPERUSER", "SWITCH", "SYNC", "SYSTEM", "TABLE", "TABLES", "TABLESAMPLE", + "TABLET", "TABLETS", "TAG", "TASK", "TASKS", "TDE", "TEMPORARY", "TERMINATED", + "TEXT", "THAN", "THEN", "TIME", "TIMESTAMP", "TINYINT", "TO", "TOKENIZER", + "TOKEN_FILTER", "TRAILING", "TRANSACTION", "TRASH", "TREE", "TRIGGERS", + "TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "TYPECAST", "TYPES", + "UNBOUNDED", "UNCOMMITTED", "UNINSTALL", "UNION", "UNIQUE", "UNLOCK", + "UNSET", "UNSIGNED", "UP", "UPDATE", "USE", "USER", "USE_MV", "USING", + "VALUE", "VALUES", "VARBINARY", "VARCHAR", "VARIABLE", "VARIABLES", + "VARIANT", "VAULT", "VAULTS", "VERBOSE", "VERSION", "VIEW", "VIEWS", + "WARM", "WARNINGS", "WEEK", "WHEN", "WHERE", "WHITELIST", "WITH", "WORK", + "WORKLOAD", "WRITE", "XOR", "YEAR", "EQ", "NSEQ", "NEQ", "LT", "LTE", + "GT", "GTE", "PLUS", "SUBTRACT", "ASTERISK", "SLASH", "MOD", "TILDE", + "AMPERSAND", "LOGICALAND", "LOGICALNOT", "PIPE", "DOUBLEPIPES", "HAT", + "COLON", "ARROW", "HINT_START", "HINT_END", "COMMENT_START", "ATSIGN", + "DOUBLEATSIGN", "STRING_LITERAL", "VARBINARY_LITERAL", "LEADING_STRING", + "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", + "EXPONENT_VALUE", "DECIMAL_VALUE", "BIGDECIMAL_LITERAL", "IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "FROM_DUAL", + "WS", "UNRECOGNIZED", + } + staticData.RuleNames = []string{ + "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "DOTDOTDOT", + "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "ACCOUNT_LOCK", + "ACCOUNT_UNLOCK", "ACTIONS", "ADD", "ADMIN", "AFTER", "AGG_STATE", "AGGREGATE", + "ALIAS", "ALL", "ALTER", "ANALYZE", "ANALYZED", "ANALYZER", "AND", "ANTI", + "APPEND", "ARRAY", "AS", "ASC", "AT", "AUTHORS", "AUTO", "AUTO_INCREMENT", + "ALWAYS", "BACKEND", "BACKENDS", "BACKUP", "BEGIN", "BELONG", "BETWEEN", + "BIGINT", "BIN", "BINARY", "BINLOG", "BITAND", "BITMAP", "BITMAP_EMPTY", + "BITMAP_UNION", "BITOR", "BITXOR", "BLOB", "BOOLEAN", "BOTH", "BRANCH", + "BRIEF", "BROKER", "BUCKETS", "BUILD", "BUILTIN", "BULK", "BY", "CACHE", + "CACHED", "CALL", "CANCEL", "CASE", "CAST", "CATALOG", "CATALOGS", "CHAIN", + "CHAR", "CHARSET", "CHAR_FILTER", "CHECK", "CLEAN", "CLUSTER", "CLUSTERS", + "COLLATE", "COLLATION", "COLLECT", "COLOCATE", "COLUMN", "COLUMNS", + "COMMENT", "COMMIT", "COMMITTED", "COMPACT", "COMPLETE", "COMPRESS_TYPE", + "COMPUTE", "CONDITIONS", "CONFIG", "CONNECTION", "CONNECTION_ID", "CONSISTENT", + "CONSTRAINT", "CONSTRAINTS", "CONVERT", "CONVERT_LSC", "COPY", "COUNT", + "CREATE", "CREATION", "CRON", "CROSS", "CUBE", "CURRENT", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "DATA", "DATABASE", "DATABASES", "DATE", "DATETIME", "DATETIMEV2", "DATEV2", + "DATETIMEV1", "DATEV1", "DAY", "DAY_SECOND", "DAYS", "DAY_HOUR", "DECIMAL", + "DECIMALV2", "DECIMALV3", "DECOMMISSION", "DEFAULT", "DEFERRED", "DELETE", + "DEMAND", "DESC", "DESCRIBE", "DIAGNOSE", "DIAGNOSIS", "DICTIONARIES", + "DICTIONARY", "DISK", "DISTINCT", "DISTINCTPC", "DISTINCTPCSA", "DISTRIBUTED", + "DISTRIBUTION", "DIV", "DO", "DORIS_INTERNAL_TABLE_ID", "DOUBLE", "DROP", + "DROPP", "DUAL", "DUMP", "DUPLICATE", "DYNAMIC", "E", "ELSE", "ENABLE", + "ENCRYPTION", "ENCRYPTKEY", "ENCRYPTKEYS", "END", "ENDS", "ENGINE", + "ENGINES", "ENTER", "ERRORS", "ESCAPE", "EVENTS", "EVERY", "EXCEPT", + "EXCLUDE", "EXECUTE", "EXISTS", "EXPIRED", "EXPLAIN", "EXPORT", "EXTENDED", + "EXTERNAL", "EXTRACT", "FAILED_LOGIN_ATTEMPTS", "FALSE", "FAST", "FEATURE", + "FIELDS", "FILE", "FILTER", "FIRST", "FLOAT", "FOLLOWER", "FOLLOWING", + "FOR", "FOREIGN", "FORCE", "FORMAT", "FREE", "FROM", "FRONTEND", "FRONTENDS", + "FULL", "FUNCTION", "FUNCTIONS", "GENERATED", "GENERIC", "GLOBAL", "GRANT", + "GRANTS", "GRAPH", "GROUP", "GROUPING", "GROUPS", "GROUP_CONCAT", "HASH", + "HASH_MAP", "HAVING", "HDFS", "HELP", "HISTOGRAM", "HLL", "HLL_UNION", + "HOSTNAME", "HOTSPOT", "HOUR", "HOURS", "HUB", "IDENTIFIED", "IF", "IGNORE", + "IMMEDIATE", "IN", "INCREMENTAL", "INDEX", "INDEXES", "INFILE", "INNER", + "INSERT", "INSTALL", "INT", "INTEGER", "INTERMEDIATE", "INTERSECT", + "INTERVAL", "INTO", "INVERTED", "IP_TRIE", "IPV4", "IPV6", "IS", "IS_NOT_NULL_PRED", + "IS_NULL_PRED", "ISNULL", "ISOLATION", "JOB", "JOBS", "JOIN", "JSON", + "JSONB", "KEY", "KEYS", "KILL", "LABEL", "LARGEINT", "LAYOUT", "LAST", + "LATERAL", "LDAP", "LDAP_ADMIN_PASSWORD", "LEADING", "LEFT", "LESS", + "LEVEL", "LIKE", "LIMIT", "LINES", "LINK", "LIST", "LOAD", "LOCAL", + "LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCK", "LOGICAL", "LOW_PRIORITY", + "MANUAL", "MAP", "MATCH", "MATCHED", "MATCH_ALL", "MATCH_ANY", "MATCH_NAME", + "MATCH_NAME_GLOB", "MATCH_PHRASE", "MATCH_PHRASE_EDGE", "MATCH_PHRASE_PREFIX", + "MATCH_REGEXP", "MATERIALIZED", "MAX", "MAXVALUE", "MEMO", "MERGE", + "MID", "MIGRATE", "MIGRATIONS", "MIN", "MINUS", "MINUTE", "MINUTES", + "MINUTE_SECOND", "MODIFY", "MONTH", "MTMV", "NAME", "NAMES", "NATURAL", + "NEGATIVE", "NEVER", "NEXT", "NGRAM_BF", "ANN", "NO", "NO_USE_MV", "NON_NULLABLE", + "NOT", "NULL", "NULLS", "OBSERVER", "OF", "OFFSET", "ON", "OFF", "ONLY", + "OPEN", "OPTIMIZE", "OPTIMIZED", "OR", "ORDER", "OUTER", "OUTFILE", + "OVER", "OVERWRITE", "PARAMETER", "PARSED", "PARTITION", "PARTITIONS", + "PASSWORD", "PASSWORD_EXPIRE", "PASSWORD_HISTORY", "PASSWORD_LOCK_TIME", + "PASSWORD_REUSE", "PATH", "PAUSE", "PERCENT", "PERIOD", "PERMISSIVE", + "PHYSICAL", "PI", "PLACEHOLDER", "PLAN", "PLAY", "PRIVILEGES", "PROCESS", + "PLUGIN", "PLUGINS", "POLICY", "POSITION", "PRECEDING", "PREPARE", "PRIMARY", + "PROC", "PROCEDURE", "PROCESSLIST", "PROFILE", "PROPERTIES", "PROPERTY", + "QUANTILE_STATE", "QUANTILE_UNION", "QUERY", "QUEUED", "QUOTA", "QUALIFY", + "QUARTER", "RANDOM", "RANGE", "READ", "REAL", "REBALANCE", "RECENT", + "RECOVER", "RECYCLE", "REFRESH", "REFERENCES", "REGEXP", "RELEASE", + "RENAME", "REPAIR", "REPEATABLE", "REPLACE", "REPLACE_IF_NOT_NULL", + "REPLAYER", "REPLICA", "REPOSITORIES", "REPOSITORY", "RESOURCE", "RESOURCES", + "RESTORE", "RESTRICTIVE", "RESUME", "RETAIN", "RETENTION", "RETURNS", + "REVOKE", "REWRITTEN", "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK", + "ROLLUP", "ROOT", "ROTATE", "ROUTINE", "ROW", "ROWS", "S3", "SAMPLE", + "SCHEDULE", "SCHEDULER", "SCHEMA", "SCHEMAS", "SECOND", "SELECT", "SEMI", + "SEPARATOR", "SERIALIZABLE", "SESSION", "SESSION_USER", "SET", "SETS", + "SET_SESSION_VARIABLE", "SHAPE", "SHOW", "SIGNED", "SKEW", "SMALLINT", + "SNAPSHOT", "SNAPSHOTS", "SONAME", "SPLIT", "SQL", "SQL_BLOCK_RULE", + "STAGE", "STAGES", "START", "STARTS", "STATS", "STATUS", "STOP", "STORAGE", + "STREAM", "STREAMING", "STRING", "STRUCT", "SUBSTR", "SUBSTRING", "SUM", + "SUPERUSER", "SWITCH", "SYNC", "SYSTEM", "TABLE", "TABLES", "TABLESAMPLE", + "TABLET", "TABLETS", "TAG", "TASK", "TASKS", "TDE", "TEMPORARY", "TERMINATED", + "TEXT", "THAN", "THEN", "TIME", "TIMESTAMP", "TINYINT", "TO", "TOKENIZER", + "TOKEN_FILTER", "TRAILING", "TRANSACTION", "TRASH", "TREE", "TRIGGERS", + "TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "TYPECAST", "TYPES", + "UNBOUNDED", "UNCOMMITTED", "UNINSTALL", "UNION", "UNIQUE", "UNLOCK", + "UNSET", "UNSIGNED", "UP", "UPDATE", "USE", "USER", "USE_MV", "USING", + "VALUE", "VALUES", "VARBINARY", "VARCHAR", "VARIABLE", "VARIABLES", + "VARIANT", "VAULT", "VAULTS", "VERBOSE", "VERSION", "VIEW", "VIEWS", + "WARM", "WARNINGS", "WEEK", "WHEN", "WHERE", "WHITELIST", "WITH", "WORK", + "WORKLOAD", "WRITE", "XOR", "YEAR", "EQ", "NSEQ", "NEQ", "LT", "LTE", + "GT", "GTE", "PLUS", "SUBTRACT", "ASTERISK", "SLASH", "MOD", "TILDE", + "AMPERSAND", "LOGICALAND", "LOGICALNOT", "PIPE", "DOUBLEPIPES", "HAT", + "COLON", "ARROW", "HINT_START", "HINT_END", "COMMENT_START", "ATSIGN", + "DOUBLEATSIGN", "STRING_LITERAL", "VARBINARY_LITERAL", "LEADING_STRING", + "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", + "EXPONENT_VALUE", "DECIMAL_VALUE", "BIGDECIMAL_LITERAL", "IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "DECIMAL_DIGITS", "EXPONENT", "DIGIT", "HEXDIGIT", + "LETTER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "FROM_DUAL", "WS", + "UNRECOGNIZED", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 585, 5694, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, + 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, + 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, + 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, + 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, + 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, + 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, + 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, + 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, + 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, + 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, + 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, + 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, + 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, + 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, + 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, + 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, + 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, + 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, + 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, + 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, + 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, + 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, + 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, + 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, + 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, + 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, + 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, + 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, + 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, + 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, + 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, + 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, + 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, + 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, + 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, + 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, + 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, + 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, + 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, + 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, + 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, + 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, + 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, + 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, + 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, + 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, + 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, + 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, + 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, + 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, + 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, + 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, + 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, + 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, + 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, + 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, + 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, + 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, + 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, + 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, + 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, + 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, + 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, + 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, + 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, + 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, + 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, + 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, + 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, + 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, + 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, + 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, + 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, + 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, + 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, + 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, + 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, + 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, + 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, + 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, + 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, + 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, + 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, + 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, + 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, + 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, + 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, + 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, + 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, + 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, + 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, + 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, + 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, + 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, + 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, + 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, + 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, + 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, + 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, + 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, + 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, + 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, + 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, + 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, + 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, + 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, + 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, + 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, + 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, + 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, + 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, + 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, + 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, + 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, + 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, + 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, + 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, + 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, + 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, + 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, + 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, + 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, + 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, + 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, + 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, + 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, + 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, + 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, + 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, + 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, + 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, + 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, + 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, + 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, + 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, + 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, + 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, + 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, + 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, + 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, + 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, + 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, + 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, + 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, + 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, + 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, + 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, + 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, + 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, + 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, + 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, + 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, + 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, + 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, + 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, + 3, 71, 1647, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, + 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, + 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, + 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, + 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, + 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, + 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, + 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, + 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, + 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, + 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, + 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, + 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, + 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, + 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, + 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, + 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, + 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, + 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, + 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, + 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, + 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, + 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, + 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, + 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, + 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, + 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, + 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, + 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, + 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, + 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, + 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, + 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, + 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, + 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, + 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, + 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, + 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, + 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, + 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, + 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, + 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, + 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, + 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, + 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, + 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, + 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, + 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, + 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, + 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, + 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, + 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, + 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, + 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, + 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, + 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, + 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, + 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, + 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, + 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, + 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, + 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, + 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, + 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, + 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, + 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, + 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, + 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, + 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, + 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, + 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, + 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, + 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, + 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, + 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, + 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, + 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, + 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, + 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, + 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, + 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, + 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, + 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, + 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, + 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, + 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, + 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, + 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, + 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, + 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, + 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, + 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, + 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, + 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, + 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, + 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, + 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, + 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, + 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, + 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, + 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, + 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, + 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, + 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, + 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, + 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, + 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, + 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, + 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, + 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, + 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, + 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 231, + 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, + 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, + 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, + 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, + 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, + 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, + 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, + 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, + 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, + 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, + 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, + 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, + 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, + 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, + 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, + 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, + 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, + 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, + 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, + 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, + 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, + 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, + 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, + 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, + 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, + 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, + 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, + 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, + 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, + 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, + 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, + 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, + 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, + 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, + 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, + 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, + 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, + 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, + 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, + 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, + 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, + 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, + 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, + 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, + 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, + 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, + 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, + 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, + 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, + 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, + 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, + 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, + 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, + 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, + 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, + 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, + 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, + 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, + 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, + 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, + 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, + 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, + 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, + 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, + 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, + 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, + 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, + 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, + 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, + 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, + 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, + 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, + 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, + 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, + 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, + 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, + 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, + 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, + 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, + 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, + 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, + 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, + 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, + 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, + 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, + 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, + 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, + 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, + 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, + 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, + 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, + 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, + 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, + 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, + 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, + 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, + 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, + 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, + 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, + 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, + 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, + 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, + 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, + 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, + 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, + 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, + 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, + 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, + 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, + 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, + 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, + 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, + 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, + 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, + 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, + 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, + 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, + 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, + 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, + 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, + 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, + 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, + 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, + 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, + 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, + 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, + 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 407, + 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, + 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, + 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 411, + 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, + 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, + 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, + 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, + 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, + 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, + 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, + 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 421, + 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, + 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, + 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, + 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, + 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, + 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, + 1, 429, 1, 429, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, + 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 432, + 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, + 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, + 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, + 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, + 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, + 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, 439, 1, 439, + 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, + 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, + 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, + 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, + 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, + 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, 1, 450, 1, 450, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, + 1, 452, 1, 452, 1, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, + 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, + 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, + 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 1, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, + 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, + 1, 462, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, + 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, + 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, 466, + 1, 466, 1, 466, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, + 1, 467, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, + 1, 468, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 470, 1, 470, 1, 470, + 1, 470, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, + 1, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, + 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, + 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 478, + 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, + 1, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 483, + 1, 483, 1, 483, 1, 483, 1, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, + 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 486, 1, 486, 1, 486, 1, 486, + 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, + 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 488, 1, 488, 1, 488, 1, 489, + 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, + 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, + 1, 490, 1, 490, 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, + 1, 491, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, + 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, + 1, 493, 1, 493, 1, 493, 1, 493, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, + 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, + 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, + 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, + 1, 499, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 501, 1, 501, 1, 501, + 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 502, 1, 502, + 1, 502, 1, 502, 1, 502, 1, 502, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, + 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 504, 1, 504, 1, 504, 1, 504, + 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 505, + 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, + 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, + 1, 507, 1, 507, 1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, + 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 510, + 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, + 1, 511, 1, 511, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, + 1, 516, 1, 516, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, + 1, 517, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 519, + 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, + 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 521, + 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 522, + 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, + 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 524, + 1, 524, 1, 524, 1, 524, 1, 524, 1, 524, 1, 525, 1, 525, 1, 525, 1, 525, + 1, 525, 1, 525, 1, 525, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, + 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, + 1, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 531, + 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, + 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 535, 1, 535, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, + 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 539, + 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 540, 1, 540, 1, 540, 1, 540, + 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 3, 542, + 5394, 8, 542, 1, 543, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, + 544, 3, 544, 5404, 8, 544, 1, 545, 1, 545, 1, 546, 1, 546, 1, 546, 1, 546, + 3, 546, 5412, 8, 546, 1, 547, 1, 547, 1, 548, 1, 548, 1, 548, 1, 548, 3, + 548, 5420, 8, 548, 1, 549, 1, 549, 1, 550, 1, 550, 1, 551, 1, 551, 1, 552, + 1, 552, 1, 553, 1, 553, 1, 554, 1, 554, 1, 555, 1, 555, 1, 556, 1, 556, + 1, 556, 1, 557, 1, 557, 1, 558, 1, 558, 1, 559, 1, 559, 1, 559, 1, 560, + 1, 560, 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, + 1, 563, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, + 1, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, + 5, 568, 5474, 8, 568, 10, 568, 12, 568, 5477, 9, 568, 1, 568, 1, 568, 1, + 568, 1, 568, 1, 568, 1, 568, 1, 568, 5, 568, 5486, 8, 568, 10, 568, 12, + 568, 5489, 9, 568, 1, 568, 3, 568, 5492, 8, 568, 1, 569, 1, 569, 1, 569, + 5, 569, 5497, 8, 569, 10, 569, 12, 569, 5500, 9, 569, 1, 569, 1, 569, 1, + 569, 1, 569, 5, 569, 5506, 8, 569, 10, 569, 12, 569, 5509, 9, 569, 1, 569, + 3, 569, 5512, 8, 569, 1, 570, 1, 570, 1, 570, 1, 570, 3, 570, 5518, 8, + 570, 1, 571, 4, 571, 5521, 8, 571, 11, 571, 12, 571, 5522, 1, 571, 1, 571, + 1, 572, 4, 572, 5528, 8, 572, 11, 572, 12, 572, 5529, 1, 572, 1, 572, 1, + 573, 4, 573, 5535, 8, 573, 11, 573, 12, 573, 5536, 1, 573, 1, 573, 1, 574, + 4, 574, 5542, 8, 574, 11, 574, 12, 574, 5543, 1, 575, 4, 575, 5547, 8, + 575, 11, 575, 12, 575, 5548, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 3, + 575, 5556, 8, 575, 1, 576, 1, 576, 1, 577, 4, 577, 5561, 8, 577, 11, 577, + 12, 577, 5562, 1, 577, 3, 577, 5566, 8, 577, 1, 577, 1, 577, 1, 577, 1, + 577, 1, 577, 3, 577, 5573, 8, 577, 1, 577, 1, 577, 1, 577, 3, 577, 5578, + 8, 577, 1, 578, 1, 578, 1, 578, 4, 578, 5583, 8, 578, 11, 578, 12, 578, + 5584, 1, 579, 1, 579, 1, 579, 1, 579, 5, 579, 5591, 8, 579, 10, 579, 12, + 579, 5594, 9, 579, 1, 579, 1, 579, 1, 580, 4, 580, 5599, 8, 580, 11, 580, + 12, 580, 5600, 1, 580, 1, 580, 5, 580, 5605, 8, 580, 10, 580, 12, 580, + 5608, 9, 580, 1, 580, 1, 580, 4, 580, 5612, 8, 580, 11, 580, 12, 580, 5613, + 3, 580, 5616, 8, 580, 1, 581, 1, 581, 3, 581, 5620, 8, 581, 1, 581, 4, + 581, 5623, 8, 581, 11, 581, 12, 581, 5624, 1, 582, 1, 582, 1, 583, 1, 583, + 1, 584, 1, 584, 1, 584, 1, 584, 3, 584, 5635, 8, 584, 1, 585, 1, 585, 1, + 585, 1, 585, 1, 585, 1, 585, 5, 585, 5643, 8, 585, 10, 585, 12, 585, 5646, + 9, 585, 1, 585, 3, 585, 5649, 8, 585, 1, 585, 3, 585, 5652, 8, 585, 1, + 585, 1, 585, 1, 586, 1, 586, 1, 586, 5, 586, 5659, 8, 586, 10, 586, 12, + 586, 5662, 9, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 587, 1, 587, + 1, 587, 1, 587, 1, 587, 1, 587, 4, 587, 5675, 8, 587, 11, 587, 12, 587, + 5676, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 588, 4, + 588, 5687, 8, 588, 11, 588, 12, 588, 5688, 1, 588, 1, 588, 1, 589, 1, 589, + 1, 5660, 0, 590, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, + 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, + 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, + 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, + 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, + 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, + 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, + 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, + 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, + 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, + 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, + 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, + 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, + 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, + 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, + 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, + 263, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, + 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, + 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, + 154, 309, 155, 311, 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, + 323, 162, 325, 163, 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, + 169, 339, 170, 341, 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 176, + 353, 177, 355, 178, 357, 179, 359, 180, 361, 181, 363, 182, 365, 183, 367, + 184, 369, 185, 371, 186, 373, 187, 375, 188, 377, 189, 379, 190, 381, 191, + 383, 192, 385, 193, 387, 194, 389, 195, 391, 196, 393, 197, 395, 198, 397, + 199, 399, 200, 401, 201, 403, 202, 405, 203, 407, 204, 409, 205, 411, 206, + 413, 207, 415, 208, 417, 209, 419, 210, 421, 211, 423, 212, 425, 213, 427, + 214, 429, 215, 431, 216, 433, 217, 435, 218, 437, 219, 439, 220, 441, 221, + 443, 222, 445, 223, 447, 224, 449, 225, 451, 226, 453, 227, 455, 228, 457, + 229, 459, 230, 461, 231, 463, 232, 465, 233, 467, 234, 469, 235, 471, 236, + 473, 237, 475, 238, 477, 239, 479, 240, 481, 241, 483, 242, 485, 243, 487, + 244, 489, 245, 491, 246, 493, 247, 495, 248, 497, 249, 499, 250, 501, 251, + 503, 252, 505, 253, 507, 254, 509, 255, 511, 256, 513, 257, 515, 258, 517, + 259, 519, 260, 521, 261, 523, 262, 525, 263, 527, 264, 529, 265, 531, 266, + 533, 267, 535, 268, 537, 269, 539, 270, 541, 271, 543, 272, 545, 273, 547, + 274, 549, 275, 551, 276, 553, 277, 555, 278, 557, 279, 559, 280, 561, 281, + 563, 282, 565, 283, 567, 284, 569, 285, 571, 286, 573, 287, 575, 288, 577, + 289, 579, 290, 581, 291, 583, 292, 585, 293, 587, 294, 589, 295, 591, 296, + 593, 297, 595, 298, 597, 299, 599, 300, 601, 301, 603, 302, 605, 303, 607, + 304, 609, 305, 611, 306, 613, 307, 615, 308, 617, 309, 619, 310, 621, 311, + 623, 312, 625, 313, 627, 314, 629, 315, 631, 316, 633, 317, 635, 318, 637, + 319, 639, 320, 641, 321, 643, 322, 645, 323, 647, 324, 649, 325, 651, 326, + 653, 327, 655, 328, 657, 329, 659, 330, 661, 331, 663, 332, 665, 333, 667, + 334, 669, 335, 671, 336, 673, 337, 675, 338, 677, 339, 679, 340, 681, 341, + 683, 342, 685, 343, 687, 344, 689, 345, 691, 346, 693, 347, 695, 348, 697, + 349, 699, 350, 701, 351, 703, 352, 705, 353, 707, 354, 709, 355, 711, 356, + 713, 357, 715, 358, 717, 359, 719, 360, 721, 361, 723, 362, 725, 363, 727, + 364, 729, 365, 731, 366, 733, 367, 735, 368, 737, 369, 739, 370, 741, 371, + 743, 372, 745, 373, 747, 374, 749, 375, 751, 376, 753, 377, 755, 378, 757, + 379, 759, 380, 761, 381, 763, 382, 765, 383, 767, 384, 769, 385, 771, 386, + 773, 387, 775, 388, 777, 389, 779, 390, 781, 391, 783, 392, 785, 393, 787, + 394, 789, 395, 791, 396, 793, 397, 795, 398, 797, 399, 799, 400, 801, 401, + 803, 402, 805, 403, 807, 404, 809, 405, 811, 406, 813, 407, 815, 408, 817, + 409, 819, 410, 821, 411, 823, 412, 825, 413, 827, 414, 829, 415, 831, 416, + 833, 417, 835, 418, 837, 419, 839, 420, 841, 421, 843, 422, 845, 423, 847, + 424, 849, 425, 851, 426, 853, 427, 855, 428, 857, 429, 859, 430, 861, 431, + 863, 432, 865, 433, 867, 434, 869, 435, 871, 436, 873, 437, 875, 438, 877, + 439, 879, 440, 881, 441, 883, 442, 885, 443, 887, 444, 889, 445, 891, 446, + 893, 447, 895, 448, 897, 449, 899, 450, 901, 451, 903, 452, 905, 453, 907, + 454, 909, 455, 911, 456, 913, 457, 915, 458, 917, 459, 919, 460, 921, 461, + 923, 462, 925, 463, 927, 464, 929, 465, 931, 466, 933, 467, 935, 468, 937, + 469, 939, 470, 941, 471, 943, 472, 945, 473, 947, 474, 949, 475, 951, 476, + 953, 477, 955, 478, 957, 479, 959, 480, 961, 481, 963, 482, 965, 483, 967, + 484, 969, 485, 971, 486, 973, 487, 975, 488, 977, 489, 979, 490, 981, 491, + 983, 492, 985, 493, 987, 494, 989, 495, 991, 496, 993, 497, 995, 498, 997, + 499, 999, 500, 1001, 501, 1003, 502, 1005, 503, 1007, 504, 1009, 505, 1011, + 506, 1013, 507, 1015, 508, 1017, 509, 1019, 510, 1021, 511, 1023, 512, + 1025, 513, 1027, 514, 1029, 515, 1031, 516, 1033, 517, 1035, 518, 1037, + 519, 1039, 520, 1041, 521, 1043, 522, 1045, 523, 1047, 524, 1049, 525, + 1051, 526, 1053, 527, 1055, 528, 1057, 529, 1059, 530, 1061, 531, 1063, + 532, 1065, 533, 1067, 534, 1069, 535, 1071, 536, 1073, 537, 1075, 538, + 1077, 539, 1079, 540, 1081, 541, 1083, 542, 1085, 543, 1087, 544, 1089, + 545, 1091, 546, 1093, 547, 1095, 548, 1097, 549, 1099, 550, 1101, 551, + 1103, 552, 1105, 553, 1107, 554, 1109, 555, 1111, 556, 1113, 557, 1115, + 558, 1117, 559, 1119, 560, 1121, 561, 1123, 562, 1125, 563, 1127, 564, + 1129, 565, 1131, 566, 1133, 567, 1135, 568, 1137, 569, 1139, 570, 1141, + 571, 1143, 572, 1145, 573, 1147, 574, 1149, 575, 1151, 576, 1153, 577, + 1155, 578, 1157, 579, 1159, 580, 1161, 0, 1163, 0, 1165, 0, 1167, 0, 1169, + 0, 1171, 581, 1173, 582, 1175, 583, 1177, 584, 1179, 585, 1, 0, 13, 2, + 0, 39, 39, 92, 92, 2, 0, 34, 34, 92, 92, 2, 0, 88, 88, 120, 120, 1, 0, + 96, 96, 2, 0, 43, 43, 45, 45, 1, 0, 48, 57, 3, 0, 48, 57, 65, 70, 97, 102, + 4, 0, 36, 36, 65, 90, 95, 95, 97, 122, 2, 0, 0, 127, 55296, 56319, 1, 0, + 55296, 56319, 1, 0, 56320, 57343, 2, 0, 10, 10, 13, 13, 3, 0, 9, 10, 13, + 13, 32, 32, 5737, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, + 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, + 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, + 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, + 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, + 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, + 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, + 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, + 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, + 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, + 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, + 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, + 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, + 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, + 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, + 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, + 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, + 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, + 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, + 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, + 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, + 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, + 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, + 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, + 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, + 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, + 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, + 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, + 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, + 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, + 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, + 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, + 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, + 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, + 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, + 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, + 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, + 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, + 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, + 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, + 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, + 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, + 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, + 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, + 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, + 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, + 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, + 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, + 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, + 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, + 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, + 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, + 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, + 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, + 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, + 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, + 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, + 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, + 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, + 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, + 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, + 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, + 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, + 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, + 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, + 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, + 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, + 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, + 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, + 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, + 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, + 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, + 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, + 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, + 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, + 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, + 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, + 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, + 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, + 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, + 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, + 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, + 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, + 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, + 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, + 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, + 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, + 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, + 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, + 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, + 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, + 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, + 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, + 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, + 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, + 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, + 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, + 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, + 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, + 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, + 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, + 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, + 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, + 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, + 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, + 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, + 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, + 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, + 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, + 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, + 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, + 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, + 0, 0, 0, 0, 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, + 819, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, + 0, 0, 0, 827, 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, + 1, 0, 0, 0, 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, + 0, 841, 1, 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, + 0, 0, 0, 0, 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, + 855, 1, 0, 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, + 0, 0, 0, 863, 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, + 1, 0, 0, 0, 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, + 0, 877, 1, 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, + 0, 0, 0, 0, 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, + 891, 1, 0, 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, + 0, 0, 0, 899, 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, + 1, 0, 0, 0, 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, + 0, 913, 1, 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, + 0, 0, 0, 0, 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, + 927, 1, 0, 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, + 0, 0, 0, 935, 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, + 1, 0, 0, 0, 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, + 0, 949, 1, 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, + 0, 0, 0, 0, 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, + 963, 1, 0, 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 0, 969, 1, 0, + 0, 0, 0, 971, 1, 0, 0, 0, 0, 973, 1, 0, 0, 0, 0, 975, 1, 0, 0, 0, 0, 977, + 1, 0, 0, 0, 0, 979, 1, 0, 0, 0, 0, 981, 1, 0, 0, 0, 0, 983, 1, 0, 0, 0, + 0, 985, 1, 0, 0, 0, 0, 987, 1, 0, 0, 0, 0, 989, 1, 0, 0, 0, 0, 991, 1, + 0, 0, 0, 0, 993, 1, 0, 0, 0, 0, 995, 1, 0, 0, 0, 0, 997, 1, 0, 0, 0, 0, + 999, 1, 0, 0, 0, 0, 1001, 1, 0, 0, 0, 0, 1003, 1, 0, 0, 0, 0, 1005, 1, + 0, 0, 0, 0, 1007, 1, 0, 0, 0, 0, 1009, 1, 0, 0, 0, 0, 1011, 1, 0, 0, 0, + 0, 1013, 1, 0, 0, 0, 0, 1015, 1, 0, 0, 0, 0, 1017, 1, 0, 0, 0, 0, 1019, + 1, 0, 0, 0, 0, 1021, 1, 0, 0, 0, 0, 1023, 1, 0, 0, 0, 0, 1025, 1, 0, 0, + 0, 0, 1027, 1, 0, 0, 0, 0, 1029, 1, 0, 0, 0, 0, 1031, 1, 0, 0, 0, 0, 1033, + 1, 0, 0, 0, 0, 1035, 1, 0, 0, 0, 0, 1037, 1, 0, 0, 0, 0, 1039, 1, 0, 0, + 0, 0, 1041, 1, 0, 0, 0, 0, 1043, 1, 0, 0, 0, 0, 1045, 1, 0, 0, 0, 0, 1047, + 1, 0, 0, 0, 0, 1049, 1, 0, 0, 0, 0, 1051, 1, 0, 0, 0, 0, 1053, 1, 0, 0, + 0, 0, 1055, 1, 0, 0, 0, 0, 1057, 1, 0, 0, 0, 0, 1059, 1, 0, 0, 0, 0, 1061, + 1, 0, 0, 0, 0, 1063, 1, 0, 0, 0, 0, 1065, 1, 0, 0, 0, 0, 1067, 1, 0, 0, + 0, 0, 1069, 1, 0, 0, 0, 0, 1071, 1, 0, 0, 0, 0, 1073, 1, 0, 0, 0, 0, 1075, + 1, 0, 0, 0, 0, 1077, 1, 0, 0, 0, 0, 1079, 1, 0, 0, 0, 0, 1081, 1, 0, 0, + 0, 0, 1083, 1, 0, 0, 0, 0, 1085, 1, 0, 0, 0, 0, 1087, 1, 0, 0, 0, 0, 1089, + 1, 0, 0, 0, 0, 1091, 1, 0, 0, 0, 0, 1093, 1, 0, 0, 0, 0, 1095, 1, 0, 0, + 0, 0, 1097, 1, 0, 0, 0, 0, 1099, 1, 0, 0, 0, 0, 1101, 1, 0, 0, 0, 0, 1103, + 1, 0, 0, 0, 0, 1105, 1, 0, 0, 0, 0, 1107, 1, 0, 0, 0, 0, 1109, 1, 0, 0, + 0, 0, 1111, 1, 0, 0, 0, 0, 1113, 1, 0, 0, 0, 0, 1115, 1, 0, 0, 0, 0, 1117, + 1, 0, 0, 0, 0, 1119, 1, 0, 0, 0, 0, 1121, 1, 0, 0, 0, 0, 1123, 1, 0, 0, + 0, 0, 1125, 1, 0, 0, 0, 0, 1127, 1, 0, 0, 0, 0, 1129, 1, 0, 0, 0, 0, 1131, + 1, 0, 0, 0, 0, 1133, 1, 0, 0, 0, 0, 1135, 1, 0, 0, 0, 0, 1137, 1, 0, 0, + 0, 0, 1139, 1, 0, 0, 0, 0, 1141, 1, 0, 0, 0, 0, 1143, 1, 0, 0, 0, 0, 1145, + 1, 0, 0, 0, 0, 1147, 1, 0, 0, 0, 0, 1149, 1, 0, 0, 0, 0, 1151, 1, 0, 0, + 0, 0, 1153, 1, 0, 0, 0, 0, 1155, 1, 0, 0, 0, 0, 1157, 1, 0, 0, 0, 0, 1159, + 1, 0, 0, 0, 0, 1171, 1, 0, 0, 0, 0, 1173, 1, 0, 0, 0, 0, 1175, 1, 0, 0, + 0, 0, 1177, 1, 0, 0, 0, 0, 1179, 1, 0, 0, 0, 1, 1181, 1, 0, 0, 0, 3, 1183, + 1, 0, 0, 0, 5, 1185, 1, 0, 0, 0, 7, 1187, 1, 0, 0, 0, 9, 1189, 1, 0, 0, + 0, 11, 1191, 1, 0, 0, 0, 13, 1195, 1, 0, 0, 0, 15, 1197, 1, 0, 0, 0, 17, + 1199, 1, 0, 0, 0, 19, 1201, 1, 0, 0, 0, 21, 1203, 1, 0, 0, 0, 23, 1216, + 1, 0, 0, 0, 25, 1231, 1, 0, 0, 0, 27, 1239, 1, 0, 0, 0, 29, 1243, 1, 0, + 0, 0, 31, 1249, 1, 0, 0, 0, 33, 1255, 1, 0, 0, 0, 35, 1265, 1, 0, 0, 0, + 37, 1275, 1, 0, 0, 0, 39, 1281, 1, 0, 0, 0, 41, 1285, 1, 0, 0, 0, 43, 1291, + 1, 0, 0, 0, 45, 1299, 1, 0, 0, 0, 47, 1308, 1, 0, 0, 0, 49, 1317, 1, 0, + 0, 0, 51, 1321, 1, 0, 0, 0, 53, 1326, 1, 0, 0, 0, 55, 1333, 1, 0, 0, 0, + 57, 1339, 1, 0, 0, 0, 59, 1342, 1, 0, 0, 0, 61, 1346, 1, 0, 0, 0, 63, 1349, + 1, 0, 0, 0, 65, 1357, 1, 0, 0, 0, 67, 1362, 1, 0, 0, 0, 69, 1377, 1, 0, + 0, 0, 71, 1384, 1, 0, 0, 0, 73, 1392, 1, 0, 0, 0, 75, 1401, 1, 0, 0, 0, + 77, 1408, 1, 0, 0, 0, 79, 1414, 1, 0, 0, 0, 81, 1421, 1, 0, 0, 0, 83, 1429, + 1, 0, 0, 0, 85, 1436, 1, 0, 0, 0, 87, 1440, 1, 0, 0, 0, 89, 1447, 1, 0, + 0, 0, 91, 1454, 1, 0, 0, 0, 93, 1461, 1, 0, 0, 0, 95, 1468, 1, 0, 0, 0, + 97, 1481, 1, 0, 0, 0, 99, 1494, 1, 0, 0, 0, 101, 1500, 1, 0, 0, 0, 103, + 1507, 1, 0, 0, 0, 105, 1512, 1, 0, 0, 0, 107, 1520, 1, 0, 0, 0, 109, 1525, + 1, 0, 0, 0, 111, 1532, 1, 0, 0, 0, 113, 1538, 1, 0, 0, 0, 115, 1545, 1, + 0, 0, 0, 117, 1553, 1, 0, 0, 0, 119, 1559, 1, 0, 0, 0, 121, 1567, 1, 0, + 0, 0, 123, 1572, 1, 0, 0, 0, 125, 1575, 1, 0, 0, 0, 127, 1581, 1, 0, 0, + 0, 129, 1588, 1, 0, 0, 0, 131, 1593, 1, 0, 0, 0, 133, 1600, 1, 0, 0, 0, + 135, 1605, 1, 0, 0, 0, 137, 1610, 1, 0, 0, 0, 139, 1618, 1, 0, 0, 0, 141, + 1627, 1, 0, 0, 0, 143, 1646, 1, 0, 0, 0, 145, 1648, 1, 0, 0, 0, 147, 1656, + 1, 0, 0, 0, 149, 1668, 1, 0, 0, 0, 151, 1674, 1, 0, 0, 0, 153, 1680, 1, + 0, 0, 0, 155, 1688, 1, 0, 0, 0, 157, 1697, 1, 0, 0, 0, 159, 1705, 1, 0, + 0, 0, 161, 1715, 1, 0, 0, 0, 163, 1723, 1, 0, 0, 0, 165, 1732, 1, 0, 0, + 0, 167, 1739, 1, 0, 0, 0, 169, 1747, 1, 0, 0, 0, 171, 1755, 1, 0, 0, 0, + 173, 1762, 1, 0, 0, 0, 175, 1772, 1, 0, 0, 0, 177, 1780, 1, 0, 0, 0, 179, + 1789, 1, 0, 0, 0, 181, 1803, 1, 0, 0, 0, 183, 1811, 1, 0, 0, 0, 185, 1822, + 1, 0, 0, 0, 187, 1829, 1, 0, 0, 0, 189, 1840, 1, 0, 0, 0, 191, 1854, 1, + 0, 0, 0, 193, 1865, 1, 0, 0, 0, 195, 1876, 1, 0, 0, 0, 197, 1888, 1, 0, + 0, 0, 199, 1896, 1, 0, 0, 0, 201, 1932, 1, 0, 0, 0, 203, 1937, 1, 0, 0, + 0, 205, 1943, 1, 0, 0, 0, 207, 1950, 1, 0, 0, 0, 209, 1959, 1, 0, 0, 0, + 211, 1964, 1, 0, 0, 0, 213, 1970, 1, 0, 0, 0, 215, 1975, 1, 0, 0, 0, 217, + 1983, 1, 0, 0, 0, 219, 1999, 1, 0, 0, 0, 221, 2012, 1, 0, 0, 0, 223, 2025, + 1, 0, 0, 0, 225, 2043, 1, 0, 0, 0, 227, 2056, 1, 0, 0, 0, 229, 2061, 1, + 0, 0, 0, 231, 2070, 1, 0, 0, 0, 233, 2080, 1, 0, 0, 0, 235, 2085, 1, 0, + 0, 0, 237, 2094, 1, 0, 0, 0, 239, 2105, 1, 0, 0, 0, 241, 2112, 1, 0, 0, + 0, 243, 2123, 1, 0, 0, 0, 245, 2130, 1, 0, 0, 0, 247, 2134, 1, 0, 0, 0, + 249, 2145, 1, 0, 0, 0, 251, 2150, 1, 0, 0, 0, 253, 2159, 1, 0, 0, 0, 255, + 2167, 1, 0, 0, 0, 257, 2177, 1, 0, 0, 0, 259, 2187, 1, 0, 0, 0, 261, 2200, + 1, 0, 0, 0, 263, 2208, 1, 0, 0, 0, 265, 2217, 1, 0, 0, 0, 267, 2224, 1, + 0, 0, 0, 269, 2231, 1, 0, 0, 0, 271, 2236, 1, 0, 0, 0, 273, 2245, 1, 0, + 0, 0, 275, 2254, 1, 0, 0, 0, 277, 2264, 1, 0, 0, 0, 279, 2277, 1, 0, 0, + 0, 281, 2288, 1, 0, 0, 0, 283, 2293, 1, 0, 0, 0, 285, 2302, 1, 0, 0, 0, + 287, 2313, 1, 0, 0, 0, 289, 2326, 1, 0, 0, 0, 291, 2338, 1, 0, 0, 0, 293, + 2351, 1, 0, 0, 0, 295, 2355, 1, 0, 0, 0, 297, 2358, 1, 0, 0, 0, 299, 2382, + 1, 0, 0, 0, 301, 2389, 1, 0, 0, 0, 303, 2394, 1, 0, 0, 0, 305, 2400, 1, + 0, 0, 0, 307, 2405, 1, 0, 0, 0, 309, 2410, 1, 0, 0, 0, 311, 2420, 1, 0, + 0, 0, 313, 2428, 1, 0, 0, 0, 315, 2430, 1, 0, 0, 0, 317, 2435, 1, 0, 0, + 0, 319, 2442, 1, 0, 0, 0, 321, 2453, 1, 0, 0, 0, 323, 2464, 1, 0, 0, 0, + 325, 2476, 1, 0, 0, 0, 327, 2480, 1, 0, 0, 0, 329, 2485, 1, 0, 0, 0, 331, + 2492, 1, 0, 0, 0, 333, 2500, 1, 0, 0, 0, 335, 2506, 1, 0, 0, 0, 337, 2513, + 1, 0, 0, 0, 339, 2520, 1, 0, 0, 0, 341, 2527, 1, 0, 0, 0, 343, 2533, 1, + 0, 0, 0, 345, 2540, 1, 0, 0, 0, 347, 2548, 1, 0, 0, 0, 349, 2556, 1, 0, + 0, 0, 351, 2563, 1, 0, 0, 0, 353, 2571, 1, 0, 0, 0, 355, 2579, 1, 0, 0, + 0, 357, 2586, 1, 0, 0, 0, 359, 2595, 1, 0, 0, 0, 361, 2604, 1, 0, 0, 0, + 363, 2612, 1, 0, 0, 0, 365, 2634, 1, 0, 0, 0, 367, 2640, 1, 0, 0, 0, 369, + 2645, 1, 0, 0, 0, 371, 2653, 1, 0, 0, 0, 373, 2660, 1, 0, 0, 0, 375, 2665, + 1, 0, 0, 0, 377, 2672, 1, 0, 0, 0, 379, 2678, 1, 0, 0, 0, 381, 2684, 1, + 0, 0, 0, 383, 2693, 1, 0, 0, 0, 385, 2703, 1, 0, 0, 0, 387, 2707, 1, 0, + 0, 0, 389, 2715, 1, 0, 0, 0, 391, 2721, 1, 0, 0, 0, 393, 2728, 1, 0, 0, + 0, 395, 2733, 1, 0, 0, 0, 397, 2738, 1, 0, 0, 0, 399, 2747, 1, 0, 0, 0, + 401, 2757, 1, 0, 0, 0, 403, 2762, 1, 0, 0, 0, 405, 2771, 1, 0, 0, 0, 407, + 2781, 1, 0, 0, 0, 409, 2791, 1, 0, 0, 0, 411, 2799, 1, 0, 0, 0, 413, 2806, + 1, 0, 0, 0, 415, 2812, 1, 0, 0, 0, 417, 2819, 1, 0, 0, 0, 419, 2825, 1, + 0, 0, 0, 421, 2831, 1, 0, 0, 0, 423, 2840, 1, 0, 0, 0, 425, 2847, 1, 0, + 0, 0, 427, 2860, 1, 0, 0, 0, 429, 2865, 1, 0, 0, 0, 431, 2874, 1, 0, 0, + 0, 433, 2881, 1, 0, 0, 0, 435, 2886, 1, 0, 0, 0, 437, 2891, 1, 0, 0, 0, + 439, 2901, 1, 0, 0, 0, 441, 2905, 1, 0, 0, 0, 443, 2915, 1, 0, 0, 0, 445, + 2924, 1, 0, 0, 0, 447, 2932, 1, 0, 0, 0, 449, 2937, 1, 0, 0, 0, 451, 2943, + 1, 0, 0, 0, 453, 2947, 1, 0, 0, 0, 455, 2958, 1, 0, 0, 0, 457, 2961, 1, + 0, 0, 0, 459, 2968, 1, 0, 0, 0, 461, 2978, 1, 0, 0, 0, 463, 2981, 1, 0, + 0, 0, 465, 2993, 1, 0, 0, 0, 467, 2999, 1, 0, 0, 0, 469, 3007, 1, 0, 0, + 0, 471, 3014, 1, 0, 0, 0, 473, 3020, 1, 0, 0, 0, 475, 3027, 1, 0, 0, 0, + 477, 3035, 1, 0, 0, 0, 479, 3039, 1, 0, 0, 0, 481, 3047, 1, 0, 0, 0, 483, + 3060, 1, 0, 0, 0, 485, 3070, 1, 0, 0, 0, 487, 3079, 1, 0, 0, 0, 489, 3084, + 1, 0, 0, 0, 491, 3093, 1, 0, 0, 0, 493, 3101, 1, 0, 0, 0, 495, 3106, 1, + 0, 0, 0, 497, 3111, 1, 0, 0, 0, 499, 3114, 1, 0, 0, 0, 501, 3131, 1, 0, + 0, 0, 503, 3144, 1, 0, 0, 0, 505, 3151, 1, 0, 0, 0, 507, 3161, 1, 0, 0, + 0, 509, 3165, 1, 0, 0, 0, 511, 3170, 1, 0, 0, 0, 513, 3175, 1, 0, 0, 0, + 515, 3180, 1, 0, 0, 0, 517, 3186, 1, 0, 0, 0, 519, 3190, 1, 0, 0, 0, 521, + 3195, 1, 0, 0, 0, 523, 3200, 1, 0, 0, 0, 525, 3206, 1, 0, 0, 0, 527, 3215, + 1, 0, 0, 0, 529, 3222, 1, 0, 0, 0, 531, 3227, 1, 0, 0, 0, 533, 3235, 1, + 0, 0, 0, 535, 3240, 1, 0, 0, 0, 537, 3260, 1, 0, 0, 0, 539, 3268, 1, 0, + 0, 0, 541, 3273, 1, 0, 0, 0, 543, 3278, 1, 0, 0, 0, 545, 3284, 1, 0, 0, + 0, 547, 3289, 1, 0, 0, 0, 549, 3295, 1, 0, 0, 0, 551, 3301, 1, 0, 0, 0, + 553, 3306, 1, 0, 0, 0, 555, 3311, 1, 0, 0, 0, 557, 3316, 1, 0, 0, 0, 559, + 3322, 1, 0, 0, 0, 561, 3332, 1, 0, 0, 0, 563, 3347, 1, 0, 0, 0, 565, 3356, + 1, 0, 0, 0, 567, 3361, 1, 0, 0, 0, 569, 3369, 1, 0, 0, 0, 571, 3382, 1, + 0, 0, 0, 573, 3389, 1, 0, 0, 0, 575, 3393, 1, 0, 0, 0, 577, 3399, 1, 0, + 0, 0, 579, 3407, 1, 0, 0, 0, 581, 3417, 1, 0, 0, 0, 583, 3427, 1, 0, 0, + 0, 585, 3438, 1, 0, 0, 0, 587, 3454, 1, 0, 0, 0, 589, 3467, 1, 0, 0, 0, + 591, 3485, 1, 0, 0, 0, 593, 3505, 1, 0, 0, 0, 595, 3518, 1, 0, 0, 0, 597, + 3531, 1, 0, 0, 0, 599, 3535, 1, 0, 0, 0, 601, 3544, 1, 0, 0, 0, 603, 3549, + 1, 0, 0, 0, 605, 3555, 1, 0, 0, 0, 607, 3559, 1, 0, 0, 0, 609, 3567, 1, + 0, 0, 0, 611, 3578, 1, 0, 0, 0, 613, 3582, 1, 0, 0, 0, 615, 3588, 1, 0, + 0, 0, 617, 3595, 1, 0, 0, 0, 619, 3603, 1, 0, 0, 0, 621, 3617, 1, 0, 0, + 0, 623, 3624, 1, 0, 0, 0, 625, 3630, 1, 0, 0, 0, 627, 3635, 1, 0, 0, 0, + 629, 3640, 1, 0, 0, 0, 631, 3646, 1, 0, 0, 0, 633, 3654, 1, 0, 0, 0, 635, + 3663, 1, 0, 0, 0, 637, 3669, 1, 0, 0, 0, 639, 3674, 1, 0, 0, 0, 641, 3683, + 1, 0, 0, 0, 643, 3687, 1, 0, 0, 0, 645, 3690, 1, 0, 0, 0, 647, 3700, 1, + 0, 0, 0, 649, 3713, 1, 0, 0, 0, 651, 3717, 1, 0, 0, 0, 653, 3722, 1, 0, + 0, 0, 655, 3728, 1, 0, 0, 0, 657, 3737, 1, 0, 0, 0, 659, 3740, 1, 0, 0, + 0, 661, 3747, 1, 0, 0, 0, 663, 3750, 1, 0, 0, 0, 665, 3754, 1, 0, 0, 0, + 667, 3759, 1, 0, 0, 0, 669, 3764, 1, 0, 0, 0, 671, 3773, 1, 0, 0, 0, 673, + 3783, 1, 0, 0, 0, 675, 3786, 1, 0, 0, 0, 677, 3792, 1, 0, 0, 0, 679, 3798, + 1, 0, 0, 0, 681, 3806, 1, 0, 0, 0, 683, 3811, 1, 0, 0, 0, 685, 3821, 1, + 0, 0, 0, 687, 3831, 1, 0, 0, 0, 689, 3838, 1, 0, 0, 0, 691, 3848, 1, 0, + 0, 0, 693, 3859, 1, 0, 0, 0, 695, 3868, 1, 0, 0, 0, 697, 3884, 1, 0, 0, + 0, 699, 3901, 1, 0, 0, 0, 701, 3920, 1, 0, 0, 0, 703, 3935, 1, 0, 0, 0, + 705, 3940, 1, 0, 0, 0, 707, 3946, 1, 0, 0, 0, 709, 3954, 1, 0, 0, 0, 711, + 3961, 1, 0, 0, 0, 713, 3972, 1, 0, 0, 0, 715, 3981, 1, 0, 0, 0, 717, 3984, + 1, 0, 0, 0, 719, 3986, 1, 0, 0, 0, 721, 3991, 1, 0, 0, 0, 723, 3996, 1, + 0, 0, 0, 725, 4007, 1, 0, 0, 0, 727, 4015, 1, 0, 0, 0, 729, 4022, 1, 0, + 0, 0, 731, 4030, 1, 0, 0, 0, 733, 4037, 1, 0, 0, 0, 735, 4046, 1, 0, 0, + 0, 737, 4056, 1, 0, 0, 0, 739, 4064, 1, 0, 0, 0, 741, 4072, 1, 0, 0, 0, + 743, 4077, 1, 0, 0, 0, 745, 4087, 1, 0, 0, 0, 747, 4099, 1, 0, 0, 0, 749, + 4107, 1, 0, 0, 0, 751, 4118, 1, 0, 0, 0, 753, 4127, 1, 0, 0, 0, 755, 4142, + 1, 0, 0, 0, 757, 4157, 1, 0, 0, 0, 759, 4163, 1, 0, 0, 0, 761, 4170, 1, + 0, 0, 0, 763, 4176, 1, 0, 0, 0, 765, 4184, 1, 0, 0, 0, 767, 4192, 1, 0, + 0, 0, 769, 4199, 1, 0, 0, 0, 771, 4205, 1, 0, 0, 0, 773, 4210, 1, 0, 0, + 0, 775, 4215, 1, 0, 0, 0, 777, 4225, 1, 0, 0, 0, 779, 4232, 1, 0, 0, 0, + 781, 4240, 1, 0, 0, 0, 783, 4248, 1, 0, 0, 0, 785, 4256, 1, 0, 0, 0, 787, + 4267, 1, 0, 0, 0, 789, 4274, 1, 0, 0, 0, 791, 4282, 1, 0, 0, 0, 793, 4289, + 1, 0, 0, 0, 795, 4296, 1, 0, 0, 0, 797, 4307, 1, 0, 0, 0, 799, 4315, 1, + 0, 0, 0, 801, 4335, 1, 0, 0, 0, 803, 4344, 1, 0, 0, 0, 805, 4352, 1, 0, + 0, 0, 807, 4365, 1, 0, 0, 0, 809, 4376, 1, 0, 0, 0, 811, 4385, 1, 0, 0, + 0, 813, 4395, 1, 0, 0, 0, 815, 4403, 1, 0, 0, 0, 817, 4415, 1, 0, 0, 0, + 819, 4422, 1, 0, 0, 0, 821, 4429, 1, 0, 0, 0, 823, 4439, 1, 0, 0, 0, 825, + 4447, 1, 0, 0, 0, 827, 4454, 1, 0, 0, 0, 829, 4464, 1, 0, 0, 0, 831, 4470, + 1, 0, 0, 0, 833, 4476, 1, 0, 0, 0, 835, 4481, 1, 0, 0, 0, 837, 4487, 1, + 0, 0, 0, 839, 4496, 1, 0, 0, 0, 841, 4503, 1, 0, 0, 0, 843, 4508, 1, 0, + 0, 0, 845, 4515, 1, 0, 0, 0, 847, 4523, 1, 0, 0, 0, 849, 4527, 1, 0, 0, + 0, 851, 4532, 1, 0, 0, 0, 853, 4535, 1, 0, 0, 0, 855, 4542, 1, 0, 0, 0, + 857, 4551, 1, 0, 0, 0, 859, 4561, 1, 0, 0, 0, 861, 4568, 1, 0, 0, 0, 863, + 4576, 1, 0, 0, 0, 865, 4583, 1, 0, 0, 0, 867, 4590, 1, 0, 0, 0, 869, 4595, + 1, 0, 0, 0, 871, 4605, 1, 0, 0, 0, 873, 4618, 1, 0, 0, 0, 875, 4626, 1, + 0, 0, 0, 877, 4639, 1, 0, 0, 0, 879, 4643, 1, 0, 0, 0, 881, 4648, 1, 0, + 0, 0, 883, 4669, 1, 0, 0, 0, 885, 4675, 1, 0, 0, 0, 887, 4680, 1, 0, 0, + 0, 889, 4687, 1, 0, 0, 0, 891, 4692, 1, 0, 0, 0, 893, 4701, 1, 0, 0, 0, + 895, 4710, 1, 0, 0, 0, 897, 4720, 1, 0, 0, 0, 899, 4727, 1, 0, 0, 0, 901, + 4733, 1, 0, 0, 0, 903, 4737, 1, 0, 0, 0, 905, 4752, 1, 0, 0, 0, 907, 4758, + 1, 0, 0, 0, 909, 4765, 1, 0, 0, 0, 911, 4771, 1, 0, 0, 0, 913, 4778, 1, + 0, 0, 0, 915, 4784, 1, 0, 0, 0, 917, 4791, 1, 0, 0, 0, 919, 4796, 1, 0, + 0, 0, 921, 4804, 1, 0, 0, 0, 923, 4811, 1, 0, 0, 0, 925, 4821, 1, 0, 0, + 0, 927, 4828, 1, 0, 0, 0, 929, 4835, 1, 0, 0, 0, 931, 4842, 1, 0, 0, 0, + 933, 4852, 1, 0, 0, 0, 935, 4856, 1, 0, 0, 0, 937, 4866, 1, 0, 0, 0, 939, + 4873, 1, 0, 0, 0, 941, 4878, 1, 0, 0, 0, 943, 4885, 1, 0, 0, 0, 945, 4891, + 1, 0, 0, 0, 947, 4898, 1, 0, 0, 0, 949, 4910, 1, 0, 0, 0, 951, 4917, 1, + 0, 0, 0, 953, 4925, 1, 0, 0, 0, 955, 4929, 1, 0, 0, 0, 957, 4934, 1, 0, + 0, 0, 959, 4940, 1, 0, 0, 0, 961, 4944, 1, 0, 0, 0, 963, 4954, 1, 0, 0, + 0, 965, 4965, 1, 0, 0, 0, 967, 4970, 1, 0, 0, 0, 969, 4975, 1, 0, 0, 0, + 971, 4980, 1, 0, 0, 0, 973, 4985, 1, 0, 0, 0, 975, 4995, 1, 0, 0, 0, 977, + 5003, 1, 0, 0, 0, 979, 5006, 1, 0, 0, 0, 981, 5016, 1, 0, 0, 0, 983, 5029, + 1, 0, 0, 0, 985, 5038, 1, 0, 0, 0, 987, 5050, 1, 0, 0, 0, 989, 5056, 1, + 0, 0, 0, 991, 5061, 1, 0, 0, 0, 993, 5070, 1, 0, 0, 0, 995, 5075, 1, 0, + 0, 0, 997, 5080, 1, 0, 0, 0, 999, 5089, 1, 0, 0, 0, 1001, 5098, 1, 0, 0, + 0, 1003, 5103, 1, 0, 0, 0, 1005, 5113, 1, 0, 0, 0, 1007, 5119, 1, 0, 0, + 0, 1009, 5129, 1, 0, 0, 0, 1011, 5141, 1, 0, 0, 0, 1013, 5151, 1, 0, 0, + 0, 1015, 5157, 1, 0, 0, 0, 1017, 5164, 1, 0, 0, 0, 1019, 5171, 1, 0, 0, + 0, 1021, 5177, 1, 0, 0, 0, 1023, 5186, 1, 0, 0, 0, 1025, 5189, 1, 0, 0, + 0, 1027, 5196, 1, 0, 0, 0, 1029, 5200, 1, 0, 0, 0, 1031, 5205, 1, 0, 0, + 0, 1033, 5212, 1, 0, 0, 0, 1035, 5218, 1, 0, 0, 0, 1037, 5224, 1, 0, 0, + 0, 1039, 5231, 1, 0, 0, 0, 1041, 5241, 1, 0, 0, 0, 1043, 5249, 1, 0, 0, + 0, 1045, 5258, 1, 0, 0, 0, 1047, 5268, 1, 0, 0, 0, 1049, 5276, 1, 0, 0, + 0, 1051, 5282, 1, 0, 0, 0, 1053, 5289, 1, 0, 0, 0, 1055, 5297, 1, 0, 0, + 0, 1057, 5305, 1, 0, 0, 0, 1059, 5310, 1, 0, 0, 0, 1061, 5316, 1, 0, 0, + 0, 1063, 5321, 1, 0, 0, 0, 1065, 5330, 1, 0, 0, 0, 1067, 5335, 1, 0, 0, + 0, 1069, 5340, 1, 0, 0, 0, 1071, 5346, 1, 0, 0, 0, 1073, 5356, 1, 0, 0, + 0, 1075, 5361, 1, 0, 0, 0, 1077, 5366, 1, 0, 0, 0, 1079, 5375, 1, 0, 0, + 0, 1081, 5381, 1, 0, 0, 0, 1083, 5385, 1, 0, 0, 0, 1085, 5393, 1, 0, 0, + 0, 1087, 5395, 1, 0, 0, 0, 1089, 5403, 1, 0, 0, 0, 1091, 5405, 1, 0, 0, + 0, 1093, 5411, 1, 0, 0, 0, 1095, 5413, 1, 0, 0, 0, 1097, 5419, 1, 0, 0, + 0, 1099, 5421, 1, 0, 0, 0, 1101, 5423, 1, 0, 0, 0, 1103, 5425, 1, 0, 0, + 0, 1105, 5427, 1, 0, 0, 0, 1107, 5429, 1, 0, 0, 0, 1109, 5431, 1, 0, 0, + 0, 1111, 5433, 1, 0, 0, 0, 1113, 5435, 1, 0, 0, 0, 1115, 5438, 1, 0, 0, + 0, 1117, 5440, 1, 0, 0, 0, 1119, 5442, 1, 0, 0, 0, 1121, 5445, 1, 0, 0, + 0, 1123, 5447, 1, 0, 0, 0, 1125, 5449, 1, 0, 0, 0, 1127, 5452, 1, 0, 0, + 0, 1129, 5456, 1, 0, 0, 0, 1131, 5459, 1, 0, 0, 0, 1133, 5462, 1, 0, 0, + 0, 1135, 5464, 1, 0, 0, 0, 1137, 5491, 1, 0, 0, 0, 1139, 5511, 1, 0, 0, + 0, 1141, 5517, 1, 0, 0, 0, 1143, 5520, 1, 0, 0, 0, 1145, 5527, 1, 0, 0, + 0, 1147, 5534, 1, 0, 0, 0, 1149, 5541, 1, 0, 0, 0, 1151, 5555, 1, 0, 0, + 0, 1153, 5557, 1, 0, 0, 0, 1155, 5577, 1, 0, 0, 0, 1157, 5582, 1, 0, 0, + 0, 1159, 5586, 1, 0, 0, 0, 1161, 5615, 1, 0, 0, 0, 1163, 5617, 1, 0, 0, + 0, 1165, 5626, 1, 0, 0, 0, 1167, 5628, 1, 0, 0, 0, 1169, 5634, 1, 0, 0, + 0, 1171, 5636, 1, 0, 0, 0, 1173, 5655, 1, 0, 0, 0, 1175, 5668, 1, 0, 0, + 0, 1177, 5686, 1, 0, 0, 0, 1179, 5692, 1, 0, 0, 0, 1181, 1182, 5, 59, 0, + 0, 1182, 2, 1, 0, 0, 0, 1183, 1184, 5, 40, 0, 0, 1184, 4, 1, 0, 0, 0, 1185, + 1186, 5, 41, 0, 0, 1186, 6, 1, 0, 0, 0, 1187, 1188, 5, 44, 0, 0, 1188, + 8, 1, 0, 0, 0, 1189, 1190, 5, 46, 0, 0, 1190, 10, 1, 0, 0, 0, 1191, 1192, + 5, 46, 0, 0, 1192, 1193, 5, 46, 0, 0, 1193, 1194, 5, 46, 0, 0, 1194, 12, + 1, 0, 0, 0, 1195, 1196, 5, 91, 0, 0, 1196, 14, 1, 0, 0, 0, 1197, 1198, + 5, 93, 0, 0, 1198, 16, 1, 0, 0, 0, 1199, 1200, 5, 123, 0, 0, 1200, 18, + 1, 0, 0, 0, 1201, 1202, 5, 125, 0, 0, 1202, 20, 1, 0, 0, 0, 1203, 1204, + 5, 65, 0, 0, 1204, 1205, 5, 67, 0, 0, 1205, 1206, 5, 67, 0, 0, 1206, 1207, + 5, 79, 0, 0, 1207, 1208, 5, 85, 0, 0, 1208, 1209, 5, 78, 0, 0, 1209, 1210, + 5, 84, 0, 0, 1210, 1211, 5, 95, 0, 0, 1211, 1212, 5, 76, 0, 0, 1212, 1213, + 5, 79, 0, 0, 1213, 1214, 5, 67, 0, 0, 1214, 1215, 5, 75, 0, 0, 1215, 22, + 1, 0, 0, 0, 1216, 1217, 5, 65, 0, 0, 1217, 1218, 5, 67, 0, 0, 1218, 1219, + 5, 67, 0, 0, 1219, 1220, 5, 79, 0, 0, 1220, 1221, 5, 85, 0, 0, 1221, 1222, + 5, 78, 0, 0, 1222, 1223, 5, 84, 0, 0, 1223, 1224, 5, 95, 0, 0, 1224, 1225, + 5, 85, 0, 0, 1225, 1226, 5, 78, 0, 0, 1226, 1227, 5, 76, 0, 0, 1227, 1228, + 5, 79, 0, 0, 1228, 1229, 5, 67, 0, 0, 1229, 1230, 5, 75, 0, 0, 1230, 24, + 1, 0, 0, 0, 1231, 1232, 5, 65, 0, 0, 1232, 1233, 5, 67, 0, 0, 1233, 1234, + 5, 84, 0, 0, 1234, 1235, 5, 73, 0, 0, 1235, 1236, 5, 79, 0, 0, 1236, 1237, + 5, 78, 0, 0, 1237, 1238, 5, 83, 0, 0, 1238, 26, 1, 0, 0, 0, 1239, 1240, + 5, 65, 0, 0, 1240, 1241, 5, 68, 0, 0, 1241, 1242, 5, 68, 0, 0, 1242, 28, + 1, 0, 0, 0, 1243, 1244, 5, 65, 0, 0, 1244, 1245, 5, 68, 0, 0, 1245, 1246, + 5, 77, 0, 0, 1246, 1247, 5, 73, 0, 0, 1247, 1248, 5, 78, 0, 0, 1248, 30, + 1, 0, 0, 0, 1249, 1250, 5, 65, 0, 0, 1250, 1251, 5, 70, 0, 0, 1251, 1252, + 5, 84, 0, 0, 1252, 1253, 5, 69, 0, 0, 1253, 1254, 5, 82, 0, 0, 1254, 32, + 1, 0, 0, 0, 1255, 1256, 5, 65, 0, 0, 1256, 1257, 5, 71, 0, 0, 1257, 1258, + 5, 71, 0, 0, 1258, 1259, 5, 95, 0, 0, 1259, 1260, 5, 83, 0, 0, 1260, 1261, + 5, 84, 0, 0, 1261, 1262, 5, 65, 0, 0, 1262, 1263, 5, 84, 0, 0, 1263, 1264, + 5, 69, 0, 0, 1264, 34, 1, 0, 0, 0, 1265, 1266, 5, 65, 0, 0, 1266, 1267, + 5, 71, 0, 0, 1267, 1268, 5, 71, 0, 0, 1268, 1269, 5, 82, 0, 0, 1269, 1270, + 5, 69, 0, 0, 1270, 1271, 5, 71, 0, 0, 1271, 1272, 5, 65, 0, 0, 1272, 1273, + 5, 84, 0, 0, 1273, 1274, 5, 69, 0, 0, 1274, 36, 1, 0, 0, 0, 1275, 1276, + 5, 65, 0, 0, 1276, 1277, 5, 76, 0, 0, 1277, 1278, 5, 73, 0, 0, 1278, 1279, + 5, 65, 0, 0, 1279, 1280, 5, 83, 0, 0, 1280, 38, 1, 0, 0, 0, 1281, 1282, + 5, 65, 0, 0, 1282, 1283, 5, 76, 0, 0, 1283, 1284, 5, 76, 0, 0, 1284, 40, + 1, 0, 0, 0, 1285, 1286, 5, 65, 0, 0, 1286, 1287, 5, 76, 0, 0, 1287, 1288, + 5, 84, 0, 0, 1288, 1289, 5, 69, 0, 0, 1289, 1290, 5, 82, 0, 0, 1290, 42, + 1, 0, 0, 0, 1291, 1292, 5, 65, 0, 0, 1292, 1293, 5, 78, 0, 0, 1293, 1294, + 5, 65, 0, 0, 1294, 1295, 5, 76, 0, 0, 1295, 1296, 5, 89, 0, 0, 1296, 1297, + 5, 90, 0, 0, 1297, 1298, 5, 69, 0, 0, 1298, 44, 1, 0, 0, 0, 1299, 1300, + 5, 65, 0, 0, 1300, 1301, 5, 78, 0, 0, 1301, 1302, 5, 65, 0, 0, 1302, 1303, + 5, 76, 0, 0, 1303, 1304, 5, 89, 0, 0, 1304, 1305, 5, 90, 0, 0, 1305, 1306, + 5, 69, 0, 0, 1306, 1307, 5, 68, 0, 0, 1307, 46, 1, 0, 0, 0, 1308, 1309, + 5, 65, 0, 0, 1309, 1310, 5, 78, 0, 0, 1310, 1311, 5, 65, 0, 0, 1311, 1312, + 5, 76, 0, 0, 1312, 1313, 5, 89, 0, 0, 1313, 1314, 5, 90, 0, 0, 1314, 1315, + 5, 69, 0, 0, 1315, 1316, 5, 82, 0, 0, 1316, 48, 1, 0, 0, 0, 1317, 1318, + 5, 65, 0, 0, 1318, 1319, 5, 78, 0, 0, 1319, 1320, 5, 68, 0, 0, 1320, 50, + 1, 0, 0, 0, 1321, 1322, 5, 65, 0, 0, 1322, 1323, 5, 78, 0, 0, 1323, 1324, + 5, 84, 0, 0, 1324, 1325, 5, 73, 0, 0, 1325, 52, 1, 0, 0, 0, 1326, 1327, + 5, 65, 0, 0, 1327, 1328, 5, 80, 0, 0, 1328, 1329, 5, 80, 0, 0, 1329, 1330, + 5, 69, 0, 0, 1330, 1331, 5, 78, 0, 0, 1331, 1332, 5, 68, 0, 0, 1332, 54, + 1, 0, 0, 0, 1333, 1334, 5, 65, 0, 0, 1334, 1335, 5, 82, 0, 0, 1335, 1336, + 5, 82, 0, 0, 1336, 1337, 5, 65, 0, 0, 1337, 1338, 5, 89, 0, 0, 1338, 56, + 1, 0, 0, 0, 1339, 1340, 5, 65, 0, 0, 1340, 1341, 5, 83, 0, 0, 1341, 58, + 1, 0, 0, 0, 1342, 1343, 5, 65, 0, 0, 1343, 1344, 5, 83, 0, 0, 1344, 1345, + 5, 67, 0, 0, 1345, 60, 1, 0, 0, 0, 1346, 1347, 5, 65, 0, 0, 1347, 1348, + 5, 84, 0, 0, 1348, 62, 1, 0, 0, 0, 1349, 1350, 5, 65, 0, 0, 1350, 1351, + 5, 85, 0, 0, 1351, 1352, 5, 84, 0, 0, 1352, 1353, 5, 72, 0, 0, 1353, 1354, + 5, 79, 0, 0, 1354, 1355, 5, 82, 0, 0, 1355, 1356, 5, 83, 0, 0, 1356, 64, + 1, 0, 0, 0, 1357, 1358, 5, 65, 0, 0, 1358, 1359, 5, 85, 0, 0, 1359, 1360, + 5, 84, 0, 0, 1360, 1361, 5, 79, 0, 0, 1361, 66, 1, 0, 0, 0, 1362, 1363, + 5, 65, 0, 0, 1363, 1364, 5, 85, 0, 0, 1364, 1365, 5, 84, 0, 0, 1365, 1366, + 5, 79, 0, 0, 1366, 1367, 5, 95, 0, 0, 1367, 1368, 5, 73, 0, 0, 1368, 1369, + 5, 78, 0, 0, 1369, 1370, 5, 67, 0, 0, 1370, 1371, 5, 82, 0, 0, 1371, 1372, + 5, 69, 0, 0, 1372, 1373, 5, 77, 0, 0, 1373, 1374, 5, 69, 0, 0, 1374, 1375, + 5, 78, 0, 0, 1375, 1376, 5, 84, 0, 0, 1376, 68, 1, 0, 0, 0, 1377, 1378, + 5, 65, 0, 0, 1378, 1379, 5, 76, 0, 0, 1379, 1380, 5, 87, 0, 0, 1380, 1381, + 5, 65, 0, 0, 1381, 1382, 5, 89, 0, 0, 1382, 1383, 5, 83, 0, 0, 1383, 70, + 1, 0, 0, 0, 1384, 1385, 5, 66, 0, 0, 1385, 1386, 5, 65, 0, 0, 1386, 1387, + 5, 67, 0, 0, 1387, 1388, 5, 75, 0, 0, 1388, 1389, 5, 69, 0, 0, 1389, 1390, + 5, 78, 0, 0, 1390, 1391, 5, 68, 0, 0, 1391, 72, 1, 0, 0, 0, 1392, 1393, + 5, 66, 0, 0, 1393, 1394, 5, 65, 0, 0, 1394, 1395, 5, 67, 0, 0, 1395, 1396, + 5, 75, 0, 0, 1396, 1397, 5, 69, 0, 0, 1397, 1398, 5, 78, 0, 0, 1398, 1399, + 5, 68, 0, 0, 1399, 1400, 5, 83, 0, 0, 1400, 74, 1, 0, 0, 0, 1401, 1402, + 5, 66, 0, 0, 1402, 1403, 5, 65, 0, 0, 1403, 1404, 5, 67, 0, 0, 1404, 1405, + 5, 75, 0, 0, 1405, 1406, 5, 85, 0, 0, 1406, 1407, 5, 80, 0, 0, 1407, 76, + 1, 0, 0, 0, 1408, 1409, 5, 66, 0, 0, 1409, 1410, 5, 69, 0, 0, 1410, 1411, + 5, 71, 0, 0, 1411, 1412, 5, 73, 0, 0, 1412, 1413, 5, 78, 0, 0, 1413, 78, + 1, 0, 0, 0, 1414, 1415, 5, 66, 0, 0, 1415, 1416, 5, 69, 0, 0, 1416, 1417, + 5, 76, 0, 0, 1417, 1418, 5, 79, 0, 0, 1418, 1419, 5, 78, 0, 0, 1419, 1420, + 5, 71, 0, 0, 1420, 80, 1, 0, 0, 0, 1421, 1422, 5, 66, 0, 0, 1422, 1423, + 5, 69, 0, 0, 1423, 1424, 5, 84, 0, 0, 1424, 1425, 5, 87, 0, 0, 1425, 1426, + 5, 69, 0, 0, 1426, 1427, 5, 69, 0, 0, 1427, 1428, 5, 78, 0, 0, 1428, 82, + 1, 0, 0, 0, 1429, 1430, 5, 66, 0, 0, 1430, 1431, 5, 73, 0, 0, 1431, 1432, + 5, 71, 0, 0, 1432, 1433, 5, 73, 0, 0, 1433, 1434, 5, 78, 0, 0, 1434, 1435, + 5, 84, 0, 0, 1435, 84, 1, 0, 0, 0, 1436, 1437, 5, 66, 0, 0, 1437, 1438, + 5, 73, 0, 0, 1438, 1439, 5, 78, 0, 0, 1439, 86, 1, 0, 0, 0, 1440, 1441, + 5, 66, 0, 0, 1441, 1442, 5, 73, 0, 0, 1442, 1443, 5, 78, 0, 0, 1443, 1444, + 5, 65, 0, 0, 1444, 1445, 5, 82, 0, 0, 1445, 1446, 5, 89, 0, 0, 1446, 88, + 1, 0, 0, 0, 1447, 1448, 5, 66, 0, 0, 1448, 1449, 5, 73, 0, 0, 1449, 1450, + 5, 78, 0, 0, 1450, 1451, 5, 76, 0, 0, 1451, 1452, 5, 79, 0, 0, 1452, 1453, + 5, 71, 0, 0, 1453, 90, 1, 0, 0, 0, 1454, 1455, 5, 66, 0, 0, 1455, 1456, + 5, 73, 0, 0, 1456, 1457, 5, 84, 0, 0, 1457, 1458, 5, 65, 0, 0, 1458, 1459, + 5, 78, 0, 0, 1459, 1460, 5, 68, 0, 0, 1460, 92, 1, 0, 0, 0, 1461, 1462, + 5, 66, 0, 0, 1462, 1463, 5, 73, 0, 0, 1463, 1464, 5, 84, 0, 0, 1464, 1465, + 5, 77, 0, 0, 1465, 1466, 5, 65, 0, 0, 1466, 1467, 5, 80, 0, 0, 1467, 94, + 1, 0, 0, 0, 1468, 1469, 5, 66, 0, 0, 1469, 1470, 5, 73, 0, 0, 1470, 1471, + 5, 84, 0, 0, 1471, 1472, 5, 77, 0, 0, 1472, 1473, 5, 65, 0, 0, 1473, 1474, + 5, 80, 0, 0, 1474, 1475, 5, 95, 0, 0, 1475, 1476, 5, 69, 0, 0, 1476, 1477, + 5, 77, 0, 0, 1477, 1478, 5, 80, 0, 0, 1478, 1479, 5, 84, 0, 0, 1479, 1480, + 5, 89, 0, 0, 1480, 96, 1, 0, 0, 0, 1481, 1482, 5, 66, 0, 0, 1482, 1483, + 5, 73, 0, 0, 1483, 1484, 5, 84, 0, 0, 1484, 1485, 5, 77, 0, 0, 1485, 1486, + 5, 65, 0, 0, 1486, 1487, 5, 80, 0, 0, 1487, 1488, 5, 95, 0, 0, 1488, 1489, + 5, 85, 0, 0, 1489, 1490, 5, 78, 0, 0, 1490, 1491, 5, 73, 0, 0, 1491, 1492, + 5, 79, 0, 0, 1492, 1493, 5, 78, 0, 0, 1493, 98, 1, 0, 0, 0, 1494, 1495, + 5, 66, 0, 0, 1495, 1496, 5, 73, 0, 0, 1496, 1497, 5, 84, 0, 0, 1497, 1498, + 5, 79, 0, 0, 1498, 1499, 5, 82, 0, 0, 1499, 100, 1, 0, 0, 0, 1500, 1501, + 5, 66, 0, 0, 1501, 1502, 5, 73, 0, 0, 1502, 1503, 5, 84, 0, 0, 1503, 1504, + 5, 88, 0, 0, 1504, 1505, 5, 79, 0, 0, 1505, 1506, 5, 82, 0, 0, 1506, 102, + 1, 0, 0, 0, 1507, 1508, 5, 66, 0, 0, 1508, 1509, 5, 76, 0, 0, 1509, 1510, + 5, 79, 0, 0, 1510, 1511, 5, 66, 0, 0, 1511, 104, 1, 0, 0, 0, 1512, 1513, + 5, 66, 0, 0, 1513, 1514, 5, 79, 0, 0, 1514, 1515, 5, 79, 0, 0, 1515, 1516, + 5, 76, 0, 0, 1516, 1517, 5, 69, 0, 0, 1517, 1518, 5, 65, 0, 0, 1518, 1519, + 5, 78, 0, 0, 1519, 106, 1, 0, 0, 0, 1520, 1521, 5, 66, 0, 0, 1521, 1522, + 5, 79, 0, 0, 1522, 1523, 5, 84, 0, 0, 1523, 1524, 5, 72, 0, 0, 1524, 108, + 1, 0, 0, 0, 1525, 1526, 5, 66, 0, 0, 1526, 1527, 5, 82, 0, 0, 1527, 1528, + 5, 65, 0, 0, 1528, 1529, 5, 78, 0, 0, 1529, 1530, 5, 67, 0, 0, 1530, 1531, + 5, 72, 0, 0, 1531, 110, 1, 0, 0, 0, 1532, 1533, 5, 66, 0, 0, 1533, 1534, + 5, 82, 0, 0, 1534, 1535, 5, 73, 0, 0, 1535, 1536, 5, 69, 0, 0, 1536, 1537, + 5, 70, 0, 0, 1537, 112, 1, 0, 0, 0, 1538, 1539, 5, 66, 0, 0, 1539, 1540, + 5, 82, 0, 0, 1540, 1541, 5, 79, 0, 0, 1541, 1542, 5, 75, 0, 0, 1542, 1543, + 5, 69, 0, 0, 1543, 1544, 5, 82, 0, 0, 1544, 114, 1, 0, 0, 0, 1545, 1546, + 5, 66, 0, 0, 1546, 1547, 5, 85, 0, 0, 1547, 1548, 5, 67, 0, 0, 1548, 1549, + 5, 75, 0, 0, 1549, 1550, 5, 69, 0, 0, 1550, 1551, 5, 84, 0, 0, 1551, 1552, + 5, 83, 0, 0, 1552, 116, 1, 0, 0, 0, 1553, 1554, 5, 66, 0, 0, 1554, 1555, + 5, 85, 0, 0, 1555, 1556, 5, 73, 0, 0, 1556, 1557, 5, 76, 0, 0, 1557, 1558, + 5, 68, 0, 0, 1558, 118, 1, 0, 0, 0, 1559, 1560, 5, 66, 0, 0, 1560, 1561, + 5, 85, 0, 0, 1561, 1562, 5, 73, 0, 0, 1562, 1563, 5, 76, 0, 0, 1563, 1564, + 5, 84, 0, 0, 1564, 1565, 5, 73, 0, 0, 1565, 1566, 5, 78, 0, 0, 1566, 120, + 1, 0, 0, 0, 1567, 1568, 5, 66, 0, 0, 1568, 1569, 5, 85, 0, 0, 1569, 1570, + 5, 76, 0, 0, 1570, 1571, 5, 75, 0, 0, 1571, 122, 1, 0, 0, 0, 1572, 1573, + 5, 66, 0, 0, 1573, 1574, 5, 89, 0, 0, 1574, 124, 1, 0, 0, 0, 1575, 1576, + 5, 67, 0, 0, 1576, 1577, 5, 65, 0, 0, 1577, 1578, 5, 67, 0, 0, 1578, 1579, + 5, 72, 0, 0, 1579, 1580, 5, 69, 0, 0, 1580, 126, 1, 0, 0, 0, 1581, 1582, + 5, 67, 0, 0, 1582, 1583, 5, 65, 0, 0, 1583, 1584, 5, 67, 0, 0, 1584, 1585, + 5, 72, 0, 0, 1585, 1586, 5, 69, 0, 0, 1586, 1587, 5, 68, 0, 0, 1587, 128, + 1, 0, 0, 0, 1588, 1589, 5, 67, 0, 0, 1589, 1590, 5, 65, 0, 0, 1590, 1591, + 5, 76, 0, 0, 1591, 1592, 5, 76, 0, 0, 1592, 130, 1, 0, 0, 0, 1593, 1594, + 5, 67, 0, 0, 1594, 1595, 5, 65, 0, 0, 1595, 1596, 5, 78, 0, 0, 1596, 1597, + 5, 67, 0, 0, 1597, 1598, 5, 69, 0, 0, 1598, 1599, 5, 76, 0, 0, 1599, 132, + 1, 0, 0, 0, 1600, 1601, 5, 67, 0, 0, 1601, 1602, 5, 65, 0, 0, 1602, 1603, + 5, 83, 0, 0, 1603, 1604, 5, 69, 0, 0, 1604, 134, 1, 0, 0, 0, 1605, 1606, + 5, 67, 0, 0, 1606, 1607, 5, 65, 0, 0, 1607, 1608, 5, 83, 0, 0, 1608, 1609, + 5, 84, 0, 0, 1609, 136, 1, 0, 0, 0, 1610, 1611, 5, 67, 0, 0, 1611, 1612, + 5, 65, 0, 0, 1612, 1613, 5, 84, 0, 0, 1613, 1614, 5, 65, 0, 0, 1614, 1615, + 5, 76, 0, 0, 1615, 1616, 5, 79, 0, 0, 1616, 1617, 5, 71, 0, 0, 1617, 138, + 1, 0, 0, 0, 1618, 1619, 5, 67, 0, 0, 1619, 1620, 5, 65, 0, 0, 1620, 1621, + 5, 84, 0, 0, 1621, 1622, 5, 65, 0, 0, 1622, 1623, 5, 76, 0, 0, 1623, 1624, + 5, 79, 0, 0, 1624, 1625, 5, 71, 0, 0, 1625, 1626, 5, 83, 0, 0, 1626, 140, + 1, 0, 0, 0, 1627, 1628, 5, 67, 0, 0, 1628, 1629, 5, 72, 0, 0, 1629, 1630, + 5, 65, 0, 0, 1630, 1631, 5, 73, 0, 0, 1631, 1632, 5, 78, 0, 0, 1632, 142, + 1, 0, 0, 0, 1633, 1634, 5, 67, 0, 0, 1634, 1635, 5, 72, 0, 0, 1635, 1636, + 5, 65, 0, 0, 1636, 1647, 5, 82, 0, 0, 1637, 1638, 5, 67, 0, 0, 1638, 1639, + 5, 72, 0, 0, 1639, 1640, 5, 65, 0, 0, 1640, 1641, 5, 82, 0, 0, 1641, 1642, + 5, 65, 0, 0, 1642, 1643, 5, 67, 0, 0, 1643, 1644, 5, 84, 0, 0, 1644, 1645, + 5, 69, 0, 0, 1645, 1647, 5, 82, 0, 0, 1646, 1633, 1, 0, 0, 0, 1646, 1637, + 1, 0, 0, 0, 1647, 144, 1, 0, 0, 0, 1648, 1649, 5, 67, 0, 0, 1649, 1650, + 5, 72, 0, 0, 1650, 1651, 5, 65, 0, 0, 1651, 1652, 5, 82, 0, 0, 1652, 1653, + 5, 83, 0, 0, 1653, 1654, 5, 69, 0, 0, 1654, 1655, 5, 84, 0, 0, 1655, 146, + 1, 0, 0, 0, 1656, 1657, 5, 67, 0, 0, 1657, 1658, 5, 72, 0, 0, 1658, 1659, + 5, 65, 0, 0, 1659, 1660, 5, 82, 0, 0, 1660, 1661, 5, 95, 0, 0, 1661, 1662, + 5, 70, 0, 0, 1662, 1663, 5, 73, 0, 0, 1663, 1664, 5, 76, 0, 0, 1664, 1665, + 5, 84, 0, 0, 1665, 1666, 5, 69, 0, 0, 1666, 1667, 5, 82, 0, 0, 1667, 148, + 1, 0, 0, 0, 1668, 1669, 5, 67, 0, 0, 1669, 1670, 5, 72, 0, 0, 1670, 1671, + 5, 69, 0, 0, 1671, 1672, 5, 67, 0, 0, 1672, 1673, 5, 75, 0, 0, 1673, 150, + 1, 0, 0, 0, 1674, 1675, 5, 67, 0, 0, 1675, 1676, 5, 76, 0, 0, 1676, 1677, + 5, 69, 0, 0, 1677, 1678, 5, 65, 0, 0, 1678, 1679, 5, 78, 0, 0, 1679, 152, + 1, 0, 0, 0, 1680, 1681, 5, 67, 0, 0, 1681, 1682, 5, 76, 0, 0, 1682, 1683, + 5, 85, 0, 0, 1683, 1684, 5, 83, 0, 0, 1684, 1685, 5, 84, 0, 0, 1685, 1686, + 5, 69, 0, 0, 1686, 1687, 5, 82, 0, 0, 1687, 154, 1, 0, 0, 0, 1688, 1689, + 5, 67, 0, 0, 1689, 1690, 5, 76, 0, 0, 1690, 1691, 5, 85, 0, 0, 1691, 1692, + 5, 83, 0, 0, 1692, 1693, 5, 84, 0, 0, 1693, 1694, 5, 69, 0, 0, 1694, 1695, + 5, 82, 0, 0, 1695, 1696, 5, 83, 0, 0, 1696, 156, 1, 0, 0, 0, 1697, 1698, + 5, 67, 0, 0, 1698, 1699, 5, 79, 0, 0, 1699, 1700, 5, 76, 0, 0, 1700, 1701, + 5, 76, 0, 0, 1701, 1702, 5, 65, 0, 0, 1702, 1703, 5, 84, 0, 0, 1703, 1704, + 5, 69, 0, 0, 1704, 158, 1, 0, 0, 0, 1705, 1706, 5, 67, 0, 0, 1706, 1707, + 5, 79, 0, 0, 1707, 1708, 5, 76, 0, 0, 1708, 1709, 5, 76, 0, 0, 1709, 1710, + 5, 65, 0, 0, 1710, 1711, 5, 84, 0, 0, 1711, 1712, 5, 73, 0, 0, 1712, 1713, + 5, 79, 0, 0, 1713, 1714, 5, 78, 0, 0, 1714, 160, 1, 0, 0, 0, 1715, 1716, + 5, 67, 0, 0, 1716, 1717, 5, 79, 0, 0, 1717, 1718, 5, 76, 0, 0, 1718, 1719, + 5, 76, 0, 0, 1719, 1720, 5, 69, 0, 0, 1720, 1721, 5, 67, 0, 0, 1721, 1722, + 5, 84, 0, 0, 1722, 162, 1, 0, 0, 0, 1723, 1724, 5, 67, 0, 0, 1724, 1725, + 5, 79, 0, 0, 1725, 1726, 5, 76, 0, 0, 1726, 1727, 5, 79, 0, 0, 1727, 1728, + 5, 67, 0, 0, 1728, 1729, 5, 65, 0, 0, 1729, 1730, 5, 84, 0, 0, 1730, 1731, + 5, 69, 0, 0, 1731, 164, 1, 0, 0, 0, 1732, 1733, 5, 67, 0, 0, 1733, 1734, + 5, 79, 0, 0, 1734, 1735, 5, 76, 0, 0, 1735, 1736, 5, 85, 0, 0, 1736, 1737, + 5, 77, 0, 0, 1737, 1738, 5, 78, 0, 0, 1738, 166, 1, 0, 0, 0, 1739, 1740, + 5, 67, 0, 0, 1740, 1741, 5, 79, 0, 0, 1741, 1742, 5, 76, 0, 0, 1742, 1743, + 5, 85, 0, 0, 1743, 1744, 5, 77, 0, 0, 1744, 1745, 5, 78, 0, 0, 1745, 1746, + 5, 83, 0, 0, 1746, 168, 1, 0, 0, 0, 1747, 1748, 5, 67, 0, 0, 1748, 1749, + 5, 79, 0, 0, 1749, 1750, 5, 77, 0, 0, 1750, 1751, 5, 77, 0, 0, 1751, 1752, + 5, 69, 0, 0, 1752, 1753, 5, 78, 0, 0, 1753, 1754, 5, 84, 0, 0, 1754, 170, + 1, 0, 0, 0, 1755, 1756, 5, 67, 0, 0, 1756, 1757, 5, 79, 0, 0, 1757, 1758, + 5, 77, 0, 0, 1758, 1759, 5, 77, 0, 0, 1759, 1760, 5, 73, 0, 0, 1760, 1761, + 5, 84, 0, 0, 1761, 172, 1, 0, 0, 0, 1762, 1763, 5, 67, 0, 0, 1763, 1764, + 5, 79, 0, 0, 1764, 1765, 5, 77, 0, 0, 1765, 1766, 5, 77, 0, 0, 1766, 1767, + 5, 73, 0, 0, 1767, 1768, 5, 84, 0, 0, 1768, 1769, 5, 84, 0, 0, 1769, 1770, + 5, 69, 0, 0, 1770, 1771, 5, 68, 0, 0, 1771, 174, 1, 0, 0, 0, 1772, 1773, + 5, 67, 0, 0, 1773, 1774, 5, 79, 0, 0, 1774, 1775, 5, 77, 0, 0, 1775, 1776, + 5, 80, 0, 0, 1776, 1777, 5, 65, 0, 0, 1777, 1778, 5, 67, 0, 0, 1778, 1779, + 5, 84, 0, 0, 1779, 176, 1, 0, 0, 0, 1780, 1781, 5, 67, 0, 0, 1781, 1782, + 5, 79, 0, 0, 1782, 1783, 5, 77, 0, 0, 1783, 1784, 5, 80, 0, 0, 1784, 1785, + 5, 76, 0, 0, 1785, 1786, 5, 69, 0, 0, 1786, 1787, 5, 84, 0, 0, 1787, 1788, + 5, 69, 0, 0, 1788, 178, 1, 0, 0, 0, 1789, 1790, 5, 67, 0, 0, 1790, 1791, + 5, 79, 0, 0, 1791, 1792, 5, 77, 0, 0, 1792, 1793, 5, 80, 0, 0, 1793, 1794, + 5, 82, 0, 0, 1794, 1795, 5, 69, 0, 0, 1795, 1796, 5, 83, 0, 0, 1796, 1797, + 5, 83, 0, 0, 1797, 1798, 5, 95, 0, 0, 1798, 1799, 5, 84, 0, 0, 1799, 1800, + 5, 89, 0, 0, 1800, 1801, 5, 80, 0, 0, 1801, 1802, 5, 69, 0, 0, 1802, 180, + 1, 0, 0, 0, 1803, 1804, 5, 67, 0, 0, 1804, 1805, 5, 79, 0, 0, 1805, 1806, + 5, 77, 0, 0, 1806, 1807, 5, 80, 0, 0, 1807, 1808, 5, 85, 0, 0, 1808, 1809, + 5, 84, 0, 0, 1809, 1810, 5, 69, 0, 0, 1810, 182, 1, 0, 0, 0, 1811, 1812, + 5, 67, 0, 0, 1812, 1813, 5, 79, 0, 0, 1813, 1814, 5, 78, 0, 0, 1814, 1815, + 5, 68, 0, 0, 1815, 1816, 5, 73, 0, 0, 1816, 1817, 5, 84, 0, 0, 1817, 1818, + 5, 73, 0, 0, 1818, 1819, 5, 79, 0, 0, 1819, 1820, 5, 78, 0, 0, 1820, 1821, + 5, 83, 0, 0, 1821, 184, 1, 0, 0, 0, 1822, 1823, 5, 67, 0, 0, 1823, 1824, + 5, 79, 0, 0, 1824, 1825, 5, 78, 0, 0, 1825, 1826, 5, 70, 0, 0, 1826, 1827, + 5, 73, 0, 0, 1827, 1828, 5, 71, 0, 0, 1828, 186, 1, 0, 0, 0, 1829, 1830, + 5, 67, 0, 0, 1830, 1831, 5, 79, 0, 0, 1831, 1832, 5, 78, 0, 0, 1832, 1833, + 5, 78, 0, 0, 1833, 1834, 5, 69, 0, 0, 1834, 1835, 5, 67, 0, 0, 1835, 1836, + 5, 84, 0, 0, 1836, 1837, 5, 73, 0, 0, 1837, 1838, 5, 79, 0, 0, 1838, 1839, + 5, 78, 0, 0, 1839, 188, 1, 0, 0, 0, 1840, 1841, 5, 67, 0, 0, 1841, 1842, + 5, 79, 0, 0, 1842, 1843, 5, 78, 0, 0, 1843, 1844, 5, 78, 0, 0, 1844, 1845, + 5, 69, 0, 0, 1845, 1846, 5, 67, 0, 0, 1846, 1847, 5, 84, 0, 0, 1847, 1848, + 5, 73, 0, 0, 1848, 1849, 5, 79, 0, 0, 1849, 1850, 5, 78, 0, 0, 1850, 1851, + 5, 95, 0, 0, 1851, 1852, 5, 73, 0, 0, 1852, 1853, 5, 68, 0, 0, 1853, 190, + 1, 0, 0, 0, 1854, 1855, 5, 67, 0, 0, 1855, 1856, 5, 79, 0, 0, 1856, 1857, + 5, 78, 0, 0, 1857, 1858, 5, 83, 0, 0, 1858, 1859, 5, 73, 0, 0, 1859, 1860, + 5, 83, 0, 0, 1860, 1861, 5, 84, 0, 0, 1861, 1862, 5, 69, 0, 0, 1862, 1863, + 5, 78, 0, 0, 1863, 1864, 5, 84, 0, 0, 1864, 192, 1, 0, 0, 0, 1865, 1866, + 5, 67, 0, 0, 1866, 1867, 5, 79, 0, 0, 1867, 1868, 5, 78, 0, 0, 1868, 1869, + 5, 83, 0, 0, 1869, 1870, 5, 84, 0, 0, 1870, 1871, 5, 82, 0, 0, 1871, 1872, + 5, 65, 0, 0, 1872, 1873, 5, 73, 0, 0, 1873, 1874, 5, 78, 0, 0, 1874, 1875, + 5, 84, 0, 0, 1875, 194, 1, 0, 0, 0, 1876, 1877, 5, 67, 0, 0, 1877, 1878, + 5, 79, 0, 0, 1878, 1879, 5, 78, 0, 0, 1879, 1880, 5, 83, 0, 0, 1880, 1881, + 5, 84, 0, 0, 1881, 1882, 5, 82, 0, 0, 1882, 1883, 5, 65, 0, 0, 1883, 1884, + 5, 73, 0, 0, 1884, 1885, 5, 78, 0, 0, 1885, 1886, 5, 84, 0, 0, 1886, 1887, + 5, 83, 0, 0, 1887, 196, 1, 0, 0, 0, 1888, 1889, 5, 67, 0, 0, 1889, 1890, + 5, 79, 0, 0, 1890, 1891, 5, 78, 0, 0, 1891, 1892, 5, 86, 0, 0, 1892, 1893, + 5, 69, 0, 0, 1893, 1894, 5, 82, 0, 0, 1894, 1895, 5, 84, 0, 0, 1895, 198, + 1, 0, 0, 0, 1896, 1897, 5, 67, 0, 0, 1897, 1898, 5, 79, 0, 0, 1898, 1899, + 5, 78, 0, 0, 1899, 1900, 5, 86, 0, 0, 1900, 1901, 5, 69, 0, 0, 1901, 1902, + 5, 82, 0, 0, 1902, 1903, 5, 84, 0, 0, 1903, 1904, 5, 95, 0, 0, 1904, 1905, + 5, 76, 0, 0, 1905, 1906, 5, 73, 0, 0, 1906, 1907, 5, 71, 0, 0, 1907, 1908, + 5, 72, 0, 0, 1908, 1909, 5, 84, 0, 0, 1909, 1910, 5, 95, 0, 0, 1910, 1911, + 5, 83, 0, 0, 1911, 1912, 5, 67, 0, 0, 1912, 1913, 5, 72, 0, 0, 1913, 1914, + 5, 69, 0, 0, 1914, 1915, 5, 77, 0, 0, 1915, 1916, 5, 65, 0, 0, 1916, 1917, + 5, 95, 0, 0, 1917, 1918, 5, 67, 0, 0, 1918, 1919, 5, 72, 0, 0, 1919, 1920, + 5, 65, 0, 0, 1920, 1921, 5, 78, 0, 0, 1921, 1922, 5, 71, 0, 0, 1922, 1923, + 5, 69, 0, 0, 1923, 1924, 5, 95, 0, 0, 1924, 1925, 5, 80, 0, 0, 1925, 1926, + 5, 82, 0, 0, 1926, 1927, 5, 79, 0, 0, 1927, 1928, 5, 67, 0, 0, 1928, 1929, + 5, 69, 0, 0, 1929, 1930, 5, 83, 0, 0, 1930, 1931, 5, 83, 0, 0, 1931, 200, + 1, 0, 0, 0, 1932, 1933, 5, 67, 0, 0, 1933, 1934, 5, 79, 0, 0, 1934, 1935, + 5, 80, 0, 0, 1935, 1936, 5, 89, 0, 0, 1936, 202, 1, 0, 0, 0, 1937, 1938, + 5, 67, 0, 0, 1938, 1939, 5, 79, 0, 0, 1939, 1940, 5, 85, 0, 0, 1940, 1941, + 5, 78, 0, 0, 1941, 1942, 5, 84, 0, 0, 1942, 204, 1, 0, 0, 0, 1943, 1944, + 5, 67, 0, 0, 1944, 1945, 5, 82, 0, 0, 1945, 1946, 5, 69, 0, 0, 1946, 1947, + 5, 65, 0, 0, 1947, 1948, 5, 84, 0, 0, 1948, 1949, 5, 69, 0, 0, 1949, 206, + 1, 0, 0, 0, 1950, 1951, 5, 67, 0, 0, 1951, 1952, 5, 82, 0, 0, 1952, 1953, + 5, 69, 0, 0, 1953, 1954, 5, 65, 0, 0, 1954, 1955, 5, 84, 0, 0, 1955, 1956, + 5, 73, 0, 0, 1956, 1957, 5, 79, 0, 0, 1957, 1958, 5, 78, 0, 0, 1958, 208, + 1, 0, 0, 0, 1959, 1960, 5, 67, 0, 0, 1960, 1961, 5, 82, 0, 0, 1961, 1962, + 5, 79, 0, 0, 1962, 1963, 5, 78, 0, 0, 1963, 210, 1, 0, 0, 0, 1964, 1965, + 5, 67, 0, 0, 1965, 1966, 5, 82, 0, 0, 1966, 1967, 5, 79, 0, 0, 1967, 1968, + 5, 83, 0, 0, 1968, 1969, 5, 83, 0, 0, 1969, 212, 1, 0, 0, 0, 1970, 1971, + 5, 67, 0, 0, 1971, 1972, 5, 85, 0, 0, 1972, 1973, 5, 66, 0, 0, 1973, 1974, + 5, 69, 0, 0, 1974, 214, 1, 0, 0, 0, 1975, 1976, 5, 67, 0, 0, 1976, 1977, + 5, 85, 0, 0, 1977, 1978, 5, 82, 0, 0, 1978, 1979, 5, 82, 0, 0, 1979, 1980, + 5, 69, 0, 0, 1980, 1981, 5, 78, 0, 0, 1981, 1982, 5, 84, 0, 0, 1982, 216, + 1, 0, 0, 0, 1983, 1984, 5, 67, 0, 0, 1984, 1985, 5, 85, 0, 0, 1985, 1986, + 5, 82, 0, 0, 1986, 1987, 5, 82, 0, 0, 1987, 1988, 5, 69, 0, 0, 1988, 1989, + 5, 78, 0, 0, 1989, 1990, 5, 84, 0, 0, 1990, 1991, 5, 95, 0, 0, 1991, 1992, + 5, 67, 0, 0, 1992, 1993, 5, 65, 0, 0, 1993, 1994, 5, 84, 0, 0, 1994, 1995, + 5, 65, 0, 0, 1995, 1996, 5, 76, 0, 0, 1996, 1997, 5, 79, 0, 0, 1997, 1998, + 5, 71, 0, 0, 1998, 218, 1, 0, 0, 0, 1999, 2000, 5, 67, 0, 0, 2000, 2001, + 5, 85, 0, 0, 2001, 2002, 5, 82, 0, 0, 2002, 2003, 5, 82, 0, 0, 2003, 2004, + 5, 69, 0, 0, 2004, 2005, 5, 78, 0, 0, 2005, 2006, 5, 84, 0, 0, 2006, 2007, + 5, 95, 0, 0, 2007, 2008, 5, 68, 0, 0, 2008, 2009, 5, 65, 0, 0, 2009, 2010, + 5, 84, 0, 0, 2010, 2011, 5, 69, 0, 0, 2011, 220, 1, 0, 0, 0, 2012, 2013, + 5, 67, 0, 0, 2013, 2014, 5, 85, 0, 0, 2014, 2015, 5, 82, 0, 0, 2015, 2016, + 5, 82, 0, 0, 2016, 2017, 5, 69, 0, 0, 2017, 2018, 5, 78, 0, 0, 2018, 2019, + 5, 84, 0, 0, 2019, 2020, 5, 95, 0, 0, 2020, 2021, 5, 84, 0, 0, 2021, 2022, + 5, 73, 0, 0, 2022, 2023, 5, 77, 0, 0, 2023, 2024, 5, 69, 0, 0, 2024, 222, + 1, 0, 0, 0, 2025, 2026, 5, 67, 0, 0, 2026, 2027, 5, 85, 0, 0, 2027, 2028, + 5, 82, 0, 0, 2028, 2029, 5, 82, 0, 0, 2029, 2030, 5, 69, 0, 0, 2030, 2031, + 5, 78, 0, 0, 2031, 2032, 5, 84, 0, 0, 2032, 2033, 5, 95, 0, 0, 2033, 2034, + 5, 84, 0, 0, 2034, 2035, 5, 73, 0, 0, 2035, 2036, 5, 77, 0, 0, 2036, 2037, + 5, 69, 0, 0, 2037, 2038, 5, 83, 0, 0, 2038, 2039, 5, 84, 0, 0, 2039, 2040, + 5, 65, 0, 0, 2040, 2041, 5, 77, 0, 0, 2041, 2042, 5, 80, 0, 0, 2042, 224, + 1, 0, 0, 0, 2043, 2044, 5, 67, 0, 0, 2044, 2045, 5, 85, 0, 0, 2045, 2046, + 5, 82, 0, 0, 2046, 2047, 5, 82, 0, 0, 2047, 2048, 5, 69, 0, 0, 2048, 2049, + 5, 78, 0, 0, 2049, 2050, 5, 84, 0, 0, 2050, 2051, 5, 95, 0, 0, 2051, 2052, + 5, 85, 0, 0, 2052, 2053, 5, 83, 0, 0, 2053, 2054, 5, 69, 0, 0, 2054, 2055, + 5, 82, 0, 0, 2055, 226, 1, 0, 0, 0, 2056, 2057, 5, 68, 0, 0, 2057, 2058, + 5, 65, 0, 0, 2058, 2059, 5, 84, 0, 0, 2059, 2060, 5, 65, 0, 0, 2060, 228, + 1, 0, 0, 0, 2061, 2062, 5, 68, 0, 0, 2062, 2063, 5, 65, 0, 0, 2063, 2064, + 5, 84, 0, 0, 2064, 2065, 5, 65, 0, 0, 2065, 2066, 5, 66, 0, 0, 2066, 2067, + 5, 65, 0, 0, 2067, 2068, 5, 83, 0, 0, 2068, 2069, 5, 69, 0, 0, 2069, 230, + 1, 0, 0, 0, 2070, 2071, 5, 68, 0, 0, 2071, 2072, 5, 65, 0, 0, 2072, 2073, + 5, 84, 0, 0, 2073, 2074, 5, 65, 0, 0, 2074, 2075, 5, 66, 0, 0, 2075, 2076, + 5, 65, 0, 0, 2076, 2077, 5, 83, 0, 0, 2077, 2078, 5, 69, 0, 0, 2078, 2079, + 5, 83, 0, 0, 2079, 232, 1, 0, 0, 0, 2080, 2081, 5, 68, 0, 0, 2081, 2082, + 5, 65, 0, 0, 2082, 2083, 5, 84, 0, 0, 2083, 2084, 5, 69, 0, 0, 2084, 234, + 1, 0, 0, 0, 2085, 2086, 5, 68, 0, 0, 2086, 2087, 5, 65, 0, 0, 2087, 2088, + 5, 84, 0, 0, 2088, 2089, 5, 69, 0, 0, 2089, 2090, 5, 84, 0, 0, 2090, 2091, + 5, 73, 0, 0, 2091, 2092, 5, 77, 0, 0, 2092, 2093, 5, 69, 0, 0, 2093, 236, + 1, 0, 0, 0, 2094, 2095, 5, 68, 0, 0, 2095, 2096, 5, 65, 0, 0, 2096, 2097, + 5, 84, 0, 0, 2097, 2098, 5, 69, 0, 0, 2098, 2099, 5, 84, 0, 0, 2099, 2100, + 5, 73, 0, 0, 2100, 2101, 5, 77, 0, 0, 2101, 2102, 5, 69, 0, 0, 2102, 2103, + 5, 86, 0, 0, 2103, 2104, 5, 50, 0, 0, 2104, 238, 1, 0, 0, 0, 2105, 2106, + 5, 68, 0, 0, 2106, 2107, 5, 65, 0, 0, 2107, 2108, 5, 84, 0, 0, 2108, 2109, + 5, 69, 0, 0, 2109, 2110, 5, 86, 0, 0, 2110, 2111, 5, 50, 0, 0, 2111, 240, + 1, 0, 0, 0, 2112, 2113, 5, 68, 0, 0, 2113, 2114, 5, 65, 0, 0, 2114, 2115, + 5, 84, 0, 0, 2115, 2116, 5, 69, 0, 0, 2116, 2117, 5, 84, 0, 0, 2117, 2118, + 5, 73, 0, 0, 2118, 2119, 5, 77, 0, 0, 2119, 2120, 5, 69, 0, 0, 2120, 2121, + 5, 86, 0, 0, 2121, 2122, 5, 49, 0, 0, 2122, 242, 1, 0, 0, 0, 2123, 2124, + 5, 68, 0, 0, 2124, 2125, 5, 65, 0, 0, 2125, 2126, 5, 84, 0, 0, 2126, 2127, + 5, 69, 0, 0, 2127, 2128, 5, 86, 0, 0, 2128, 2129, 5, 49, 0, 0, 2129, 244, + 1, 0, 0, 0, 2130, 2131, 5, 68, 0, 0, 2131, 2132, 5, 65, 0, 0, 2132, 2133, + 5, 89, 0, 0, 2133, 246, 1, 0, 0, 0, 2134, 2135, 5, 68, 0, 0, 2135, 2136, + 5, 65, 0, 0, 2136, 2137, 5, 89, 0, 0, 2137, 2138, 5, 95, 0, 0, 2138, 2139, + 5, 83, 0, 0, 2139, 2140, 5, 69, 0, 0, 2140, 2141, 5, 67, 0, 0, 2141, 2142, + 5, 79, 0, 0, 2142, 2143, 5, 78, 0, 0, 2143, 2144, 5, 68, 0, 0, 2144, 248, + 1, 0, 0, 0, 2145, 2146, 5, 68, 0, 0, 2146, 2147, 5, 65, 0, 0, 2147, 2148, + 5, 89, 0, 0, 2148, 2149, 5, 83, 0, 0, 2149, 250, 1, 0, 0, 0, 2150, 2151, + 5, 68, 0, 0, 2151, 2152, 5, 65, 0, 0, 2152, 2153, 5, 89, 0, 0, 2153, 2154, + 5, 95, 0, 0, 2154, 2155, 5, 72, 0, 0, 2155, 2156, 5, 79, 0, 0, 2156, 2157, + 5, 85, 0, 0, 2157, 2158, 5, 82, 0, 0, 2158, 252, 1, 0, 0, 0, 2159, 2160, + 5, 68, 0, 0, 2160, 2161, 5, 69, 0, 0, 2161, 2162, 5, 67, 0, 0, 2162, 2163, + 5, 73, 0, 0, 2163, 2164, 5, 77, 0, 0, 2164, 2165, 5, 65, 0, 0, 2165, 2166, + 5, 76, 0, 0, 2166, 254, 1, 0, 0, 0, 2167, 2168, 5, 68, 0, 0, 2168, 2169, + 5, 69, 0, 0, 2169, 2170, 5, 67, 0, 0, 2170, 2171, 5, 73, 0, 0, 2171, 2172, + 5, 77, 0, 0, 2172, 2173, 5, 65, 0, 0, 2173, 2174, 5, 76, 0, 0, 2174, 2175, + 5, 86, 0, 0, 2175, 2176, 5, 50, 0, 0, 2176, 256, 1, 0, 0, 0, 2177, 2178, + 5, 68, 0, 0, 2178, 2179, 5, 69, 0, 0, 2179, 2180, 5, 67, 0, 0, 2180, 2181, + 5, 73, 0, 0, 2181, 2182, 5, 77, 0, 0, 2182, 2183, 5, 65, 0, 0, 2183, 2184, + 5, 76, 0, 0, 2184, 2185, 5, 86, 0, 0, 2185, 2186, 5, 51, 0, 0, 2186, 258, + 1, 0, 0, 0, 2187, 2188, 5, 68, 0, 0, 2188, 2189, 5, 69, 0, 0, 2189, 2190, + 5, 67, 0, 0, 2190, 2191, 5, 79, 0, 0, 2191, 2192, 5, 77, 0, 0, 2192, 2193, + 5, 77, 0, 0, 2193, 2194, 5, 73, 0, 0, 2194, 2195, 5, 83, 0, 0, 2195, 2196, + 5, 83, 0, 0, 2196, 2197, 5, 73, 0, 0, 2197, 2198, 5, 79, 0, 0, 2198, 2199, + 5, 78, 0, 0, 2199, 260, 1, 0, 0, 0, 2200, 2201, 5, 68, 0, 0, 2201, 2202, + 5, 69, 0, 0, 2202, 2203, 5, 70, 0, 0, 2203, 2204, 5, 65, 0, 0, 2204, 2205, + 5, 85, 0, 0, 2205, 2206, 5, 76, 0, 0, 2206, 2207, 5, 84, 0, 0, 2207, 262, + 1, 0, 0, 0, 2208, 2209, 5, 68, 0, 0, 2209, 2210, 5, 69, 0, 0, 2210, 2211, + 5, 70, 0, 0, 2211, 2212, 5, 69, 0, 0, 2212, 2213, 5, 82, 0, 0, 2213, 2214, + 5, 82, 0, 0, 2214, 2215, 5, 69, 0, 0, 2215, 2216, 5, 68, 0, 0, 2216, 264, + 1, 0, 0, 0, 2217, 2218, 5, 68, 0, 0, 2218, 2219, 5, 69, 0, 0, 2219, 2220, + 5, 76, 0, 0, 2220, 2221, 5, 69, 0, 0, 2221, 2222, 5, 84, 0, 0, 2222, 2223, + 5, 69, 0, 0, 2223, 266, 1, 0, 0, 0, 2224, 2225, 5, 68, 0, 0, 2225, 2226, + 5, 69, 0, 0, 2226, 2227, 5, 77, 0, 0, 2227, 2228, 5, 65, 0, 0, 2228, 2229, + 5, 78, 0, 0, 2229, 2230, 5, 68, 0, 0, 2230, 268, 1, 0, 0, 0, 2231, 2232, + 5, 68, 0, 0, 2232, 2233, 5, 69, 0, 0, 2233, 2234, 5, 83, 0, 0, 2234, 2235, + 5, 67, 0, 0, 2235, 270, 1, 0, 0, 0, 2236, 2237, 5, 68, 0, 0, 2237, 2238, + 5, 69, 0, 0, 2238, 2239, 5, 83, 0, 0, 2239, 2240, 5, 67, 0, 0, 2240, 2241, + 5, 82, 0, 0, 2241, 2242, 5, 73, 0, 0, 2242, 2243, 5, 66, 0, 0, 2243, 2244, + 5, 69, 0, 0, 2244, 272, 1, 0, 0, 0, 2245, 2246, 5, 68, 0, 0, 2246, 2247, + 5, 73, 0, 0, 2247, 2248, 5, 65, 0, 0, 2248, 2249, 5, 71, 0, 0, 2249, 2250, + 5, 78, 0, 0, 2250, 2251, 5, 79, 0, 0, 2251, 2252, 5, 83, 0, 0, 2252, 2253, + 5, 69, 0, 0, 2253, 274, 1, 0, 0, 0, 2254, 2255, 5, 68, 0, 0, 2255, 2256, + 5, 73, 0, 0, 2256, 2257, 5, 65, 0, 0, 2257, 2258, 5, 71, 0, 0, 2258, 2259, + 5, 78, 0, 0, 2259, 2260, 5, 79, 0, 0, 2260, 2261, 5, 83, 0, 0, 2261, 2262, + 5, 73, 0, 0, 2262, 2263, 5, 83, 0, 0, 2263, 276, 1, 0, 0, 0, 2264, 2265, + 5, 68, 0, 0, 2265, 2266, 5, 73, 0, 0, 2266, 2267, 5, 67, 0, 0, 2267, 2268, + 5, 84, 0, 0, 2268, 2269, 5, 73, 0, 0, 2269, 2270, 5, 79, 0, 0, 2270, 2271, + 5, 78, 0, 0, 2271, 2272, 5, 65, 0, 0, 2272, 2273, 5, 82, 0, 0, 2273, 2274, + 5, 73, 0, 0, 2274, 2275, 5, 69, 0, 0, 2275, 2276, 5, 83, 0, 0, 2276, 278, + 1, 0, 0, 0, 2277, 2278, 5, 68, 0, 0, 2278, 2279, 5, 73, 0, 0, 2279, 2280, + 5, 67, 0, 0, 2280, 2281, 5, 84, 0, 0, 2281, 2282, 5, 73, 0, 0, 2282, 2283, + 5, 79, 0, 0, 2283, 2284, 5, 78, 0, 0, 2284, 2285, 5, 65, 0, 0, 2285, 2286, + 5, 82, 0, 0, 2286, 2287, 5, 89, 0, 0, 2287, 280, 1, 0, 0, 0, 2288, 2289, + 5, 68, 0, 0, 2289, 2290, 5, 73, 0, 0, 2290, 2291, 5, 83, 0, 0, 2291, 2292, + 5, 75, 0, 0, 2292, 282, 1, 0, 0, 0, 2293, 2294, 5, 68, 0, 0, 2294, 2295, + 5, 73, 0, 0, 2295, 2296, 5, 83, 0, 0, 2296, 2297, 5, 84, 0, 0, 2297, 2298, + 5, 73, 0, 0, 2298, 2299, 5, 78, 0, 0, 2299, 2300, 5, 67, 0, 0, 2300, 2301, + 5, 84, 0, 0, 2301, 284, 1, 0, 0, 0, 2302, 2303, 5, 68, 0, 0, 2303, 2304, + 5, 73, 0, 0, 2304, 2305, 5, 83, 0, 0, 2305, 2306, 5, 84, 0, 0, 2306, 2307, + 5, 73, 0, 0, 2307, 2308, 5, 78, 0, 0, 2308, 2309, 5, 67, 0, 0, 2309, 2310, + 5, 84, 0, 0, 2310, 2311, 5, 80, 0, 0, 2311, 2312, 5, 67, 0, 0, 2312, 286, + 1, 0, 0, 0, 2313, 2314, 5, 68, 0, 0, 2314, 2315, 5, 73, 0, 0, 2315, 2316, + 5, 83, 0, 0, 2316, 2317, 5, 84, 0, 0, 2317, 2318, 5, 73, 0, 0, 2318, 2319, + 5, 78, 0, 0, 2319, 2320, 5, 67, 0, 0, 2320, 2321, 5, 84, 0, 0, 2321, 2322, + 5, 80, 0, 0, 2322, 2323, 5, 67, 0, 0, 2323, 2324, 5, 83, 0, 0, 2324, 2325, + 5, 65, 0, 0, 2325, 288, 1, 0, 0, 0, 2326, 2327, 5, 68, 0, 0, 2327, 2328, + 5, 73, 0, 0, 2328, 2329, 5, 83, 0, 0, 2329, 2330, 5, 84, 0, 0, 2330, 2331, + 5, 82, 0, 0, 2331, 2332, 5, 73, 0, 0, 2332, 2333, 5, 66, 0, 0, 2333, 2334, + 5, 85, 0, 0, 2334, 2335, 5, 84, 0, 0, 2335, 2336, 5, 69, 0, 0, 2336, 2337, + 5, 68, 0, 0, 2337, 290, 1, 0, 0, 0, 2338, 2339, 5, 68, 0, 0, 2339, 2340, + 5, 73, 0, 0, 2340, 2341, 5, 83, 0, 0, 2341, 2342, 5, 84, 0, 0, 2342, 2343, + 5, 82, 0, 0, 2343, 2344, 5, 73, 0, 0, 2344, 2345, 5, 66, 0, 0, 2345, 2346, + 5, 85, 0, 0, 2346, 2347, 5, 84, 0, 0, 2347, 2348, 5, 73, 0, 0, 2348, 2349, + 5, 79, 0, 0, 2349, 2350, 5, 78, 0, 0, 2350, 292, 1, 0, 0, 0, 2351, 2352, + 5, 68, 0, 0, 2352, 2353, 5, 73, 0, 0, 2353, 2354, 5, 86, 0, 0, 2354, 294, + 1, 0, 0, 0, 2355, 2356, 5, 68, 0, 0, 2356, 2357, 5, 79, 0, 0, 2357, 296, + 1, 0, 0, 0, 2358, 2359, 5, 68, 0, 0, 2359, 2360, 5, 79, 0, 0, 2360, 2361, + 5, 82, 0, 0, 2361, 2362, 5, 73, 0, 0, 2362, 2363, 5, 83, 0, 0, 2363, 2364, + 5, 95, 0, 0, 2364, 2365, 5, 73, 0, 0, 2365, 2366, 5, 78, 0, 0, 2366, 2367, + 5, 84, 0, 0, 2367, 2368, 5, 69, 0, 0, 2368, 2369, 5, 82, 0, 0, 2369, 2370, + 5, 78, 0, 0, 2370, 2371, 5, 65, 0, 0, 2371, 2372, 5, 76, 0, 0, 2372, 2373, + 5, 95, 0, 0, 2373, 2374, 5, 84, 0, 0, 2374, 2375, 5, 65, 0, 0, 2375, 2376, + 5, 66, 0, 0, 2376, 2377, 5, 76, 0, 0, 2377, 2378, 5, 69, 0, 0, 2378, 2379, + 5, 95, 0, 0, 2379, 2380, 5, 73, 0, 0, 2380, 2381, 5, 68, 0, 0, 2381, 298, + 1, 0, 0, 0, 2382, 2383, 5, 68, 0, 0, 2383, 2384, 5, 79, 0, 0, 2384, 2385, + 5, 85, 0, 0, 2385, 2386, 5, 66, 0, 0, 2386, 2387, 5, 76, 0, 0, 2387, 2388, + 5, 69, 0, 0, 2388, 300, 1, 0, 0, 0, 2389, 2390, 5, 68, 0, 0, 2390, 2391, + 5, 82, 0, 0, 2391, 2392, 5, 79, 0, 0, 2392, 2393, 5, 80, 0, 0, 2393, 302, + 1, 0, 0, 0, 2394, 2395, 5, 68, 0, 0, 2395, 2396, 5, 82, 0, 0, 2396, 2397, + 5, 79, 0, 0, 2397, 2398, 5, 80, 0, 0, 2398, 2399, 5, 80, 0, 0, 2399, 304, + 1, 0, 0, 0, 2400, 2401, 5, 68, 0, 0, 2401, 2402, 5, 85, 0, 0, 2402, 2403, + 5, 65, 0, 0, 2403, 2404, 5, 76, 0, 0, 2404, 306, 1, 0, 0, 0, 2405, 2406, + 5, 68, 0, 0, 2406, 2407, 5, 85, 0, 0, 2407, 2408, 5, 77, 0, 0, 2408, 2409, + 5, 80, 0, 0, 2409, 308, 1, 0, 0, 0, 2410, 2411, 5, 68, 0, 0, 2411, 2412, + 5, 85, 0, 0, 2412, 2413, 5, 80, 0, 0, 2413, 2414, 5, 76, 0, 0, 2414, 2415, + 5, 73, 0, 0, 2415, 2416, 5, 67, 0, 0, 2416, 2417, 5, 65, 0, 0, 2417, 2418, + 5, 84, 0, 0, 2418, 2419, 5, 69, 0, 0, 2419, 310, 1, 0, 0, 0, 2420, 2421, + 5, 68, 0, 0, 2421, 2422, 5, 89, 0, 0, 2422, 2423, 5, 78, 0, 0, 2423, 2424, + 5, 65, 0, 0, 2424, 2425, 5, 77, 0, 0, 2425, 2426, 5, 73, 0, 0, 2426, 2427, + 5, 67, 0, 0, 2427, 312, 1, 0, 0, 0, 2428, 2429, 5, 69, 0, 0, 2429, 314, + 1, 0, 0, 0, 2430, 2431, 5, 69, 0, 0, 2431, 2432, 5, 76, 0, 0, 2432, 2433, + 5, 83, 0, 0, 2433, 2434, 5, 69, 0, 0, 2434, 316, 1, 0, 0, 0, 2435, 2436, + 5, 69, 0, 0, 2436, 2437, 5, 78, 0, 0, 2437, 2438, 5, 65, 0, 0, 2438, 2439, + 5, 66, 0, 0, 2439, 2440, 5, 76, 0, 0, 2440, 2441, 5, 69, 0, 0, 2441, 318, + 1, 0, 0, 0, 2442, 2443, 5, 69, 0, 0, 2443, 2444, 5, 78, 0, 0, 2444, 2445, + 5, 67, 0, 0, 2445, 2446, 5, 82, 0, 0, 2446, 2447, 5, 89, 0, 0, 2447, 2448, + 5, 80, 0, 0, 2448, 2449, 5, 84, 0, 0, 2449, 2450, 5, 73, 0, 0, 2450, 2451, + 5, 79, 0, 0, 2451, 2452, 5, 78, 0, 0, 2452, 320, 1, 0, 0, 0, 2453, 2454, + 5, 69, 0, 0, 2454, 2455, 5, 78, 0, 0, 2455, 2456, 5, 67, 0, 0, 2456, 2457, + 5, 82, 0, 0, 2457, 2458, 5, 89, 0, 0, 2458, 2459, 5, 80, 0, 0, 2459, 2460, + 5, 84, 0, 0, 2460, 2461, 5, 75, 0, 0, 2461, 2462, 5, 69, 0, 0, 2462, 2463, + 5, 89, 0, 0, 2463, 322, 1, 0, 0, 0, 2464, 2465, 5, 69, 0, 0, 2465, 2466, + 5, 78, 0, 0, 2466, 2467, 5, 67, 0, 0, 2467, 2468, 5, 82, 0, 0, 2468, 2469, + 5, 89, 0, 0, 2469, 2470, 5, 80, 0, 0, 2470, 2471, 5, 84, 0, 0, 2471, 2472, + 5, 75, 0, 0, 2472, 2473, 5, 69, 0, 0, 2473, 2474, 5, 89, 0, 0, 2474, 2475, + 5, 83, 0, 0, 2475, 324, 1, 0, 0, 0, 2476, 2477, 5, 69, 0, 0, 2477, 2478, + 5, 78, 0, 0, 2478, 2479, 5, 68, 0, 0, 2479, 326, 1, 0, 0, 0, 2480, 2481, + 5, 69, 0, 0, 2481, 2482, 5, 78, 0, 0, 2482, 2483, 5, 68, 0, 0, 2483, 2484, + 5, 83, 0, 0, 2484, 328, 1, 0, 0, 0, 2485, 2486, 5, 69, 0, 0, 2486, 2487, + 5, 78, 0, 0, 2487, 2488, 5, 71, 0, 0, 2488, 2489, 5, 73, 0, 0, 2489, 2490, + 5, 78, 0, 0, 2490, 2491, 5, 69, 0, 0, 2491, 330, 1, 0, 0, 0, 2492, 2493, + 5, 69, 0, 0, 2493, 2494, 5, 78, 0, 0, 2494, 2495, 5, 71, 0, 0, 2495, 2496, + 5, 73, 0, 0, 2496, 2497, 5, 78, 0, 0, 2497, 2498, 5, 69, 0, 0, 2498, 2499, + 5, 83, 0, 0, 2499, 332, 1, 0, 0, 0, 2500, 2501, 5, 69, 0, 0, 2501, 2502, + 5, 78, 0, 0, 2502, 2503, 5, 84, 0, 0, 2503, 2504, 5, 69, 0, 0, 2504, 2505, + 5, 82, 0, 0, 2505, 334, 1, 0, 0, 0, 2506, 2507, 5, 69, 0, 0, 2507, 2508, + 5, 82, 0, 0, 2508, 2509, 5, 82, 0, 0, 2509, 2510, 5, 79, 0, 0, 2510, 2511, + 5, 82, 0, 0, 2511, 2512, 5, 83, 0, 0, 2512, 336, 1, 0, 0, 0, 2513, 2514, + 5, 69, 0, 0, 2514, 2515, 5, 83, 0, 0, 2515, 2516, 5, 67, 0, 0, 2516, 2517, + 5, 65, 0, 0, 2517, 2518, 5, 80, 0, 0, 2518, 2519, 5, 69, 0, 0, 2519, 338, + 1, 0, 0, 0, 2520, 2521, 5, 69, 0, 0, 2521, 2522, 5, 86, 0, 0, 2522, 2523, + 5, 69, 0, 0, 2523, 2524, 5, 78, 0, 0, 2524, 2525, 5, 84, 0, 0, 2525, 2526, + 5, 83, 0, 0, 2526, 340, 1, 0, 0, 0, 2527, 2528, 5, 69, 0, 0, 2528, 2529, + 5, 86, 0, 0, 2529, 2530, 5, 69, 0, 0, 2530, 2531, 5, 82, 0, 0, 2531, 2532, + 5, 89, 0, 0, 2532, 342, 1, 0, 0, 0, 2533, 2534, 5, 69, 0, 0, 2534, 2535, + 5, 88, 0, 0, 2535, 2536, 5, 67, 0, 0, 2536, 2537, 5, 69, 0, 0, 2537, 2538, + 5, 80, 0, 0, 2538, 2539, 5, 84, 0, 0, 2539, 344, 1, 0, 0, 0, 2540, 2541, + 5, 69, 0, 0, 2541, 2542, 5, 88, 0, 0, 2542, 2543, 5, 67, 0, 0, 2543, 2544, + 5, 76, 0, 0, 2544, 2545, 5, 85, 0, 0, 2545, 2546, 5, 68, 0, 0, 2546, 2547, + 5, 69, 0, 0, 2547, 346, 1, 0, 0, 0, 2548, 2549, 5, 69, 0, 0, 2549, 2550, + 5, 88, 0, 0, 2550, 2551, 5, 69, 0, 0, 2551, 2552, 5, 67, 0, 0, 2552, 2553, + 5, 85, 0, 0, 2553, 2554, 5, 84, 0, 0, 2554, 2555, 5, 69, 0, 0, 2555, 348, + 1, 0, 0, 0, 2556, 2557, 5, 69, 0, 0, 2557, 2558, 5, 88, 0, 0, 2558, 2559, + 5, 73, 0, 0, 2559, 2560, 5, 83, 0, 0, 2560, 2561, 5, 84, 0, 0, 2561, 2562, + 5, 83, 0, 0, 2562, 350, 1, 0, 0, 0, 2563, 2564, 5, 69, 0, 0, 2564, 2565, + 5, 88, 0, 0, 2565, 2566, 5, 80, 0, 0, 2566, 2567, 5, 73, 0, 0, 2567, 2568, + 5, 82, 0, 0, 2568, 2569, 5, 69, 0, 0, 2569, 2570, 5, 68, 0, 0, 2570, 352, + 1, 0, 0, 0, 2571, 2572, 5, 69, 0, 0, 2572, 2573, 5, 88, 0, 0, 2573, 2574, + 5, 80, 0, 0, 2574, 2575, 5, 76, 0, 0, 2575, 2576, 5, 65, 0, 0, 2576, 2577, + 5, 73, 0, 0, 2577, 2578, 5, 78, 0, 0, 2578, 354, 1, 0, 0, 0, 2579, 2580, + 5, 69, 0, 0, 2580, 2581, 5, 88, 0, 0, 2581, 2582, 5, 80, 0, 0, 2582, 2583, + 5, 79, 0, 0, 2583, 2584, 5, 82, 0, 0, 2584, 2585, 5, 84, 0, 0, 2585, 356, + 1, 0, 0, 0, 2586, 2587, 5, 69, 0, 0, 2587, 2588, 5, 88, 0, 0, 2588, 2589, + 5, 84, 0, 0, 2589, 2590, 5, 69, 0, 0, 2590, 2591, 5, 78, 0, 0, 2591, 2592, + 5, 68, 0, 0, 2592, 2593, 5, 69, 0, 0, 2593, 2594, 5, 68, 0, 0, 2594, 358, + 1, 0, 0, 0, 2595, 2596, 5, 69, 0, 0, 2596, 2597, 5, 88, 0, 0, 2597, 2598, + 5, 84, 0, 0, 2598, 2599, 5, 69, 0, 0, 2599, 2600, 5, 82, 0, 0, 2600, 2601, + 5, 78, 0, 0, 2601, 2602, 5, 65, 0, 0, 2602, 2603, 5, 76, 0, 0, 2603, 360, + 1, 0, 0, 0, 2604, 2605, 5, 69, 0, 0, 2605, 2606, 5, 88, 0, 0, 2606, 2607, + 5, 84, 0, 0, 2607, 2608, 5, 82, 0, 0, 2608, 2609, 5, 65, 0, 0, 2609, 2610, + 5, 67, 0, 0, 2610, 2611, 5, 84, 0, 0, 2611, 362, 1, 0, 0, 0, 2612, 2613, + 5, 70, 0, 0, 2613, 2614, 5, 65, 0, 0, 2614, 2615, 5, 73, 0, 0, 2615, 2616, + 5, 76, 0, 0, 2616, 2617, 5, 69, 0, 0, 2617, 2618, 5, 68, 0, 0, 2618, 2619, + 5, 95, 0, 0, 2619, 2620, 5, 76, 0, 0, 2620, 2621, 5, 79, 0, 0, 2621, 2622, + 5, 71, 0, 0, 2622, 2623, 5, 73, 0, 0, 2623, 2624, 5, 78, 0, 0, 2624, 2625, + 5, 95, 0, 0, 2625, 2626, 5, 65, 0, 0, 2626, 2627, 5, 84, 0, 0, 2627, 2628, + 5, 84, 0, 0, 2628, 2629, 5, 69, 0, 0, 2629, 2630, 5, 77, 0, 0, 2630, 2631, + 5, 80, 0, 0, 2631, 2632, 5, 84, 0, 0, 2632, 2633, 5, 83, 0, 0, 2633, 364, + 1, 0, 0, 0, 2634, 2635, 5, 70, 0, 0, 2635, 2636, 5, 65, 0, 0, 2636, 2637, + 5, 76, 0, 0, 2637, 2638, 5, 83, 0, 0, 2638, 2639, 5, 69, 0, 0, 2639, 366, + 1, 0, 0, 0, 2640, 2641, 5, 70, 0, 0, 2641, 2642, 5, 65, 0, 0, 2642, 2643, + 5, 83, 0, 0, 2643, 2644, 5, 84, 0, 0, 2644, 368, 1, 0, 0, 0, 2645, 2646, + 5, 70, 0, 0, 2646, 2647, 5, 69, 0, 0, 2647, 2648, 5, 65, 0, 0, 2648, 2649, + 5, 84, 0, 0, 2649, 2650, 5, 85, 0, 0, 2650, 2651, 5, 82, 0, 0, 2651, 2652, + 5, 69, 0, 0, 2652, 370, 1, 0, 0, 0, 2653, 2654, 5, 70, 0, 0, 2654, 2655, + 5, 73, 0, 0, 2655, 2656, 5, 69, 0, 0, 2656, 2657, 5, 76, 0, 0, 2657, 2658, + 5, 68, 0, 0, 2658, 2659, 5, 83, 0, 0, 2659, 372, 1, 0, 0, 0, 2660, 2661, + 5, 70, 0, 0, 2661, 2662, 5, 73, 0, 0, 2662, 2663, 5, 76, 0, 0, 2663, 2664, + 5, 69, 0, 0, 2664, 374, 1, 0, 0, 0, 2665, 2666, 5, 70, 0, 0, 2666, 2667, + 5, 73, 0, 0, 2667, 2668, 5, 76, 0, 0, 2668, 2669, 5, 84, 0, 0, 2669, 2670, + 5, 69, 0, 0, 2670, 2671, 5, 82, 0, 0, 2671, 376, 1, 0, 0, 0, 2672, 2673, + 5, 70, 0, 0, 2673, 2674, 5, 73, 0, 0, 2674, 2675, 5, 82, 0, 0, 2675, 2676, + 5, 83, 0, 0, 2676, 2677, 5, 84, 0, 0, 2677, 378, 1, 0, 0, 0, 2678, 2679, + 5, 70, 0, 0, 2679, 2680, 5, 76, 0, 0, 2680, 2681, 5, 79, 0, 0, 2681, 2682, + 5, 65, 0, 0, 2682, 2683, 5, 84, 0, 0, 2683, 380, 1, 0, 0, 0, 2684, 2685, + 5, 70, 0, 0, 2685, 2686, 5, 79, 0, 0, 2686, 2687, 5, 76, 0, 0, 2687, 2688, + 5, 76, 0, 0, 2688, 2689, 5, 79, 0, 0, 2689, 2690, 5, 87, 0, 0, 2690, 2691, + 5, 69, 0, 0, 2691, 2692, 5, 82, 0, 0, 2692, 382, 1, 0, 0, 0, 2693, 2694, + 5, 70, 0, 0, 2694, 2695, 5, 79, 0, 0, 2695, 2696, 5, 76, 0, 0, 2696, 2697, + 5, 76, 0, 0, 2697, 2698, 5, 79, 0, 0, 2698, 2699, 5, 87, 0, 0, 2699, 2700, + 5, 73, 0, 0, 2700, 2701, 5, 78, 0, 0, 2701, 2702, 5, 71, 0, 0, 2702, 384, + 1, 0, 0, 0, 2703, 2704, 5, 70, 0, 0, 2704, 2705, 5, 79, 0, 0, 2705, 2706, + 5, 82, 0, 0, 2706, 386, 1, 0, 0, 0, 2707, 2708, 5, 70, 0, 0, 2708, 2709, + 5, 79, 0, 0, 2709, 2710, 5, 82, 0, 0, 2710, 2711, 5, 69, 0, 0, 2711, 2712, + 5, 73, 0, 0, 2712, 2713, 5, 71, 0, 0, 2713, 2714, 5, 78, 0, 0, 2714, 388, + 1, 0, 0, 0, 2715, 2716, 5, 70, 0, 0, 2716, 2717, 5, 79, 0, 0, 2717, 2718, + 5, 82, 0, 0, 2718, 2719, 5, 67, 0, 0, 2719, 2720, 5, 69, 0, 0, 2720, 390, + 1, 0, 0, 0, 2721, 2722, 5, 70, 0, 0, 2722, 2723, 5, 79, 0, 0, 2723, 2724, + 5, 82, 0, 0, 2724, 2725, 5, 77, 0, 0, 2725, 2726, 5, 65, 0, 0, 2726, 2727, + 5, 84, 0, 0, 2727, 392, 1, 0, 0, 0, 2728, 2729, 5, 70, 0, 0, 2729, 2730, + 5, 82, 0, 0, 2730, 2731, 5, 69, 0, 0, 2731, 2732, 5, 69, 0, 0, 2732, 394, + 1, 0, 0, 0, 2733, 2734, 5, 70, 0, 0, 2734, 2735, 5, 82, 0, 0, 2735, 2736, + 5, 79, 0, 0, 2736, 2737, 5, 77, 0, 0, 2737, 396, 1, 0, 0, 0, 2738, 2739, + 5, 70, 0, 0, 2739, 2740, 5, 82, 0, 0, 2740, 2741, 5, 79, 0, 0, 2741, 2742, + 5, 78, 0, 0, 2742, 2743, 5, 84, 0, 0, 2743, 2744, 5, 69, 0, 0, 2744, 2745, + 5, 78, 0, 0, 2745, 2746, 5, 68, 0, 0, 2746, 398, 1, 0, 0, 0, 2747, 2748, + 5, 70, 0, 0, 2748, 2749, 5, 82, 0, 0, 2749, 2750, 5, 79, 0, 0, 2750, 2751, + 5, 78, 0, 0, 2751, 2752, 5, 84, 0, 0, 2752, 2753, 5, 69, 0, 0, 2753, 2754, + 5, 78, 0, 0, 2754, 2755, 5, 68, 0, 0, 2755, 2756, 5, 83, 0, 0, 2756, 400, + 1, 0, 0, 0, 2757, 2758, 5, 70, 0, 0, 2758, 2759, 5, 85, 0, 0, 2759, 2760, + 5, 76, 0, 0, 2760, 2761, 5, 76, 0, 0, 2761, 402, 1, 0, 0, 0, 2762, 2763, + 5, 70, 0, 0, 2763, 2764, 5, 85, 0, 0, 2764, 2765, 5, 78, 0, 0, 2765, 2766, + 5, 67, 0, 0, 2766, 2767, 5, 84, 0, 0, 2767, 2768, 5, 73, 0, 0, 2768, 2769, + 5, 79, 0, 0, 2769, 2770, 5, 78, 0, 0, 2770, 404, 1, 0, 0, 0, 2771, 2772, + 5, 70, 0, 0, 2772, 2773, 5, 85, 0, 0, 2773, 2774, 5, 78, 0, 0, 2774, 2775, + 5, 67, 0, 0, 2775, 2776, 5, 84, 0, 0, 2776, 2777, 5, 73, 0, 0, 2777, 2778, + 5, 79, 0, 0, 2778, 2779, 5, 78, 0, 0, 2779, 2780, 5, 83, 0, 0, 2780, 406, + 1, 0, 0, 0, 2781, 2782, 5, 71, 0, 0, 2782, 2783, 5, 69, 0, 0, 2783, 2784, + 5, 78, 0, 0, 2784, 2785, 5, 69, 0, 0, 2785, 2786, 5, 82, 0, 0, 2786, 2787, + 5, 65, 0, 0, 2787, 2788, 5, 84, 0, 0, 2788, 2789, 5, 69, 0, 0, 2789, 2790, + 5, 68, 0, 0, 2790, 408, 1, 0, 0, 0, 2791, 2792, 5, 71, 0, 0, 2792, 2793, + 5, 69, 0, 0, 2793, 2794, 5, 78, 0, 0, 2794, 2795, 5, 69, 0, 0, 2795, 2796, + 5, 82, 0, 0, 2796, 2797, 5, 73, 0, 0, 2797, 2798, 5, 67, 0, 0, 2798, 410, + 1, 0, 0, 0, 2799, 2800, 5, 71, 0, 0, 2800, 2801, 5, 76, 0, 0, 2801, 2802, + 5, 79, 0, 0, 2802, 2803, 5, 66, 0, 0, 2803, 2804, 5, 65, 0, 0, 2804, 2805, + 5, 76, 0, 0, 2805, 412, 1, 0, 0, 0, 2806, 2807, 5, 71, 0, 0, 2807, 2808, + 5, 82, 0, 0, 2808, 2809, 5, 65, 0, 0, 2809, 2810, 5, 78, 0, 0, 2810, 2811, + 5, 84, 0, 0, 2811, 414, 1, 0, 0, 0, 2812, 2813, 5, 71, 0, 0, 2813, 2814, + 5, 82, 0, 0, 2814, 2815, 5, 65, 0, 0, 2815, 2816, 5, 78, 0, 0, 2816, 2817, + 5, 84, 0, 0, 2817, 2818, 5, 83, 0, 0, 2818, 416, 1, 0, 0, 0, 2819, 2820, + 5, 71, 0, 0, 2820, 2821, 5, 82, 0, 0, 2821, 2822, 5, 65, 0, 0, 2822, 2823, + 5, 80, 0, 0, 2823, 2824, 5, 72, 0, 0, 2824, 418, 1, 0, 0, 0, 2825, 2826, + 5, 71, 0, 0, 2826, 2827, 5, 82, 0, 0, 2827, 2828, 5, 79, 0, 0, 2828, 2829, + 5, 85, 0, 0, 2829, 2830, 5, 80, 0, 0, 2830, 420, 1, 0, 0, 0, 2831, 2832, + 5, 71, 0, 0, 2832, 2833, 5, 82, 0, 0, 2833, 2834, 5, 79, 0, 0, 2834, 2835, + 5, 85, 0, 0, 2835, 2836, 5, 80, 0, 0, 2836, 2837, 5, 73, 0, 0, 2837, 2838, + 5, 78, 0, 0, 2838, 2839, 5, 71, 0, 0, 2839, 422, 1, 0, 0, 0, 2840, 2841, + 5, 71, 0, 0, 2841, 2842, 5, 82, 0, 0, 2842, 2843, 5, 79, 0, 0, 2843, 2844, + 5, 85, 0, 0, 2844, 2845, 5, 80, 0, 0, 2845, 2846, 5, 83, 0, 0, 2846, 424, + 1, 0, 0, 0, 2847, 2848, 5, 71, 0, 0, 2848, 2849, 5, 82, 0, 0, 2849, 2850, + 5, 79, 0, 0, 2850, 2851, 5, 85, 0, 0, 2851, 2852, 5, 80, 0, 0, 2852, 2853, + 5, 95, 0, 0, 2853, 2854, 5, 67, 0, 0, 2854, 2855, 5, 79, 0, 0, 2855, 2856, + 5, 78, 0, 0, 2856, 2857, 5, 67, 0, 0, 2857, 2858, 5, 65, 0, 0, 2858, 2859, + 5, 84, 0, 0, 2859, 426, 1, 0, 0, 0, 2860, 2861, 5, 72, 0, 0, 2861, 2862, + 5, 65, 0, 0, 2862, 2863, 5, 83, 0, 0, 2863, 2864, 5, 72, 0, 0, 2864, 428, + 1, 0, 0, 0, 2865, 2866, 5, 72, 0, 0, 2866, 2867, 5, 65, 0, 0, 2867, 2868, + 5, 83, 0, 0, 2868, 2869, 5, 72, 0, 0, 2869, 2870, 5, 95, 0, 0, 2870, 2871, + 5, 77, 0, 0, 2871, 2872, 5, 65, 0, 0, 2872, 2873, 5, 80, 0, 0, 2873, 430, + 1, 0, 0, 0, 2874, 2875, 5, 72, 0, 0, 2875, 2876, 5, 65, 0, 0, 2876, 2877, + 5, 86, 0, 0, 2877, 2878, 5, 73, 0, 0, 2878, 2879, 5, 78, 0, 0, 2879, 2880, + 5, 71, 0, 0, 2880, 432, 1, 0, 0, 0, 2881, 2882, 5, 72, 0, 0, 2882, 2883, + 5, 68, 0, 0, 2883, 2884, 5, 70, 0, 0, 2884, 2885, 5, 83, 0, 0, 2885, 434, + 1, 0, 0, 0, 2886, 2887, 5, 72, 0, 0, 2887, 2888, 5, 69, 0, 0, 2888, 2889, + 5, 76, 0, 0, 2889, 2890, 5, 80, 0, 0, 2890, 436, 1, 0, 0, 0, 2891, 2892, + 5, 72, 0, 0, 2892, 2893, 5, 73, 0, 0, 2893, 2894, 5, 83, 0, 0, 2894, 2895, + 5, 84, 0, 0, 2895, 2896, 5, 79, 0, 0, 2896, 2897, 5, 71, 0, 0, 2897, 2898, + 5, 82, 0, 0, 2898, 2899, 5, 65, 0, 0, 2899, 2900, 5, 77, 0, 0, 2900, 438, + 1, 0, 0, 0, 2901, 2902, 5, 72, 0, 0, 2902, 2903, 5, 76, 0, 0, 2903, 2904, + 5, 76, 0, 0, 2904, 440, 1, 0, 0, 0, 2905, 2906, 5, 72, 0, 0, 2906, 2907, + 5, 76, 0, 0, 2907, 2908, 5, 76, 0, 0, 2908, 2909, 5, 95, 0, 0, 2909, 2910, + 5, 85, 0, 0, 2910, 2911, 5, 78, 0, 0, 2911, 2912, 5, 73, 0, 0, 2912, 2913, + 5, 79, 0, 0, 2913, 2914, 5, 78, 0, 0, 2914, 442, 1, 0, 0, 0, 2915, 2916, + 5, 72, 0, 0, 2916, 2917, 5, 79, 0, 0, 2917, 2918, 5, 83, 0, 0, 2918, 2919, + 5, 84, 0, 0, 2919, 2920, 5, 78, 0, 0, 2920, 2921, 5, 65, 0, 0, 2921, 2922, + 5, 77, 0, 0, 2922, 2923, 5, 69, 0, 0, 2923, 444, 1, 0, 0, 0, 2924, 2925, + 5, 72, 0, 0, 2925, 2926, 5, 79, 0, 0, 2926, 2927, 5, 84, 0, 0, 2927, 2928, + 5, 83, 0, 0, 2928, 2929, 5, 80, 0, 0, 2929, 2930, 5, 79, 0, 0, 2930, 2931, + 5, 84, 0, 0, 2931, 446, 1, 0, 0, 0, 2932, 2933, 5, 72, 0, 0, 2933, 2934, + 5, 79, 0, 0, 2934, 2935, 5, 85, 0, 0, 2935, 2936, 5, 82, 0, 0, 2936, 448, + 1, 0, 0, 0, 2937, 2938, 5, 72, 0, 0, 2938, 2939, 5, 79, 0, 0, 2939, 2940, + 5, 85, 0, 0, 2940, 2941, 5, 82, 0, 0, 2941, 2942, 5, 83, 0, 0, 2942, 450, + 1, 0, 0, 0, 2943, 2944, 5, 72, 0, 0, 2944, 2945, 5, 85, 0, 0, 2945, 2946, + 5, 66, 0, 0, 2946, 452, 1, 0, 0, 0, 2947, 2948, 5, 73, 0, 0, 2948, 2949, + 5, 68, 0, 0, 2949, 2950, 5, 69, 0, 0, 2950, 2951, 5, 78, 0, 0, 2951, 2952, + 5, 84, 0, 0, 2952, 2953, 5, 73, 0, 0, 2953, 2954, 5, 70, 0, 0, 2954, 2955, + 5, 73, 0, 0, 2955, 2956, 5, 69, 0, 0, 2956, 2957, 5, 68, 0, 0, 2957, 454, + 1, 0, 0, 0, 2958, 2959, 5, 73, 0, 0, 2959, 2960, 5, 70, 0, 0, 2960, 456, + 1, 0, 0, 0, 2961, 2962, 5, 73, 0, 0, 2962, 2963, 5, 71, 0, 0, 2963, 2964, + 5, 78, 0, 0, 2964, 2965, 5, 79, 0, 0, 2965, 2966, 5, 82, 0, 0, 2966, 2967, + 5, 69, 0, 0, 2967, 458, 1, 0, 0, 0, 2968, 2969, 5, 73, 0, 0, 2969, 2970, + 5, 77, 0, 0, 2970, 2971, 5, 77, 0, 0, 2971, 2972, 5, 69, 0, 0, 2972, 2973, + 5, 68, 0, 0, 2973, 2974, 5, 73, 0, 0, 2974, 2975, 5, 65, 0, 0, 2975, 2976, + 5, 84, 0, 0, 2976, 2977, 5, 69, 0, 0, 2977, 460, 1, 0, 0, 0, 2978, 2979, + 5, 73, 0, 0, 2979, 2980, 5, 78, 0, 0, 2980, 462, 1, 0, 0, 0, 2981, 2982, + 5, 73, 0, 0, 2982, 2983, 5, 78, 0, 0, 2983, 2984, 5, 67, 0, 0, 2984, 2985, + 5, 82, 0, 0, 2985, 2986, 5, 69, 0, 0, 2986, 2987, 5, 77, 0, 0, 2987, 2988, + 5, 69, 0, 0, 2988, 2989, 5, 78, 0, 0, 2989, 2990, 5, 84, 0, 0, 2990, 2991, + 5, 65, 0, 0, 2991, 2992, 5, 76, 0, 0, 2992, 464, 1, 0, 0, 0, 2993, 2994, + 5, 73, 0, 0, 2994, 2995, 5, 78, 0, 0, 2995, 2996, 5, 68, 0, 0, 2996, 2997, + 5, 69, 0, 0, 2997, 2998, 5, 88, 0, 0, 2998, 466, 1, 0, 0, 0, 2999, 3000, + 5, 73, 0, 0, 3000, 3001, 5, 78, 0, 0, 3001, 3002, 5, 68, 0, 0, 3002, 3003, + 5, 69, 0, 0, 3003, 3004, 5, 88, 0, 0, 3004, 3005, 5, 69, 0, 0, 3005, 3006, + 5, 83, 0, 0, 3006, 468, 1, 0, 0, 0, 3007, 3008, 5, 73, 0, 0, 3008, 3009, + 5, 78, 0, 0, 3009, 3010, 5, 70, 0, 0, 3010, 3011, 5, 73, 0, 0, 3011, 3012, + 5, 76, 0, 0, 3012, 3013, 5, 69, 0, 0, 3013, 470, 1, 0, 0, 0, 3014, 3015, + 5, 73, 0, 0, 3015, 3016, 5, 78, 0, 0, 3016, 3017, 5, 78, 0, 0, 3017, 3018, + 5, 69, 0, 0, 3018, 3019, 5, 82, 0, 0, 3019, 472, 1, 0, 0, 0, 3020, 3021, + 5, 73, 0, 0, 3021, 3022, 5, 78, 0, 0, 3022, 3023, 5, 83, 0, 0, 3023, 3024, + 5, 69, 0, 0, 3024, 3025, 5, 82, 0, 0, 3025, 3026, 5, 84, 0, 0, 3026, 474, + 1, 0, 0, 0, 3027, 3028, 5, 73, 0, 0, 3028, 3029, 5, 78, 0, 0, 3029, 3030, + 5, 83, 0, 0, 3030, 3031, 5, 84, 0, 0, 3031, 3032, 5, 65, 0, 0, 3032, 3033, + 5, 76, 0, 0, 3033, 3034, 5, 76, 0, 0, 3034, 476, 1, 0, 0, 0, 3035, 3036, + 5, 73, 0, 0, 3036, 3037, 5, 78, 0, 0, 3037, 3038, 5, 84, 0, 0, 3038, 478, + 1, 0, 0, 0, 3039, 3040, 5, 73, 0, 0, 3040, 3041, 5, 78, 0, 0, 3041, 3042, + 5, 84, 0, 0, 3042, 3043, 5, 69, 0, 0, 3043, 3044, 5, 71, 0, 0, 3044, 3045, + 5, 69, 0, 0, 3045, 3046, 5, 82, 0, 0, 3046, 480, 1, 0, 0, 0, 3047, 3048, + 5, 73, 0, 0, 3048, 3049, 5, 78, 0, 0, 3049, 3050, 5, 84, 0, 0, 3050, 3051, + 5, 69, 0, 0, 3051, 3052, 5, 82, 0, 0, 3052, 3053, 5, 77, 0, 0, 3053, 3054, + 5, 69, 0, 0, 3054, 3055, 5, 68, 0, 0, 3055, 3056, 5, 73, 0, 0, 3056, 3057, + 5, 65, 0, 0, 3057, 3058, 5, 84, 0, 0, 3058, 3059, 5, 69, 0, 0, 3059, 482, + 1, 0, 0, 0, 3060, 3061, 5, 73, 0, 0, 3061, 3062, 5, 78, 0, 0, 3062, 3063, + 5, 84, 0, 0, 3063, 3064, 5, 69, 0, 0, 3064, 3065, 5, 82, 0, 0, 3065, 3066, + 5, 83, 0, 0, 3066, 3067, 5, 69, 0, 0, 3067, 3068, 5, 67, 0, 0, 3068, 3069, + 5, 84, 0, 0, 3069, 484, 1, 0, 0, 0, 3070, 3071, 5, 73, 0, 0, 3071, 3072, + 5, 78, 0, 0, 3072, 3073, 5, 84, 0, 0, 3073, 3074, 5, 69, 0, 0, 3074, 3075, + 5, 82, 0, 0, 3075, 3076, 5, 86, 0, 0, 3076, 3077, 5, 65, 0, 0, 3077, 3078, + 5, 76, 0, 0, 3078, 486, 1, 0, 0, 0, 3079, 3080, 5, 73, 0, 0, 3080, 3081, + 5, 78, 0, 0, 3081, 3082, 5, 84, 0, 0, 3082, 3083, 5, 79, 0, 0, 3083, 488, + 1, 0, 0, 0, 3084, 3085, 5, 73, 0, 0, 3085, 3086, 5, 78, 0, 0, 3086, 3087, + 5, 86, 0, 0, 3087, 3088, 5, 69, 0, 0, 3088, 3089, 5, 82, 0, 0, 3089, 3090, + 5, 84, 0, 0, 3090, 3091, 5, 69, 0, 0, 3091, 3092, 5, 68, 0, 0, 3092, 490, + 1, 0, 0, 0, 3093, 3094, 5, 73, 0, 0, 3094, 3095, 5, 80, 0, 0, 3095, 3096, + 5, 95, 0, 0, 3096, 3097, 5, 84, 0, 0, 3097, 3098, 5, 82, 0, 0, 3098, 3099, + 5, 73, 0, 0, 3099, 3100, 5, 69, 0, 0, 3100, 492, 1, 0, 0, 0, 3101, 3102, + 5, 73, 0, 0, 3102, 3103, 5, 80, 0, 0, 3103, 3104, 5, 86, 0, 0, 3104, 3105, + 5, 52, 0, 0, 3105, 494, 1, 0, 0, 0, 3106, 3107, 5, 73, 0, 0, 3107, 3108, + 5, 80, 0, 0, 3108, 3109, 5, 86, 0, 0, 3109, 3110, 5, 54, 0, 0, 3110, 496, + 1, 0, 0, 0, 3111, 3112, 5, 73, 0, 0, 3112, 3113, 5, 83, 0, 0, 3113, 498, + 1, 0, 0, 0, 3114, 3115, 5, 73, 0, 0, 3115, 3116, 5, 83, 0, 0, 3116, 3117, + 5, 95, 0, 0, 3117, 3118, 5, 78, 0, 0, 3118, 3119, 5, 79, 0, 0, 3119, 3120, + 5, 84, 0, 0, 3120, 3121, 5, 95, 0, 0, 3121, 3122, 5, 78, 0, 0, 3122, 3123, + 5, 85, 0, 0, 3123, 3124, 5, 76, 0, 0, 3124, 3125, 5, 76, 0, 0, 3125, 3126, + 5, 95, 0, 0, 3126, 3127, 5, 80, 0, 0, 3127, 3128, 5, 82, 0, 0, 3128, 3129, + 5, 69, 0, 0, 3129, 3130, 5, 68, 0, 0, 3130, 500, 1, 0, 0, 0, 3131, 3132, + 5, 73, 0, 0, 3132, 3133, 5, 83, 0, 0, 3133, 3134, 5, 95, 0, 0, 3134, 3135, + 5, 78, 0, 0, 3135, 3136, 5, 85, 0, 0, 3136, 3137, 5, 76, 0, 0, 3137, 3138, + 5, 76, 0, 0, 3138, 3139, 5, 95, 0, 0, 3139, 3140, 5, 80, 0, 0, 3140, 3141, + 5, 82, 0, 0, 3141, 3142, 5, 69, 0, 0, 3142, 3143, 5, 68, 0, 0, 3143, 502, + 1, 0, 0, 0, 3144, 3145, 5, 73, 0, 0, 3145, 3146, 5, 83, 0, 0, 3146, 3147, + 5, 78, 0, 0, 3147, 3148, 5, 85, 0, 0, 3148, 3149, 5, 76, 0, 0, 3149, 3150, + 5, 76, 0, 0, 3150, 504, 1, 0, 0, 0, 3151, 3152, 5, 73, 0, 0, 3152, 3153, + 5, 83, 0, 0, 3153, 3154, 5, 79, 0, 0, 3154, 3155, 5, 76, 0, 0, 3155, 3156, + 5, 65, 0, 0, 3156, 3157, 5, 84, 0, 0, 3157, 3158, 5, 73, 0, 0, 3158, 3159, + 5, 79, 0, 0, 3159, 3160, 5, 78, 0, 0, 3160, 506, 1, 0, 0, 0, 3161, 3162, + 5, 74, 0, 0, 3162, 3163, 5, 79, 0, 0, 3163, 3164, 5, 66, 0, 0, 3164, 508, + 1, 0, 0, 0, 3165, 3166, 5, 74, 0, 0, 3166, 3167, 5, 79, 0, 0, 3167, 3168, + 5, 66, 0, 0, 3168, 3169, 5, 83, 0, 0, 3169, 510, 1, 0, 0, 0, 3170, 3171, + 5, 74, 0, 0, 3171, 3172, 5, 79, 0, 0, 3172, 3173, 5, 73, 0, 0, 3173, 3174, + 5, 78, 0, 0, 3174, 512, 1, 0, 0, 0, 3175, 3176, 5, 74, 0, 0, 3176, 3177, + 5, 83, 0, 0, 3177, 3178, 5, 79, 0, 0, 3178, 3179, 5, 78, 0, 0, 3179, 514, + 1, 0, 0, 0, 3180, 3181, 5, 74, 0, 0, 3181, 3182, 5, 83, 0, 0, 3182, 3183, + 5, 79, 0, 0, 3183, 3184, 5, 78, 0, 0, 3184, 3185, 5, 66, 0, 0, 3185, 516, + 1, 0, 0, 0, 3186, 3187, 5, 75, 0, 0, 3187, 3188, 5, 69, 0, 0, 3188, 3189, + 5, 89, 0, 0, 3189, 518, 1, 0, 0, 0, 3190, 3191, 5, 75, 0, 0, 3191, 3192, + 5, 69, 0, 0, 3192, 3193, 5, 89, 0, 0, 3193, 3194, 5, 83, 0, 0, 3194, 520, + 1, 0, 0, 0, 3195, 3196, 5, 75, 0, 0, 3196, 3197, 5, 73, 0, 0, 3197, 3198, + 5, 76, 0, 0, 3198, 3199, 5, 76, 0, 0, 3199, 522, 1, 0, 0, 0, 3200, 3201, + 5, 76, 0, 0, 3201, 3202, 5, 65, 0, 0, 3202, 3203, 5, 66, 0, 0, 3203, 3204, + 5, 69, 0, 0, 3204, 3205, 5, 76, 0, 0, 3205, 524, 1, 0, 0, 0, 3206, 3207, + 5, 76, 0, 0, 3207, 3208, 5, 65, 0, 0, 3208, 3209, 5, 82, 0, 0, 3209, 3210, + 5, 71, 0, 0, 3210, 3211, 5, 69, 0, 0, 3211, 3212, 5, 73, 0, 0, 3212, 3213, + 5, 78, 0, 0, 3213, 3214, 5, 84, 0, 0, 3214, 526, 1, 0, 0, 0, 3215, 3216, + 5, 76, 0, 0, 3216, 3217, 5, 65, 0, 0, 3217, 3218, 5, 89, 0, 0, 3218, 3219, + 5, 79, 0, 0, 3219, 3220, 5, 85, 0, 0, 3220, 3221, 5, 84, 0, 0, 3221, 528, + 1, 0, 0, 0, 3222, 3223, 5, 76, 0, 0, 3223, 3224, 5, 65, 0, 0, 3224, 3225, + 5, 83, 0, 0, 3225, 3226, 5, 84, 0, 0, 3226, 530, 1, 0, 0, 0, 3227, 3228, + 5, 76, 0, 0, 3228, 3229, 5, 65, 0, 0, 3229, 3230, 5, 84, 0, 0, 3230, 3231, + 5, 69, 0, 0, 3231, 3232, 5, 82, 0, 0, 3232, 3233, 5, 65, 0, 0, 3233, 3234, + 5, 76, 0, 0, 3234, 532, 1, 0, 0, 0, 3235, 3236, 5, 76, 0, 0, 3236, 3237, + 5, 68, 0, 0, 3237, 3238, 5, 65, 0, 0, 3238, 3239, 5, 80, 0, 0, 3239, 534, + 1, 0, 0, 0, 3240, 3241, 5, 76, 0, 0, 3241, 3242, 5, 68, 0, 0, 3242, 3243, + 5, 65, 0, 0, 3243, 3244, 5, 80, 0, 0, 3244, 3245, 5, 95, 0, 0, 3245, 3246, + 5, 65, 0, 0, 3246, 3247, 5, 68, 0, 0, 3247, 3248, 5, 77, 0, 0, 3248, 3249, + 5, 73, 0, 0, 3249, 3250, 5, 78, 0, 0, 3250, 3251, 5, 95, 0, 0, 3251, 3252, + 5, 80, 0, 0, 3252, 3253, 5, 65, 0, 0, 3253, 3254, 5, 83, 0, 0, 3254, 3255, + 5, 83, 0, 0, 3255, 3256, 5, 87, 0, 0, 3256, 3257, 5, 79, 0, 0, 3257, 3258, + 5, 82, 0, 0, 3258, 3259, 5, 68, 0, 0, 3259, 536, 1, 0, 0, 0, 3260, 3261, + 5, 76, 0, 0, 3261, 3262, 5, 69, 0, 0, 3262, 3263, 5, 65, 0, 0, 3263, 3264, + 5, 68, 0, 0, 3264, 3265, 5, 73, 0, 0, 3265, 3266, 5, 78, 0, 0, 3266, 3267, + 5, 71, 0, 0, 3267, 538, 1, 0, 0, 0, 3268, 3269, 5, 76, 0, 0, 3269, 3270, + 5, 69, 0, 0, 3270, 3271, 5, 70, 0, 0, 3271, 3272, 5, 84, 0, 0, 3272, 540, + 1, 0, 0, 0, 3273, 3274, 5, 76, 0, 0, 3274, 3275, 5, 69, 0, 0, 3275, 3276, + 5, 83, 0, 0, 3276, 3277, 5, 83, 0, 0, 3277, 542, 1, 0, 0, 0, 3278, 3279, + 5, 76, 0, 0, 3279, 3280, 5, 69, 0, 0, 3280, 3281, 5, 86, 0, 0, 3281, 3282, + 5, 69, 0, 0, 3282, 3283, 5, 76, 0, 0, 3283, 544, 1, 0, 0, 0, 3284, 3285, + 5, 76, 0, 0, 3285, 3286, 5, 73, 0, 0, 3286, 3287, 5, 75, 0, 0, 3287, 3288, + 5, 69, 0, 0, 3288, 546, 1, 0, 0, 0, 3289, 3290, 5, 76, 0, 0, 3290, 3291, + 5, 73, 0, 0, 3291, 3292, 5, 77, 0, 0, 3292, 3293, 5, 73, 0, 0, 3293, 3294, + 5, 84, 0, 0, 3294, 548, 1, 0, 0, 0, 3295, 3296, 5, 76, 0, 0, 3296, 3297, + 5, 73, 0, 0, 3297, 3298, 5, 78, 0, 0, 3298, 3299, 5, 69, 0, 0, 3299, 3300, + 5, 83, 0, 0, 3300, 550, 1, 0, 0, 0, 3301, 3302, 5, 76, 0, 0, 3302, 3303, + 5, 73, 0, 0, 3303, 3304, 5, 78, 0, 0, 3304, 3305, 5, 75, 0, 0, 3305, 552, + 1, 0, 0, 0, 3306, 3307, 5, 76, 0, 0, 3307, 3308, 5, 73, 0, 0, 3308, 3309, + 5, 83, 0, 0, 3309, 3310, 5, 84, 0, 0, 3310, 554, 1, 0, 0, 0, 3311, 3312, + 5, 76, 0, 0, 3312, 3313, 5, 79, 0, 0, 3313, 3314, 5, 65, 0, 0, 3314, 3315, + 5, 68, 0, 0, 3315, 556, 1, 0, 0, 0, 3316, 3317, 5, 76, 0, 0, 3317, 3318, + 5, 79, 0, 0, 3318, 3319, 5, 67, 0, 0, 3319, 3320, 5, 65, 0, 0, 3320, 3321, + 5, 76, 0, 0, 3321, 558, 1, 0, 0, 0, 3322, 3323, 5, 76, 0, 0, 3323, 3324, + 5, 79, 0, 0, 3324, 3325, 5, 67, 0, 0, 3325, 3326, 5, 65, 0, 0, 3326, 3327, + 5, 76, 0, 0, 3327, 3328, 5, 84, 0, 0, 3328, 3329, 5, 73, 0, 0, 3329, 3330, + 5, 77, 0, 0, 3330, 3331, 5, 69, 0, 0, 3331, 560, 1, 0, 0, 0, 3332, 3333, + 5, 76, 0, 0, 3333, 3334, 5, 79, 0, 0, 3334, 3335, 5, 67, 0, 0, 3335, 3336, + 5, 65, 0, 0, 3336, 3337, 5, 76, 0, 0, 3337, 3338, 5, 84, 0, 0, 3338, 3339, + 5, 73, 0, 0, 3339, 3340, 5, 77, 0, 0, 3340, 3341, 5, 69, 0, 0, 3341, 3342, + 5, 83, 0, 0, 3342, 3343, 5, 84, 0, 0, 3343, 3344, 5, 65, 0, 0, 3344, 3345, + 5, 77, 0, 0, 3345, 3346, 5, 80, 0, 0, 3346, 562, 1, 0, 0, 0, 3347, 3348, + 5, 76, 0, 0, 3348, 3349, 5, 79, 0, 0, 3349, 3350, 5, 67, 0, 0, 3350, 3351, + 5, 65, 0, 0, 3351, 3352, 5, 84, 0, 0, 3352, 3353, 5, 73, 0, 0, 3353, 3354, + 5, 79, 0, 0, 3354, 3355, 5, 78, 0, 0, 3355, 564, 1, 0, 0, 0, 3356, 3357, + 5, 76, 0, 0, 3357, 3358, 5, 79, 0, 0, 3358, 3359, 5, 67, 0, 0, 3359, 3360, + 5, 75, 0, 0, 3360, 566, 1, 0, 0, 0, 3361, 3362, 5, 76, 0, 0, 3362, 3363, + 5, 79, 0, 0, 3363, 3364, 5, 71, 0, 0, 3364, 3365, 5, 73, 0, 0, 3365, 3366, + 5, 67, 0, 0, 3366, 3367, 5, 65, 0, 0, 3367, 3368, 5, 76, 0, 0, 3368, 568, + 1, 0, 0, 0, 3369, 3370, 5, 76, 0, 0, 3370, 3371, 5, 79, 0, 0, 3371, 3372, + 5, 87, 0, 0, 3372, 3373, 5, 95, 0, 0, 3373, 3374, 5, 80, 0, 0, 3374, 3375, + 5, 82, 0, 0, 3375, 3376, 5, 73, 0, 0, 3376, 3377, 5, 79, 0, 0, 3377, 3378, + 5, 82, 0, 0, 3378, 3379, 5, 73, 0, 0, 3379, 3380, 5, 84, 0, 0, 3380, 3381, + 5, 89, 0, 0, 3381, 570, 1, 0, 0, 0, 3382, 3383, 5, 77, 0, 0, 3383, 3384, + 5, 65, 0, 0, 3384, 3385, 5, 78, 0, 0, 3385, 3386, 5, 85, 0, 0, 3386, 3387, + 5, 65, 0, 0, 3387, 3388, 5, 76, 0, 0, 3388, 572, 1, 0, 0, 0, 3389, 3390, + 5, 77, 0, 0, 3390, 3391, 5, 65, 0, 0, 3391, 3392, 5, 80, 0, 0, 3392, 574, + 1, 0, 0, 0, 3393, 3394, 5, 77, 0, 0, 3394, 3395, 5, 65, 0, 0, 3395, 3396, + 5, 84, 0, 0, 3396, 3397, 5, 67, 0, 0, 3397, 3398, 5, 72, 0, 0, 3398, 576, + 1, 0, 0, 0, 3399, 3400, 5, 77, 0, 0, 3400, 3401, 5, 65, 0, 0, 3401, 3402, + 5, 84, 0, 0, 3402, 3403, 5, 67, 0, 0, 3403, 3404, 5, 72, 0, 0, 3404, 3405, + 5, 69, 0, 0, 3405, 3406, 5, 68, 0, 0, 3406, 578, 1, 0, 0, 0, 3407, 3408, + 5, 77, 0, 0, 3408, 3409, 5, 65, 0, 0, 3409, 3410, 5, 84, 0, 0, 3410, 3411, + 5, 67, 0, 0, 3411, 3412, 5, 72, 0, 0, 3412, 3413, 5, 95, 0, 0, 3413, 3414, + 5, 65, 0, 0, 3414, 3415, 5, 76, 0, 0, 3415, 3416, 5, 76, 0, 0, 3416, 580, + 1, 0, 0, 0, 3417, 3418, 5, 77, 0, 0, 3418, 3419, 5, 65, 0, 0, 3419, 3420, + 5, 84, 0, 0, 3420, 3421, 5, 67, 0, 0, 3421, 3422, 5, 72, 0, 0, 3422, 3423, + 5, 95, 0, 0, 3423, 3424, 5, 65, 0, 0, 3424, 3425, 5, 78, 0, 0, 3425, 3426, + 5, 89, 0, 0, 3426, 582, 1, 0, 0, 0, 3427, 3428, 5, 77, 0, 0, 3428, 3429, + 5, 65, 0, 0, 3429, 3430, 5, 84, 0, 0, 3430, 3431, 5, 67, 0, 0, 3431, 3432, + 5, 72, 0, 0, 3432, 3433, 5, 95, 0, 0, 3433, 3434, 5, 78, 0, 0, 3434, 3435, + 5, 65, 0, 0, 3435, 3436, 5, 77, 0, 0, 3436, 3437, 5, 69, 0, 0, 3437, 584, + 1, 0, 0, 0, 3438, 3439, 5, 77, 0, 0, 3439, 3440, 5, 65, 0, 0, 3440, 3441, + 5, 84, 0, 0, 3441, 3442, 5, 67, 0, 0, 3442, 3443, 5, 72, 0, 0, 3443, 3444, + 5, 95, 0, 0, 3444, 3445, 5, 78, 0, 0, 3445, 3446, 5, 65, 0, 0, 3446, 3447, + 5, 77, 0, 0, 3447, 3448, 5, 69, 0, 0, 3448, 3449, 5, 95, 0, 0, 3449, 3450, + 5, 71, 0, 0, 3450, 3451, 5, 76, 0, 0, 3451, 3452, 5, 79, 0, 0, 3452, 3453, + 5, 66, 0, 0, 3453, 586, 1, 0, 0, 0, 3454, 3455, 5, 77, 0, 0, 3455, 3456, + 5, 65, 0, 0, 3456, 3457, 5, 84, 0, 0, 3457, 3458, 5, 67, 0, 0, 3458, 3459, + 5, 72, 0, 0, 3459, 3460, 5, 95, 0, 0, 3460, 3461, 5, 80, 0, 0, 3461, 3462, + 5, 72, 0, 0, 3462, 3463, 5, 82, 0, 0, 3463, 3464, 5, 65, 0, 0, 3464, 3465, + 5, 83, 0, 0, 3465, 3466, 5, 69, 0, 0, 3466, 588, 1, 0, 0, 0, 3467, 3468, + 5, 77, 0, 0, 3468, 3469, 5, 65, 0, 0, 3469, 3470, 5, 84, 0, 0, 3470, 3471, + 5, 67, 0, 0, 3471, 3472, 5, 72, 0, 0, 3472, 3473, 5, 95, 0, 0, 3473, 3474, + 5, 80, 0, 0, 3474, 3475, 5, 72, 0, 0, 3475, 3476, 5, 82, 0, 0, 3476, 3477, + 5, 65, 0, 0, 3477, 3478, 5, 83, 0, 0, 3478, 3479, 5, 69, 0, 0, 3479, 3480, + 5, 95, 0, 0, 3480, 3481, 5, 69, 0, 0, 3481, 3482, 5, 68, 0, 0, 3482, 3483, + 5, 71, 0, 0, 3483, 3484, 5, 69, 0, 0, 3484, 590, 1, 0, 0, 0, 3485, 3486, + 5, 77, 0, 0, 3486, 3487, 5, 65, 0, 0, 3487, 3488, 5, 84, 0, 0, 3488, 3489, + 5, 67, 0, 0, 3489, 3490, 5, 72, 0, 0, 3490, 3491, 5, 95, 0, 0, 3491, 3492, + 5, 80, 0, 0, 3492, 3493, 5, 72, 0, 0, 3493, 3494, 5, 82, 0, 0, 3494, 3495, + 5, 65, 0, 0, 3495, 3496, 5, 83, 0, 0, 3496, 3497, 5, 69, 0, 0, 3497, 3498, + 5, 95, 0, 0, 3498, 3499, 5, 80, 0, 0, 3499, 3500, 5, 82, 0, 0, 3500, 3501, + 5, 69, 0, 0, 3501, 3502, 5, 70, 0, 0, 3502, 3503, 5, 73, 0, 0, 3503, 3504, + 5, 88, 0, 0, 3504, 592, 1, 0, 0, 0, 3505, 3506, 5, 77, 0, 0, 3506, 3507, + 5, 65, 0, 0, 3507, 3508, 5, 84, 0, 0, 3508, 3509, 5, 67, 0, 0, 3509, 3510, + 5, 72, 0, 0, 3510, 3511, 5, 95, 0, 0, 3511, 3512, 5, 82, 0, 0, 3512, 3513, + 5, 69, 0, 0, 3513, 3514, 5, 71, 0, 0, 3514, 3515, 5, 69, 0, 0, 3515, 3516, + 5, 88, 0, 0, 3516, 3517, 5, 80, 0, 0, 3517, 594, 1, 0, 0, 0, 3518, 3519, + 5, 77, 0, 0, 3519, 3520, 5, 65, 0, 0, 3520, 3521, 5, 84, 0, 0, 3521, 3522, + 5, 69, 0, 0, 3522, 3523, 5, 82, 0, 0, 3523, 3524, 5, 73, 0, 0, 3524, 3525, + 5, 65, 0, 0, 3525, 3526, 5, 76, 0, 0, 3526, 3527, 5, 73, 0, 0, 3527, 3528, + 5, 90, 0, 0, 3528, 3529, 5, 69, 0, 0, 3529, 3530, 5, 68, 0, 0, 3530, 596, + 1, 0, 0, 0, 3531, 3532, 5, 77, 0, 0, 3532, 3533, 5, 65, 0, 0, 3533, 3534, + 5, 88, 0, 0, 3534, 598, 1, 0, 0, 0, 3535, 3536, 5, 77, 0, 0, 3536, 3537, + 5, 65, 0, 0, 3537, 3538, 5, 88, 0, 0, 3538, 3539, 5, 86, 0, 0, 3539, 3540, + 5, 65, 0, 0, 3540, 3541, 5, 76, 0, 0, 3541, 3542, 5, 85, 0, 0, 3542, 3543, + 5, 69, 0, 0, 3543, 600, 1, 0, 0, 0, 3544, 3545, 5, 77, 0, 0, 3545, 3546, + 5, 69, 0, 0, 3546, 3547, 5, 77, 0, 0, 3547, 3548, 5, 79, 0, 0, 3548, 602, + 1, 0, 0, 0, 3549, 3550, 5, 77, 0, 0, 3550, 3551, 5, 69, 0, 0, 3551, 3552, + 5, 82, 0, 0, 3552, 3553, 5, 71, 0, 0, 3553, 3554, 5, 69, 0, 0, 3554, 604, + 1, 0, 0, 0, 3555, 3556, 5, 77, 0, 0, 3556, 3557, 5, 73, 0, 0, 3557, 3558, + 5, 68, 0, 0, 3558, 606, 1, 0, 0, 0, 3559, 3560, 5, 77, 0, 0, 3560, 3561, + 5, 73, 0, 0, 3561, 3562, 5, 71, 0, 0, 3562, 3563, 5, 82, 0, 0, 3563, 3564, + 5, 65, 0, 0, 3564, 3565, 5, 84, 0, 0, 3565, 3566, 5, 69, 0, 0, 3566, 608, + 1, 0, 0, 0, 3567, 3568, 5, 77, 0, 0, 3568, 3569, 5, 73, 0, 0, 3569, 3570, + 5, 71, 0, 0, 3570, 3571, 5, 82, 0, 0, 3571, 3572, 5, 65, 0, 0, 3572, 3573, + 5, 84, 0, 0, 3573, 3574, 5, 73, 0, 0, 3574, 3575, 5, 79, 0, 0, 3575, 3576, + 5, 78, 0, 0, 3576, 3577, 5, 83, 0, 0, 3577, 610, 1, 0, 0, 0, 3578, 3579, + 5, 77, 0, 0, 3579, 3580, 5, 73, 0, 0, 3580, 3581, 5, 78, 0, 0, 3581, 612, + 1, 0, 0, 0, 3582, 3583, 5, 77, 0, 0, 3583, 3584, 5, 73, 0, 0, 3584, 3585, + 5, 78, 0, 0, 3585, 3586, 5, 85, 0, 0, 3586, 3587, 5, 83, 0, 0, 3587, 614, + 1, 0, 0, 0, 3588, 3589, 5, 77, 0, 0, 3589, 3590, 5, 73, 0, 0, 3590, 3591, + 5, 78, 0, 0, 3591, 3592, 5, 85, 0, 0, 3592, 3593, 5, 84, 0, 0, 3593, 3594, + 5, 69, 0, 0, 3594, 616, 1, 0, 0, 0, 3595, 3596, 5, 77, 0, 0, 3596, 3597, + 5, 73, 0, 0, 3597, 3598, 5, 78, 0, 0, 3598, 3599, 5, 85, 0, 0, 3599, 3600, + 5, 84, 0, 0, 3600, 3601, 5, 69, 0, 0, 3601, 3602, 5, 83, 0, 0, 3602, 618, + 1, 0, 0, 0, 3603, 3604, 5, 77, 0, 0, 3604, 3605, 5, 73, 0, 0, 3605, 3606, + 5, 78, 0, 0, 3606, 3607, 5, 85, 0, 0, 3607, 3608, 5, 84, 0, 0, 3608, 3609, + 5, 69, 0, 0, 3609, 3610, 5, 95, 0, 0, 3610, 3611, 5, 83, 0, 0, 3611, 3612, + 5, 69, 0, 0, 3612, 3613, 5, 67, 0, 0, 3613, 3614, 5, 79, 0, 0, 3614, 3615, + 5, 78, 0, 0, 3615, 3616, 5, 68, 0, 0, 3616, 620, 1, 0, 0, 0, 3617, 3618, + 5, 77, 0, 0, 3618, 3619, 5, 79, 0, 0, 3619, 3620, 5, 68, 0, 0, 3620, 3621, + 5, 73, 0, 0, 3621, 3622, 5, 70, 0, 0, 3622, 3623, 5, 89, 0, 0, 3623, 622, + 1, 0, 0, 0, 3624, 3625, 5, 77, 0, 0, 3625, 3626, 5, 79, 0, 0, 3626, 3627, + 5, 78, 0, 0, 3627, 3628, 5, 84, 0, 0, 3628, 3629, 5, 72, 0, 0, 3629, 624, + 1, 0, 0, 0, 3630, 3631, 5, 77, 0, 0, 3631, 3632, 5, 84, 0, 0, 3632, 3633, + 5, 77, 0, 0, 3633, 3634, 5, 86, 0, 0, 3634, 626, 1, 0, 0, 0, 3635, 3636, + 5, 78, 0, 0, 3636, 3637, 5, 65, 0, 0, 3637, 3638, 5, 77, 0, 0, 3638, 3639, + 5, 69, 0, 0, 3639, 628, 1, 0, 0, 0, 3640, 3641, 5, 78, 0, 0, 3641, 3642, + 5, 65, 0, 0, 3642, 3643, 5, 77, 0, 0, 3643, 3644, 5, 69, 0, 0, 3644, 3645, + 5, 83, 0, 0, 3645, 630, 1, 0, 0, 0, 3646, 3647, 5, 78, 0, 0, 3647, 3648, + 5, 65, 0, 0, 3648, 3649, 5, 84, 0, 0, 3649, 3650, 5, 85, 0, 0, 3650, 3651, + 5, 82, 0, 0, 3651, 3652, 5, 65, 0, 0, 3652, 3653, 5, 76, 0, 0, 3653, 632, + 1, 0, 0, 0, 3654, 3655, 5, 78, 0, 0, 3655, 3656, 5, 69, 0, 0, 3656, 3657, + 5, 71, 0, 0, 3657, 3658, 5, 65, 0, 0, 3658, 3659, 5, 84, 0, 0, 3659, 3660, + 5, 73, 0, 0, 3660, 3661, 5, 86, 0, 0, 3661, 3662, 5, 69, 0, 0, 3662, 634, + 1, 0, 0, 0, 3663, 3664, 5, 78, 0, 0, 3664, 3665, 5, 69, 0, 0, 3665, 3666, + 5, 86, 0, 0, 3666, 3667, 5, 69, 0, 0, 3667, 3668, 5, 82, 0, 0, 3668, 636, + 1, 0, 0, 0, 3669, 3670, 5, 78, 0, 0, 3670, 3671, 5, 69, 0, 0, 3671, 3672, + 5, 88, 0, 0, 3672, 3673, 5, 84, 0, 0, 3673, 638, 1, 0, 0, 0, 3674, 3675, + 5, 78, 0, 0, 3675, 3676, 5, 71, 0, 0, 3676, 3677, 5, 82, 0, 0, 3677, 3678, + 5, 65, 0, 0, 3678, 3679, 5, 77, 0, 0, 3679, 3680, 5, 95, 0, 0, 3680, 3681, + 5, 66, 0, 0, 3681, 3682, 5, 70, 0, 0, 3682, 640, 1, 0, 0, 0, 3683, 3684, + 5, 65, 0, 0, 3684, 3685, 5, 78, 0, 0, 3685, 3686, 5, 78, 0, 0, 3686, 642, + 1, 0, 0, 0, 3687, 3688, 5, 78, 0, 0, 3688, 3689, 5, 79, 0, 0, 3689, 644, + 1, 0, 0, 0, 3690, 3691, 5, 78, 0, 0, 3691, 3692, 5, 79, 0, 0, 3692, 3693, + 5, 95, 0, 0, 3693, 3694, 5, 85, 0, 0, 3694, 3695, 5, 83, 0, 0, 3695, 3696, + 5, 69, 0, 0, 3696, 3697, 5, 95, 0, 0, 3697, 3698, 5, 77, 0, 0, 3698, 3699, + 5, 86, 0, 0, 3699, 646, 1, 0, 0, 0, 3700, 3701, 5, 78, 0, 0, 3701, 3702, + 5, 79, 0, 0, 3702, 3703, 5, 78, 0, 0, 3703, 3704, 5, 95, 0, 0, 3704, 3705, + 5, 78, 0, 0, 3705, 3706, 5, 85, 0, 0, 3706, 3707, 5, 76, 0, 0, 3707, 3708, + 5, 76, 0, 0, 3708, 3709, 5, 65, 0, 0, 3709, 3710, 5, 66, 0, 0, 3710, 3711, + 5, 76, 0, 0, 3711, 3712, 5, 69, 0, 0, 3712, 648, 1, 0, 0, 0, 3713, 3714, + 5, 78, 0, 0, 3714, 3715, 5, 79, 0, 0, 3715, 3716, 5, 84, 0, 0, 3716, 650, + 1, 0, 0, 0, 3717, 3718, 5, 78, 0, 0, 3718, 3719, 5, 85, 0, 0, 3719, 3720, + 5, 76, 0, 0, 3720, 3721, 5, 76, 0, 0, 3721, 652, 1, 0, 0, 0, 3722, 3723, + 5, 78, 0, 0, 3723, 3724, 5, 85, 0, 0, 3724, 3725, 5, 76, 0, 0, 3725, 3726, + 5, 76, 0, 0, 3726, 3727, 5, 83, 0, 0, 3727, 654, 1, 0, 0, 0, 3728, 3729, + 5, 79, 0, 0, 3729, 3730, 5, 66, 0, 0, 3730, 3731, 5, 83, 0, 0, 3731, 3732, + 5, 69, 0, 0, 3732, 3733, 5, 82, 0, 0, 3733, 3734, 5, 86, 0, 0, 3734, 3735, + 5, 69, 0, 0, 3735, 3736, 5, 82, 0, 0, 3736, 656, 1, 0, 0, 0, 3737, 3738, + 5, 79, 0, 0, 3738, 3739, 5, 70, 0, 0, 3739, 658, 1, 0, 0, 0, 3740, 3741, + 5, 79, 0, 0, 3741, 3742, 5, 70, 0, 0, 3742, 3743, 5, 70, 0, 0, 3743, 3744, + 5, 83, 0, 0, 3744, 3745, 5, 69, 0, 0, 3745, 3746, 5, 84, 0, 0, 3746, 660, + 1, 0, 0, 0, 3747, 3748, 5, 79, 0, 0, 3748, 3749, 5, 78, 0, 0, 3749, 662, + 1, 0, 0, 0, 3750, 3751, 5, 79, 0, 0, 3751, 3752, 5, 70, 0, 0, 3752, 3753, + 5, 70, 0, 0, 3753, 664, 1, 0, 0, 0, 3754, 3755, 5, 79, 0, 0, 3755, 3756, + 5, 78, 0, 0, 3756, 3757, 5, 76, 0, 0, 3757, 3758, 5, 89, 0, 0, 3758, 666, + 1, 0, 0, 0, 3759, 3760, 5, 79, 0, 0, 3760, 3761, 5, 80, 0, 0, 3761, 3762, + 5, 69, 0, 0, 3762, 3763, 5, 78, 0, 0, 3763, 668, 1, 0, 0, 0, 3764, 3765, + 5, 79, 0, 0, 3765, 3766, 5, 80, 0, 0, 3766, 3767, 5, 84, 0, 0, 3767, 3768, + 5, 73, 0, 0, 3768, 3769, 5, 77, 0, 0, 3769, 3770, 5, 73, 0, 0, 3770, 3771, + 5, 90, 0, 0, 3771, 3772, 5, 69, 0, 0, 3772, 670, 1, 0, 0, 0, 3773, 3774, + 5, 79, 0, 0, 3774, 3775, 5, 80, 0, 0, 3775, 3776, 5, 84, 0, 0, 3776, 3777, + 5, 73, 0, 0, 3777, 3778, 5, 77, 0, 0, 3778, 3779, 5, 73, 0, 0, 3779, 3780, + 5, 90, 0, 0, 3780, 3781, 5, 69, 0, 0, 3781, 3782, 5, 68, 0, 0, 3782, 672, + 1, 0, 0, 0, 3783, 3784, 5, 79, 0, 0, 3784, 3785, 5, 82, 0, 0, 3785, 674, + 1, 0, 0, 0, 3786, 3787, 5, 79, 0, 0, 3787, 3788, 5, 82, 0, 0, 3788, 3789, + 5, 68, 0, 0, 3789, 3790, 5, 69, 0, 0, 3790, 3791, 5, 82, 0, 0, 3791, 676, + 1, 0, 0, 0, 3792, 3793, 5, 79, 0, 0, 3793, 3794, 5, 85, 0, 0, 3794, 3795, + 5, 84, 0, 0, 3795, 3796, 5, 69, 0, 0, 3796, 3797, 5, 82, 0, 0, 3797, 678, + 1, 0, 0, 0, 3798, 3799, 5, 79, 0, 0, 3799, 3800, 5, 85, 0, 0, 3800, 3801, + 5, 84, 0, 0, 3801, 3802, 5, 70, 0, 0, 3802, 3803, 5, 73, 0, 0, 3803, 3804, + 5, 76, 0, 0, 3804, 3805, 5, 69, 0, 0, 3805, 680, 1, 0, 0, 0, 3806, 3807, + 5, 79, 0, 0, 3807, 3808, 5, 86, 0, 0, 3808, 3809, 5, 69, 0, 0, 3809, 3810, + 5, 82, 0, 0, 3810, 682, 1, 0, 0, 0, 3811, 3812, 5, 79, 0, 0, 3812, 3813, + 5, 86, 0, 0, 3813, 3814, 5, 69, 0, 0, 3814, 3815, 5, 82, 0, 0, 3815, 3816, + 5, 87, 0, 0, 3816, 3817, 5, 82, 0, 0, 3817, 3818, 5, 73, 0, 0, 3818, 3819, + 5, 84, 0, 0, 3819, 3820, 5, 69, 0, 0, 3820, 684, 1, 0, 0, 0, 3821, 3822, + 5, 80, 0, 0, 3822, 3823, 5, 65, 0, 0, 3823, 3824, 5, 82, 0, 0, 3824, 3825, + 5, 65, 0, 0, 3825, 3826, 5, 77, 0, 0, 3826, 3827, 5, 69, 0, 0, 3827, 3828, + 5, 84, 0, 0, 3828, 3829, 5, 69, 0, 0, 3829, 3830, 5, 82, 0, 0, 3830, 686, + 1, 0, 0, 0, 3831, 3832, 5, 80, 0, 0, 3832, 3833, 5, 65, 0, 0, 3833, 3834, + 5, 82, 0, 0, 3834, 3835, 5, 83, 0, 0, 3835, 3836, 5, 69, 0, 0, 3836, 3837, + 5, 68, 0, 0, 3837, 688, 1, 0, 0, 0, 3838, 3839, 5, 80, 0, 0, 3839, 3840, + 5, 65, 0, 0, 3840, 3841, 5, 82, 0, 0, 3841, 3842, 5, 84, 0, 0, 3842, 3843, + 5, 73, 0, 0, 3843, 3844, 5, 84, 0, 0, 3844, 3845, 5, 73, 0, 0, 3845, 3846, + 5, 79, 0, 0, 3846, 3847, 5, 78, 0, 0, 3847, 690, 1, 0, 0, 0, 3848, 3849, + 5, 80, 0, 0, 3849, 3850, 5, 65, 0, 0, 3850, 3851, 5, 82, 0, 0, 3851, 3852, + 5, 84, 0, 0, 3852, 3853, 5, 73, 0, 0, 3853, 3854, 5, 84, 0, 0, 3854, 3855, + 5, 73, 0, 0, 3855, 3856, 5, 79, 0, 0, 3856, 3857, 5, 78, 0, 0, 3857, 3858, + 5, 83, 0, 0, 3858, 692, 1, 0, 0, 0, 3859, 3860, 5, 80, 0, 0, 3860, 3861, + 5, 65, 0, 0, 3861, 3862, 5, 83, 0, 0, 3862, 3863, 5, 83, 0, 0, 3863, 3864, + 5, 87, 0, 0, 3864, 3865, 5, 79, 0, 0, 3865, 3866, 5, 82, 0, 0, 3866, 3867, + 5, 68, 0, 0, 3867, 694, 1, 0, 0, 0, 3868, 3869, 5, 80, 0, 0, 3869, 3870, + 5, 65, 0, 0, 3870, 3871, 5, 83, 0, 0, 3871, 3872, 5, 83, 0, 0, 3872, 3873, + 5, 87, 0, 0, 3873, 3874, 5, 79, 0, 0, 3874, 3875, 5, 82, 0, 0, 3875, 3876, + 5, 68, 0, 0, 3876, 3877, 5, 95, 0, 0, 3877, 3878, 5, 69, 0, 0, 3878, 3879, + 5, 88, 0, 0, 3879, 3880, 5, 80, 0, 0, 3880, 3881, 5, 73, 0, 0, 3881, 3882, + 5, 82, 0, 0, 3882, 3883, 5, 69, 0, 0, 3883, 696, 1, 0, 0, 0, 3884, 3885, + 5, 80, 0, 0, 3885, 3886, 5, 65, 0, 0, 3886, 3887, 5, 83, 0, 0, 3887, 3888, + 5, 83, 0, 0, 3888, 3889, 5, 87, 0, 0, 3889, 3890, 5, 79, 0, 0, 3890, 3891, + 5, 82, 0, 0, 3891, 3892, 5, 68, 0, 0, 3892, 3893, 5, 95, 0, 0, 3893, 3894, + 5, 72, 0, 0, 3894, 3895, 5, 73, 0, 0, 3895, 3896, 5, 83, 0, 0, 3896, 3897, + 5, 84, 0, 0, 3897, 3898, 5, 79, 0, 0, 3898, 3899, 5, 82, 0, 0, 3899, 3900, + 5, 89, 0, 0, 3900, 698, 1, 0, 0, 0, 3901, 3902, 5, 80, 0, 0, 3902, 3903, + 5, 65, 0, 0, 3903, 3904, 5, 83, 0, 0, 3904, 3905, 5, 83, 0, 0, 3905, 3906, + 5, 87, 0, 0, 3906, 3907, 5, 79, 0, 0, 3907, 3908, 5, 82, 0, 0, 3908, 3909, + 5, 68, 0, 0, 3909, 3910, 5, 95, 0, 0, 3910, 3911, 5, 76, 0, 0, 3911, 3912, + 5, 79, 0, 0, 3912, 3913, 5, 67, 0, 0, 3913, 3914, 5, 75, 0, 0, 3914, 3915, + 5, 95, 0, 0, 3915, 3916, 5, 84, 0, 0, 3916, 3917, 5, 73, 0, 0, 3917, 3918, + 5, 77, 0, 0, 3918, 3919, 5, 69, 0, 0, 3919, 700, 1, 0, 0, 0, 3920, 3921, + 5, 80, 0, 0, 3921, 3922, 5, 65, 0, 0, 3922, 3923, 5, 83, 0, 0, 3923, 3924, + 5, 83, 0, 0, 3924, 3925, 5, 87, 0, 0, 3925, 3926, 5, 79, 0, 0, 3926, 3927, + 5, 82, 0, 0, 3927, 3928, 5, 68, 0, 0, 3928, 3929, 5, 95, 0, 0, 3929, 3930, + 5, 82, 0, 0, 3930, 3931, 5, 69, 0, 0, 3931, 3932, 5, 85, 0, 0, 3932, 3933, + 5, 83, 0, 0, 3933, 3934, 5, 69, 0, 0, 3934, 702, 1, 0, 0, 0, 3935, 3936, + 5, 80, 0, 0, 3936, 3937, 5, 65, 0, 0, 3937, 3938, 5, 84, 0, 0, 3938, 3939, + 5, 72, 0, 0, 3939, 704, 1, 0, 0, 0, 3940, 3941, 5, 80, 0, 0, 3941, 3942, + 5, 65, 0, 0, 3942, 3943, 5, 85, 0, 0, 3943, 3944, 5, 83, 0, 0, 3944, 3945, + 5, 69, 0, 0, 3945, 706, 1, 0, 0, 0, 3946, 3947, 5, 80, 0, 0, 3947, 3948, + 5, 69, 0, 0, 3948, 3949, 5, 82, 0, 0, 3949, 3950, 5, 67, 0, 0, 3950, 3951, + 5, 69, 0, 0, 3951, 3952, 5, 78, 0, 0, 3952, 3953, 5, 84, 0, 0, 3953, 708, + 1, 0, 0, 0, 3954, 3955, 5, 80, 0, 0, 3955, 3956, 5, 69, 0, 0, 3956, 3957, + 5, 82, 0, 0, 3957, 3958, 5, 73, 0, 0, 3958, 3959, 5, 79, 0, 0, 3959, 3960, + 5, 68, 0, 0, 3960, 710, 1, 0, 0, 0, 3961, 3962, 5, 80, 0, 0, 3962, 3963, + 5, 69, 0, 0, 3963, 3964, 5, 82, 0, 0, 3964, 3965, 5, 77, 0, 0, 3965, 3966, + 5, 73, 0, 0, 3966, 3967, 5, 83, 0, 0, 3967, 3968, 5, 83, 0, 0, 3968, 3969, + 5, 73, 0, 0, 3969, 3970, 5, 86, 0, 0, 3970, 3971, 5, 69, 0, 0, 3971, 712, + 1, 0, 0, 0, 3972, 3973, 5, 80, 0, 0, 3973, 3974, 5, 72, 0, 0, 3974, 3975, + 5, 89, 0, 0, 3975, 3976, 5, 83, 0, 0, 3976, 3977, 5, 73, 0, 0, 3977, 3978, + 5, 67, 0, 0, 3978, 3979, 5, 65, 0, 0, 3979, 3980, 5, 76, 0, 0, 3980, 714, + 1, 0, 0, 0, 3981, 3982, 5, 80, 0, 0, 3982, 3983, 5, 73, 0, 0, 3983, 716, + 1, 0, 0, 0, 3984, 3985, 5, 63, 0, 0, 3985, 718, 1, 0, 0, 0, 3986, 3987, + 5, 80, 0, 0, 3987, 3988, 5, 76, 0, 0, 3988, 3989, 5, 65, 0, 0, 3989, 3990, + 5, 78, 0, 0, 3990, 720, 1, 0, 0, 0, 3991, 3992, 5, 80, 0, 0, 3992, 3993, + 5, 76, 0, 0, 3993, 3994, 5, 65, 0, 0, 3994, 3995, 5, 89, 0, 0, 3995, 722, + 1, 0, 0, 0, 3996, 3997, 5, 80, 0, 0, 3997, 3998, 5, 82, 0, 0, 3998, 3999, + 5, 73, 0, 0, 3999, 4000, 5, 86, 0, 0, 4000, 4001, 5, 73, 0, 0, 4001, 4002, + 5, 76, 0, 0, 4002, 4003, 5, 69, 0, 0, 4003, 4004, 5, 71, 0, 0, 4004, 4005, + 5, 69, 0, 0, 4005, 4006, 5, 83, 0, 0, 4006, 724, 1, 0, 0, 0, 4007, 4008, + 5, 80, 0, 0, 4008, 4009, 5, 82, 0, 0, 4009, 4010, 5, 79, 0, 0, 4010, 4011, + 5, 67, 0, 0, 4011, 4012, 5, 69, 0, 0, 4012, 4013, 5, 83, 0, 0, 4013, 4014, + 5, 83, 0, 0, 4014, 726, 1, 0, 0, 0, 4015, 4016, 5, 80, 0, 0, 4016, 4017, + 5, 76, 0, 0, 4017, 4018, 5, 85, 0, 0, 4018, 4019, 5, 71, 0, 0, 4019, 4020, + 5, 73, 0, 0, 4020, 4021, 5, 78, 0, 0, 4021, 728, 1, 0, 0, 0, 4022, 4023, + 5, 80, 0, 0, 4023, 4024, 5, 76, 0, 0, 4024, 4025, 5, 85, 0, 0, 4025, 4026, + 5, 71, 0, 0, 4026, 4027, 5, 73, 0, 0, 4027, 4028, 5, 78, 0, 0, 4028, 4029, + 5, 83, 0, 0, 4029, 730, 1, 0, 0, 0, 4030, 4031, 5, 80, 0, 0, 4031, 4032, + 5, 79, 0, 0, 4032, 4033, 5, 76, 0, 0, 4033, 4034, 5, 73, 0, 0, 4034, 4035, + 5, 67, 0, 0, 4035, 4036, 5, 89, 0, 0, 4036, 732, 1, 0, 0, 0, 4037, 4038, + 5, 80, 0, 0, 4038, 4039, 5, 79, 0, 0, 4039, 4040, 5, 83, 0, 0, 4040, 4041, + 5, 73, 0, 0, 4041, 4042, 5, 84, 0, 0, 4042, 4043, 5, 73, 0, 0, 4043, 4044, + 5, 79, 0, 0, 4044, 4045, 5, 78, 0, 0, 4045, 734, 1, 0, 0, 0, 4046, 4047, + 5, 80, 0, 0, 4047, 4048, 5, 82, 0, 0, 4048, 4049, 5, 69, 0, 0, 4049, 4050, + 5, 67, 0, 0, 4050, 4051, 5, 69, 0, 0, 4051, 4052, 5, 68, 0, 0, 4052, 4053, + 5, 73, 0, 0, 4053, 4054, 5, 78, 0, 0, 4054, 4055, 5, 71, 0, 0, 4055, 736, + 1, 0, 0, 0, 4056, 4057, 5, 80, 0, 0, 4057, 4058, 5, 82, 0, 0, 4058, 4059, + 5, 69, 0, 0, 4059, 4060, 5, 80, 0, 0, 4060, 4061, 5, 65, 0, 0, 4061, 4062, + 5, 82, 0, 0, 4062, 4063, 5, 69, 0, 0, 4063, 738, 1, 0, 0, 0, 4064, 4065, + 5, 80, 0, 0, 4065, 4066, 5, 82, 0, 0, 4066, 4067, 5, 73, 0, 0, 4067, 4068, + 5, 77, 0, 0, 4068, 4069, 5, 65, 0, 0, 4069, 4070, 5, 82, 0, 0, 4070, 4071, + 5, 89, 0, 0, 4071, 740, 1, 0, 0, 0, 4072, 4073, 5, 80, 0, 0, 4073, 4074, + 5, 82, 0, 0, 4074, 4075, 5, 79, 0, 0, 4075, 4076, 5, 67, 0, 0, 4076, 742, + 1, 0, 0, 0, 4077, 4078, 5, 80, 0, 0, 4078, 4079, 5, 82, 0, 0, 4079, 4080, + 5, 79, 0, 0, 4080, 4081, 5, 67, 0, 0, 4081, 4082, 5, 69, 0, 0, 4082, 4083, + 5, 68, 0, 0, 4083, 4084, 5, 85, 0, 0, 4084, 4085, 5, 82, 0, 0, 4085, 4086, + 5, 69, 0, 0, 4086, 744, 1, 0, 0, 0, 4087, 4088, 5, 80, 0, 0, 4088, 4089, + 5, 82, 0, 0, 4089, 4090, 5, 79, 0, 0, 4090, 4091, 5, 67, 0, 0, 4091, 4092, + 5, 69, 0, 0, 4092, 4093, 5, 83, 0, 0, 4093, 4094, 5, 83, 0, 0, 4094, 4095, + 5, 76, 0, 0, 4095, 4096, 5, 73, 0, 0, 4096, 4097, 5, 83, 0, 0, 4097, 4098, + 5, 84, 0, 0, 4098, 746, 1, 0, 0, 0, 4099, 4100, 5, 80, 0, 0, 4100, 4101, + 5, 82, 0, 0, 4101, 4102, 5, 79, 0, 0, 4102, 4103, 5, 70, 0, 0, 4103, 4104, + 5, 73, 0, 0, 4104, 4105, 5, 76, 0, 0, 4105, 4106, 5, 69, 0, 0, 4106, 748, + 1, 0, 0, 0, 4107, 4108, 5, 80, 0, 0, 4108, 4109, 5, 82, 0, 0, 4109, 4110, + 5, 79, 0, 0, 4110, 4111, 5, 80, 0, 0, 4111, 4112, 5, 69, 0, 0, 4112, 4113, + 5, 82, 0, 0, 4113, 4114, 5, 84, 0, 0, 4114, 4115, 5, 73, 0, 0, 4115, 4116, + 5, 69, 0, 0, 4116, 4117, 5, 83, 0, 0, 4117, 750, 1, 0, 0, 0, 4118, 4119, + 5, 80, 0, 0, 4119, 4120, 5, 82, 0, 0, 4120, 4121, 5, 79, 0, 0, 4121, 4122, + 5, 80, 0, 0, 4122, 4123, 5, 69, 0, 0, 4123, 4124, 5, 82, 0, 0, 4124, 4125, + 5, 84, 0, 0, 4125, 4126, 5, 89, 0, 0, 4126, 752, 1, 0, 0, 0, 4127, 4128, + 5, 81, 0, 0, 4128, 4129, 5, 85, 0, 0, 4129, 4130, 5, 65, 0, 0, 4130, 4131, + 5, 78, 0, 0, 4131, 4132, 5, 84, 0, 0, 4132, 4133, 5, 73, 0, 0, 4133, 4134, + 5, 76, 0, 0, 4134, 4135, 5, 69, 0, 0, 4135, 4136, 5, 95, 0, 0, 4136, 4137, + 5, 83, 0, 0, 4137, 4138, 5, 84, 0, 0, 4138, 4139, 5, 65, 0, 0, 4139, 4140, + 5, 84, 0, 0, 4140, 4141, 5, 69, 0, 0, 4141, 754, 1, 0, 0, 0, 4142, 4143, + 5, 81, 0, 0, 4143, 4144, 5, 85, 0, 0, 4144, 4145, 5, 65, 0, 0, 4145, 4146, + 5, 78, 0, 0, 4146, 4147, 5, 84, 0, 0, 4147, 4148, 5, 73, 0, 0, 4148, 4149, + 5, 76, 0, 0, 4149, 4150, 5, 69, 0, 0, 4150, 4151, 5, 95, 0, 0, 4151, 4152, + 5, 85, 0, 0, 4152, 4153, 5, 78, 0, 0, 4153, 4154, 5, 73, 0, 0, 4154, 4155, + 5, 79, 0, 0, 4155, 4156, 5, 78, 0, 0, 4156, 756, 1, 0, 0, 0, 4157, 4158, + 5, 81, 0, 0, 4158, 4159, 5, 85, 0, 0, 4159, 4160, 5, 69, 0, 0, 4160, 4161, + 5, 82, 0, 0, 4161, 4162, 5, 89, 0, 0, 4162, 758, 1, 0, 0, 0, 4163, 4164, + 5, 81, 0, 0, 4164, 4165, 5, 85, 0, 0, 4165, 4166, 5, 69, 0, 0, 4166, 4167, + 5, 85, 0, 0, 4167, 4168, 5, 69, 0, 0, 4168, 4169, 5, 68, 0, 0, 4169, 760, + 1, 0, 0, 0, 4170, 4171, 5, 81, 0, 0, 4171, 4172, 5, 85, 0, 0, 4172, 4173, + 5, 79, 0, 0, 4173, 4174, 5, 84, 0, 0, 4174, 4175, 5, 65, 0, 0, 4175, 762, + 1, 0, 0, 0, 4176, 4177, 5, 81, 0, 0, 4177, 4178, 5, 85, 0, 0, 4178, 4179, + 5, 65, 0, 0, 4179, 4180, 5, 76, 0, 0, 4180, 4181, 5, 73, 0, 0, 4181, 4182, + 5, 70, 0, 0, 4182, 4183, 5, 89, 0, 0, 4183, 764, 1, 0, 0, 0, 4184, 4185, + 5, 81, 0, 0, 4185, 4186, 5, 85, 0, 0, 4186, 4187, 5, 65, 0, 0, 4187, 4188, + 5, 82, 0, 0, 4188, 4189, 5, 84, 0, 0, 4189, 4190, 5, 69, 0, 0, 4190, 4191, + 5, 82, 0, 0, 4191, 766, 1, 0, 0, 0, 4192, 4193, 5, 82, 0, 0, 4193, 4194, + 5, 65, 0, 0, 4194, 4195, 5, 78, 0, 0, 4195, 4196, 5, 68, 0, 0, 4196, 4197, + 5, 79, 0, 0, 4197, 4198, 5, 77, 0, 0, 4198, 768, 1, 0, 0, 0, 4199, 4200, + 5, 82, 0, 0, 4200, 4201, 5, 65, 0, 0, 4201, 4202, 5, 78, 0, 0, 4202, 4203, + 5, 71, 0, 0, 4203, 4204, 5, 69, 0, 0, 4204, 770, 1, 0, 0, 0, 4205, 4206, + 5, 82, 0, 0, 4206, 4207, 5, 69, 0, 0, 4207, 4208, 5, 65, 0, 0, 4208, 4209, + 5, 68, 0, 0, 4209, 772, 1, 0, 0, 0, 4210, 4211, 5, 82, 0, 0, 4211, 4212, + 5, 69, 0, 0, 4212, 4213, 5, 65, 0, 0, 4213, 4214, 5, 76, 0, 0, 4214, 774, + 1, 0, 0, 0, 4215, 4216, 5, 82, 0, 0, 4216, 4217, 5, 69, 0, 0, 4217, 4218, + 5, 66, 0, 0, 4218, 4219, 5, 65, 0, 0, 4219, 4220, 5, 76, 0, 0, 4220, 4221, + 5, 65, 0, 0, 4221, 4222, 5, 78, 0, 0, 4222, 4223, 5, 67, 0, 0, 4223, 4224, + 5, 69, 0, 0, 4224, 776, 1, 0, 0, 0, 4225, 4226, 5, 82, 0, 0, 4226, 4227, + 5, 69, 0, 0, 4227, 4228, 5, 67, 0, 0, 4228, 4229, 5, 69, 0, 0, 4229, 4230, + 5, 78, 0, 0, 4230, 4231, 5, 84, 0, 0, 4231, 778, 1, 0, 0, 0, 4232, 4233, + 5, 82, 0, 0, 4233, 4234, 5, 69, 0, 0, 4234, 4235, 5, 67, 0, 0, 4235, 4236, + 5, 79, 0, 0, 4236, 4237, 5, 86, 0, 0, 4237, 4238, 5, 69, 0, 0, 4238, 4239, + 5, 82, 0, 0, 4239, 780, 1, 0, 0, 0, 4240, 4241, 5, 82, 0, 0, 4241, 4242, + 5, 69, 0, 0, 4242, 4243, 5, 67, 0, 0, 4243, 4244, 5, 89, 0, 0, 4244, 4245, + 5, 67, 0, 0, 4245, 4246, 5, 76, 0, 0, 4246, 4247, 5, 69, 0, 0, 4247, 782, + 1, 0, 0, 0, 4248, 4249, 5, 82, 0, 0, 4249, 4250, 5, 69, 0, 0, 4250, 4251, + 5, 70, 0, 0, 4251, 4252, 5, 82, 0, 0, 4252, 4253, 5, 69, 0, 0, 4253, 4254, + 5, 83, 0, 0, 4254, 4255, 5, 72, 0, 0, 4255, 784, 1, 0, 0, 0, 4256, 4257, + 5, 82, 0, 0, 4257, 4258, 5, 69, 0, 0, 4258, 4259, 5, 70, 0, 0, 4259, 4260, + 5, 69, 0, 0, 4260, 4261, 5, 82, 0, 0, 4261, 4262, 5, 69, 0, 0, 4262, 4263, + 5, 78, 0, 0, 4263, 4264, 5, 67, 0, 0, 4264, 4265, 5, 69, 0, 0, 4265, 4266, + 5, 83, 0, 0, 4266, 786, 1, 0, 0, 0, 4267, 4268, 5, 82, 0, 0, 4268, 4269, + 5, 69, 0, 0, 4269, 4270, 5, 71, 0, 0, 4270, 4271, 5, 69, 0, 0, 4271, 4272, + 5, 88, 0, 0, 4272, 4273, 5, 80, 0, 0, 4273, 788, 1, 0, 0, 0, 4274, 4275, + 5, 82, 0, 0, 4275, 4276, 5, 69, 0, 0, 4276, 4277, 5, 76, 0, 0, 4277, 4278, + 5, 69, 0, 0, 4278, 4279, 5, 65, 0, 0, 4279, 4280, 5, 83, 0, 0, 4280, 4281, + 5, 69, 0, 0, 4281, 790, 1, 0, 0, 0, 4282, 4283, 5, 82, 0, 0, 4283, 4284, + 5, 69, 0, 0, 4284, 4285, 5, 78, 0, 0, 4285, 4286, 5, 65, 0, 0, 4286, 4287, + 5, 77, 0, 0, 4287, 4288, 5, 69, 0, 0, 4288, 792, 1, 0, 0, 0, 4289, 4290, + 5, 82, 0, 0, 4290, 4291, 5, 69, 0, 0, 4291, 4292, 5, 80, 0, 0, 4292, 4293, + 5, 65, 0, 0, 4293, 4294, 5, 73, 0, 0, 4294, 4295, 5, 82, 0, 0, 4295, 794, + 1, 0, 0, 0, 4296, 4297, 5, 82, 0, 0, 4297, 4298, 5, 69, 0, 0, 4298, 4299, + 5, 80, 0, 0, 4299, 4300, 5, 69, 0, 0, 4300, 4301, 5, 65, 0, 0, 4301, 4302, + 5, 84, 0, 0, 4302, 4303, 5, 65, 0, 0, 4303, 4304, 5, 66, 0, 0, 4304, 4305, + 5, 76, 0, 0, 4305, 4306, 5, 69, 0, 0, 4306, 796, 1, 0, 0, 0, 4307, 4308, + 5, 82, 0, 0, 4308, 4309, 5, 69, 0, 0, 4309, 4310, 5, 80, 0, 0, 4310, 4311, + 5, 76, 0, 0, 4311, 4312, 5, 65, 0, 0, 4312, 4313, 5, 67, 0, 0, 4313, 4314, + 5, 69, 0, 0, 4314, 798, 1, 0, 0, 0, 4315, 4316, 5, 82, 0, 0, 4316, 4317, + 5, 69, 0, 0, 4317, 4318, 5, 80, 0, 0, 4318, 4319, 5, 76, 0, 0, 4319, 4320, + 5, 65, 0, 0, 4320, 4321, 5, 67, 0, 0, 4321, 4322, 5, 69, 0, 0, 4322, 4323, + 5, 95, 0, 0, 4323, 4324, 5, 73, 0, 0, 4324, 4325, 5, 70, 0, 0, 4325, 4326, + 5, 95, 0, 0, 4326, 4327, 5, 78, 0, 0, 4327, 4328, 5, 79, 0, 0, 4328, 4329, + 5, 84, 0, 0, 4329, 4330, 5, 95, 0, 0, 4330, 4331, 5, 78, 0, 0, 4331, 4332, + 5, 85, 0, 0, 4332, 4333, 5, 76, 0, 0, 4333, 4334, 5, 76, 0, 0, 4334, 800, + 1, 0, 0, 0, 4335, 4336, 5, 82, 0, 0, 4336, 4337, 5, 69, 0, 0, 4337, 4338, + 5, 80, 0, 0, 4338, 4339, 5, 76, 0, 0, 4339, 4340, 5, 65, 0, 0, 4340, 4341, + 5, 89, 0, 0, 4341, 4342, 5, 69, 0, 0, 4342, 4343, 5, 82, 0, 0, 4343, 802, + 1, 0, 0, 0, 4344, 4345, 5, 82, 0, 0, 4345, 4346, 5, 69, 0, 0, 4346, 4347, + 5, 80, 0, 0, 4347, 4348, 5, 76, 0, 0, 4348, 4349, 5, 73, 0, 0, 4349, 4350, + 5, 67, 0, 0, 4350, 4351, 5, 65, 0, 0, 4351, 804, 1, 0, 0, 0, 4352, 4353, + 5, 82, 0, 0, 4353, 4354, 5, 69, 0, 0, 4354, 4355, 5, 80, 0, 0, 4355, 4356, + 5, 79, 0, 0, 4356, 4357, 5, 83, 0, 0, 4357, 4358, 5, 73, 0, 0, 4358, 4359, + 5, 84, 0, 0, 4359, 4360, 5, 79, 0, 0, 4360, 4361, 5, 82, 0, 0, 4361, 4362, + 5, 73, 0, 0, 4362, 4363, 5, 69, 0, 0, 4363, 4364, 5, 83, 0, 0, 4364, 806, + 1, 0, 0, 0, 4365, 4366, 5, 82, 0, 0, 4366, 4367, 5, 69, 0, 0, 4367, 4368, + 5, 80, 0, 0, 4368, 4369, 5, 79, 0, 0, 4369, 4370, 5, 83, 0, 0, 4370, 4371, + 5, 73, 0, 0, 4371, 4372, 5, 84, 0, 0, 4372, 4373, 5, 79, 0, 0, 4373, 4374, + 5, 82, 0, 0, 4374, 4375, 5, 89, 0, 0, 4375, 808, 1, 0, 0, 0, 4376, 4377, + 5, 82, 0, 0, 4377, 4378, 5, 69, 0, 0, 4378, 4379, 5, 83, 0, 0, 4379, 4380, + 5, 79, 0, 0, 4380, 4381, 5, 85, 0, 0, 4381, 4382, 5, 82, 0, 0, 4382, 4383, + 5, 67, 0, 0, 4383, 4384, 5, 69, 0, 0, 4384, 810, 1, 0, 0, 0, 4385, 4386, + 5, 82, 0, 0, 4386, 4387, 5, 69, 0, 0, 4387, 4388, 5, 83, 0, 0, 4388, 4389, + 5, 79, 0, 0, 4389, 4390, 5, 85, 0, 0, 4390, 4391, 5, 82, 0, 0, 4391, 4392, + 5, 67, 0, 0, 4392, 4393, 5, 69, 0, 0, 4393, 4394, 5, 83, 0, 0, 4394, 812, + 1, 0, 0, 0, 4395, 4396, 5, 82, 0, 0, 4396, 4397, 5, 69, 0, 0, 4397, 4398, + 5, 83, 0, 0, 4398, 4399, 5, 84, 0, 0, 4399, 4400, 5, 79, 0, 0, 4400, 4401, + 5, 82, 0, 0, 4401, 4402, 5, 69, 0, 0, 4402, 814, 1, 0, 0, 0, 4403, 4404, + 5, 82, 0, 0, 4404, 4405, 5, 69, 0, 0, 4405, 4406, 5, 83, 0, 0, 4406, 4407, + 5, 84, 0, 0, 4407, 4408, 5, 82, 0, 0, 4408, 4409, 5, 73, 0, 0, 4409, 4410, + 5, 67, 0, 0, 4410, 4411, 5, 84, 0, 0, 4411, 4412, 5, 73, 0, 0, 4412, 4413, + 5, 86, 0, 0, 4413, 4414, 5, 69, 0, 0, 4414, 816, 1, 0, 0, 0, 4415, 4416, + 5, 82, 0, 0, 4416, 4417, 5, 69, 0, 0, 4417, 4418, 5, 83, 0, 0, 4418, 4419, + 5, 85, 0, 0, 4419, 4420, 5, 77, 0, 0, 4420, 4421, 5, 69, 0, 0, 4421, 818, + 1, 0, 0, 0, 4422, 4423, 5, 82, 0, 0, 4423, 4424, 5, 69, 0, 0, 4424, 4425, + 5, 84, 0, 0, 4425, 4426, 5, 65, 0, 0, 4426, 4427, 5, 73, 0, 0, 4427, 4428, + 5, 78, 0, 0, 4428, 820, 1, 0, 0, 0, 4429, 4430, 5, 82, 0, 0, 4430, 4431, + 5, 69, 0, 0, 4431, 4432, 5, 84, 0, 0, 4432, 4433, 5, 69, 0, 0, 4433, 4434, + 5, 78, 0, 0, 4434, 4435, 5, 84, 0, 0, 4435, 4436, 5, 73, 0, 0, 4436, 4437, + 5, 79, 0, 0, 4437, 4438, 5, 78, 0, 0, 4438, 822, 1, 0, 0, 0, 4439, 4440, + 5, 82, 0, 0, 4440, 4441, 5, 69, 0, 0, 4441, 4442, 5, 84, 0, 0, 4442, 4443, + 5, 85, 0, 0, 4443, 4444, 5, 82, 0, 0, 4444, 4445, 5, 78, 0, 0, 4445, 4446, + 5, 83, 0, 0, 4446, 824, 1, 0, 0, 0, 4447, 4448, 5, 82, 0, 0, 4448, 4449, + 5, 69, 0, 0, 4449, 4450, 5, 86, 0, 0, 4450, 4451, 5, 79, 0, 0, 4451, 4452, + 5, 75, 0, 0, 4452, 4453, 5, 69, 0, 0, 4453, 826, 1, 0, 0, 0, 4454, 4455, + 5, 82, 0, 0, 4455, 4456, 5, 69, 0, 0, 4456, 4457, 5, 87, 0, 0, 4457, 4458, + 5, 82, 0, 0, 4458, 4459, 5, 73, 0, 0, 4459, 4460, 5, 84, 0, 0, 4460, 4461, + 5, 84, 0, 0, 4461, 4462, 5, 69, 0, 0, 4462, 4463, 5, 78, 0, 0, 4463, 828, + 1, 0, 0, 0, 4464, 4465, 5, 82, 0, 0, 4465, 4466, 5, 73, 0, 0, 4466, 4467, + 5, 71, 0, 0, 4467, 4468, 5, 72, 0, 0, 4468, 4469, 5, 84, 0, 0, 4469, 830, + 1, 0, 0, 0, 4470, 4471, 5, 82, 0, 0, 4471, 4472, 5, 76, 0, 0, 4472, 4473, + 5, 73, 0, 0, 4473, 4474, 5, 75, 0, 0, 4474, 4475, 5, 69, 0, 0, 4475, 832, + 1, 0, 0, 0, 4476, 4477, 5, 82, 0, 0, 4477, 4478, 5, 79, 0, 0, 4478, 4479, + 5, 76, 0, 0, 4479, 4480, 5, 69, 0, 0, 4480, 834, 1, 0, 0, 0, 4481, 4482, + 5, 82, 0, 0, 4482, 4483, 5, 79, 0, 0, 4483, 4484, 5, 76, 0, 0, 4484, 4485, + 5, 69, 0, 0, 4485, 4486, 5, 83, 0, 0, 4486, 836, 1, 0, 0, 0, 4487, 4488, + 5, 82, 0, 0, 4488, 4489, 5, 79, 0, 0, 4489, 4490, 5, 76, 0, 0, 4490, 4491, + 5, 76, 0, 0, 4491, 4492, 5, 66, 0, 0, 4492, 4493, 5, 65, 0, 0, 4493, 4494, + 5, 67, 0, 0, 4494, 4495, 5, 75, 0, 0, 4495, 838, 1, 0, 0, 0, 4496, 4497, + 5, 82, 0, 0, 4497, 4498, 5, 79, 0, 0, 4498, 4499, 5, 76, 0, 0, 4499, 4500, + 5, 76, 0, 0, 4500, 4501, 5, 85, 0, 0, 4501, 4502, 5, 80, 0, 0, 4502, 840, + 1, 0, 0, 0, 4503, 4504, 5, 82, 0, 0, 4504, 4505, 5, 79, 0, 0, 4505, 4506, + 5, 79, 0, 0, 4506, 4507, 5, 84, 0, 0, 4507, 842, 1, 0, 0, 0, 4508, 4509, + 5, 82, 0, 0, 4509, 4510, 5, 79, 0, 0, 4510, 4511, 5, 84, 0, 0, 4511, 4512, + 5, 65, 0, 0, 4512, 4513, 5, 84, 0, 0, 4513, 4514, 5, 69, 0, 0, 4514, 844, + 1, 0, 0, 0, 4515, 4516, 5, 82, 0, 0, 4516, 4517, 5, 79, 0, 0, 4517, 4518, + 5, 85, 0, 0, 4518, 4519, 5, 84, 0, 0, 4519, 4520, 5, 73, 0, 0, 4520, 4521, + 5, 78, 0, 0, 4521, 4522, 5, 69, 0, 0, 4522, 846, 1, 0, 0, 0, 4523, 4524, + 5, 82, 0, 0, 4524, 4525, 5, 79, 0, 0, 4525, 4526, 5, 87, 0, 0, 4526, 848, + 1, 0, 0, 0, 4527, 4528, 5, 82, 0, 0, 4528, 4529, 5, 79, 0, 0, 4529, 4530, + 5, 87, 0, 0, 4530, 4531, 5, 83, 0, 0, 4531, 850, 1, 0, 0, 0, 4532, 4533, + 5, 83, 0, 0, 4533, 4534, 5, 51, 0, 0, 4534, 852, 1, 0, 0, 0, 4535, 4536, + 5, 83, 0, 0, 4536, 4537, 5, 65, 0, 0, 4537, 4538, 5, 77, 0, 0, 4538, 4539, + 5, 80, 0, 0, 4539, 4540, 5, 76, 0, 0, 4540, 4541, 5, 69, 0, 0, 4541, 854, + 1, 0, 0, 0, 4542, 4543, 5, 83, 0, 0, 4543, 4544, 5, 67, 0, 0, 4544, 4545, + 5, 72, 0, 0, 4545, 4546, 5, 69, 0, 0, 4546, 4547, 5, 68, 0, 0, 4547, 4548, + 5, 85, 0, 0, 4548, 4549, 5, 76, 0, 0, 4549, 4550, 5, 69, 0, 0, 4550, 856, + 1, 0, 0, 0, 4551, 4552, 5, 83, 0, 0, 4552, 4553, 5, 67, 0, 0, 4553, 4554, + 5, 72, 0, 0, 4554, 4555, 5, 69, 0, 0, 4555, 4556, 5, 68, 0, 0, 4556, 4557, + 5, 85, 0, 0, 4557, 4558, 5, 76, 0, 0, 4558, 4559, 5, 69, 0, 0, 4559, 4560, + 5, 82, 0, 0, 4560, 858, 1, 0, 0, 0, 4561, 4562, 5, 83, 0, 0, 4562, 4563, + 5, 67, 0, 0, 4563, 4564, 5, 72, 0, 0, 4564, 4565, 5, 69, 0, 0, 4565, 4566, + 5, 77, 0, 0, 4566, 4567, 5, 65, 0, 0, 4567, 860, 1, 0, 0, 0, 4568, 4569, + 5, 83, 0, 0, 4569, 4570, 5, 67, 0, 0, 4570, 4571, 5, 72, 0, 0, 4571, 4572, + 5, 69, 0, 0, 4572, 4573, 5, 77, 0, 0, 4573, 4574, 5, 65, 0, 0, 4574, 4575, + 5, 83, 0, 0, 4575, 862, 1, 0, 0, 0, 4576, 4577, 5, 83, 0, 0, 4577, 4578, + 5, 69, 0, 0, 4578, 4579, 5, 67, 0, 0, 4579, 4580, 5, 79, 0, 0, 4580, 4581, + 5, 78, 0, 0, 4581, 4582, 5, 68, 0, 0, 4582, 864, 1, 0, 0, 0, 4583, 4584, + 5, 83, 0, 0, 4584, 4585, 5, 69, 0, 0, 4585, 4586, 5, 76, 0, 0, 4586, 4587, + 5, 69, 0, 0, 4587, 4588, 5, 67, 0, 0, 4588, 4589, 5, 84, 0, 0, 4589, 866, + 1, 0, 0, 0, 4590, 4591, 5, 83, 0, 0, 4591, 4592, 5, 69, 0, 0, 4592, 4593, + 5, 77, 0, 0, 4593, 4594, 5, 73, 0, 0, 4594, 868, 1, 0, 0, 0, 4595, 4596, + 5, 83, 0, 0, 4596, 4597, 5, 69, 0, 0, 4597, 4598, 5, 80, 0, 0, 4598, 4599, + 5, 65, 0, 0, 4599, 4600, 5, 82, 0, 0, 4600, 4601, 5, 65, 0, 0, 4601, 4602, + 5, 84, 0, 0, 4602, 4603, 5, 79, 0, 0, 4603, 4604, 5, 82, 0, 0, 4604, 870, + 1, 0, 0, 0, 4605, 4606, 5, 83, 0, 0, 4606, 4607, 5, 69, 0, 0, 4607, 4608, + 5, 82, 0, 0, 4608, 4609, 5, 73, 0, 0, 4609, 4610, 5, 65, 0, 0, 4610, 4611, + 5, 76, 0, 0, 4611, 4612, 5, 73, 0, 0, 4612, 4613, 5, 90, 0, 0, 4613, 4614, + 5, 65, 0, 0, 4614, 4615, 5, 66, 0, 0, 4615, 4616, 5, 76, 0, 0, 4616, 4617, + 5, 69, 0, 0, 4617, 872, 1, 0, 0, 0, 4618, 4619, 5, 83, 0, 0, 4619, 4620, + 5, 69, 0, 0, 4620, 4621, 5, 83, 0, 0, 4621, 4622, 5, 83, 0, 0, 4622, 4623, + 5, 73, 0, 0, 4623, 4624, 5, 79, 0, 0, 4624, 4625, 5, 78, 0, 0, 4625, 874, + 1, 0, 0, 0, 4626, 4627, 5, 83, 0, 0, 4627, 4628, 5, 69, 0, 0, 4628, 4629, + 5, 83, 0, 0, 4629, 4630, 5, 83, 0, 0, 4630, 4631, 5, 73, 0, 0, 4631, 4632, + 5, 79, 0, 0, 4632, 4633, 5, 78, 0, 0, 4633, 4634, 5, 95, 0, 0, 4634, 4635, + 5, 85, 0, 0, 4635, 4636, 5, 83, 0, 0, 4636, 4637, 5, 69, 0, 0, 4637, 4638, + 5, 82, 0, 0, 4638, 876, 1, 0, 0, 0, 4639, 4640, 5, 83, 0, 0, 4640, 4641, + 5, 69, 0, 0, 4641, 4642, 5, 84, 0, 0, 4642, 878, 1, 0, 0, 0, 4643, 4644, + 5, 83, 0, 0, 4644, 4645, 5, 69, 0, 0, 4645, 4646, 5, 84, 0, 0, 4646, 4647, + 5, 83, 0, 0, 4647, 880, 1, 0, 0, 0, 4648, 4649, 5, 83, 0, 0, 4649, 4650, + 5, 69, 0, 0, 4650, 4651, 5, 84, 0, 0, 4651, 4652, 5, 95, 0, 0, 4652, 4653, + 5, 83, 0, 0, 4653, 4654, 5, 69, 0, 0, 4654, 4655, 5, 83, 0, 0, 4655, 4656, + 5, 83, 0, 0, 4656, 4657, 5, 73, 0, 0, 4657, 4658, 5, 79, 0, 0, 4658, 4659, + 5, 78, 0, 0, 4659, 4660, 5, 95, 0, 0, 4660, 4661, 5, 86, 0, 0, 4661, 4662, + 5, 65, 0, 0, 4662, 4663, 5, 82, 0, 0, 4663, 4664, 5, 73, 0, 0, 4664, 4665, + 5, 65, 0, 0, 4665, 4666, 5, 66, 0, 0, 4666, 4667, 5, 76, 0, 0, 4667, 4668, + 5, 69, 0, 0, 4668, 882, 1, 0, 0, 0, 4669, 4670, 5, 83, 0, 0, 4670, 4671, + 5, 72, 0, 0, 4671, 4672, 5, 65, 0, 0, 4672, 4673, 5, 80, 0, 0, 4673, 4674, + 5, 69, 0, 0, 4674, 884, 1, 0, 0, 0, 4675, 4676, 5, 83, 0, 0, 4676, 4677, + 5, 72, 0, 0, 4677, 4678, 5, 79, 0, 0, 4678, 4679, 5, 87, 0, 0, 4679, 886, + 1, 0, 0, 0, 4680, 4681, 5, 83, 0, 0, 4681, 4682, 5, 73, 0, 0, 4682, 4683, + 5, 71, 0, 0, 4683, 4684, 5, 78, 0, 0, 4684, 4685, 5, 69, 0, 0, 4685, 4686, + 5, 68, 0, 0, 4686, 888, 1, 0, 0, 0, 4687, 4688, 5, 83, 0, 0, 4688, 4689, + 5, 75, 0, 0, 4689, 4690, 5, 69, 0, 0, 4690, 4691, 5, 87, 0, 0, 4691, 890, + 1, 0, 0, 0, 4692, 4693, 5, 83, 0, 0, 4693, 4694, 5, 77, 0, 0, 4694, 4695, + 5, 65, 0, 0, 4695, 4696, 5, 76, 0, 0, 4696, 4697, 5, 76, 0, 0, 4697, 4698, + 5, 73, 0, 0, 4698, 4699, 5, 78, 0, 0, 4699, 4700, 5, 84, 0, 0, 4700, 892, + 1, 0, 0, 0, 4701, 4702, 5, 83, 0, 0, 4702, 4703, 5, 78, 0, 0, 4703, 4704, + 5, 65, 0, 0, 4704, 4705, 5, 80, 0, 0, 4705, 4706, 5, 83, 0, 0, 4706, 4707, + 5, 72, 0, 0, 4707, 4708, 5, 79, 0, 0, 4708, 4709, 5, 84, 0, 0, 4709, 894, + 1, 0, 0, 0, 4710, 4711, 5, 83, 0, 0, 4711, 4712, 5, 78, 0, 0, 4712, 4713, + 5, 65, 0, 0, 4713, 4714, 5, 80, 0, 0, 4714, 4715, 5, 83, 0, 0, 4715, 4716, + 5, 72, 0, 0, 4716, 4717, 5, 79, 0, 0, 4717, 4718, 5, 84, 0, 0, 4718, 4719, + 5, 83, 0, 0, 4719, 896, 1, 0, 0, 0, 4720, 4721, 5, 83, 0, 0, 4721, 4722, + 5, 79, 0, 0, 4722, 4723, 5, 78, 0, 0, 4723, 4724, 5, 65, 0, 0, 4724, 4725, + 5, 77, 0, 0, 4725, 4726, 5, 69, 0, 0, 4726, 898, 1, 0, 0, 0, 4727, 4728, + 5, 83, 0, 0, 4728, 4729, 5, 80, 0, 0, 4729, 4730, 5, 76, 0, 0, 4730, 4731, + 5, 73, 0, 0, 4731, 4732, 5, 84, 0, 0, 4732, 900, 1, 0, 0, 0, 4733, 4734, + 5, 83, 0, 0, 4734, 4735, 5, 81, 0, 0, 4735, 4736, 5, 76, 0, 0, 4736, 902, + 1, 0, 0, 0, 4737, 4738, 5, 83, 0, 0, 4738, 4739, 5, 81, 0, 0, 4739, 4740, + 5, 76, 0, 0, 4740, 4741, 5, 95, 0, 0, 4741, 4742, 5, 66, 0, 0, 4742, 4743, + 5, 76, 0, 0, 4743, 4744, 5, 79, 0, 0, 4744, 4745, 5, 67, 0, 0, 4745, 4746, + 5, 75, 0, 0, 4746, 4747, 5, 95, 0, 0, 4747, 4748, 5, 82, 0, 0, 4748, 4749, + 5, 85, 0, 0, 4749, 4750, 5, 76, 0, 0, 4750, 4751, 5, 69, 0, 0, 4751, 904, + 1, 0, 0, 0, 4752, 4753, 5, 83, 0, 0, 4753, 4754, 5, 84, 0, 0, 4754, 4755, + 5, 65, 0, 0, 4755, 4756, 5, 71, 0, 0, 4756, 4757, 5, 69, 0, 0, 4757, 906, + 1, 0, 0, 0, 4758, 4759, 5, 83, 0, 0, 4759, 4760, 5, 84, 0, 0, 4760, 4761, + 5, 65, 0, 0, 4761, 4762, 5, 71, 0, 0, 4762, 4763, 5, 69, 0, 0, 4763, 4764, + 5, 83, 0, 0, 4764, 908, 1, 0, 0, 0, 4765, 4766, 5, 83, 0, 0, 4766, 4767, + 5, 84, 0, 0, 4767, 4768, 5, 65, 0, 0, 4768, 4769, 5, 82, 0, 0, 4769, 4770, + 5, 84, 0, 0, 4770, 910, 1, 0, 0, 0, 4771, 4772, 5, 83, 0, 0, 4772, 4773, + 5, 84, 0, 0, 4773, 4774, 5, 65, 0, 0, 4774, 4775, 5, 82, 0, 0, 4775, 4776, + 5, 84, 0, 0, 4776, 4777, 5, 83, 0, 0, 4777, 912, 1, 0, 0, 0, 4778, 4779, + 5, 83, 0, 0, 4779, 4780, 5, 84, 0, 0, 4780, 4781, 5, 65, 0, 0, 4781, 4782, + 5, 84, 0, 0, 4782, 4783, 5, 83, 0, 0, 4783, 914, 1, 0, 0, 0, 4784, 4785, + 5, 83, 0, 0, 4785, 4786, 5, 84, 0, 0, 4786, 4787, 5, 65, 0, 0, 4787, 4788, + 5, 84, 0, 0, 4788, 4789, 5, 85, 0, 0, 4789, 4790, 5, 83, 0, 0, 4790, 916, + 1, 0, 0, 0, 4791, 4792, 5, 83, 0, 0, 4792, 4793, 5, 84, 0, 0, 4793, 4794, + 5, 79, 0, 0, 4794, 4795, 5, 80, 0, 0, 4795, 918, 1, 0, 0, 0, 4796, 4797, + 5, 83, 0, 0, 4797, 4798, 5, 84, 0, 0, 4798, 4799, 5, 79, 0, 0, 4799, 4800, + 5, 82, 0, 0, 4800, 4801, 5, 65, 0, 0, 4801, 4802, 5, 71, 0, 0, 4802, 4803, + 5, 69, 0, 0, 4803, 920, 1, 0, 0, 0, 4804, 4805, 5, 83, 0, 0, 4805, 4806, + 5, 84, 0, 0, 4806, 4807, 5, 82, 0, 0, 4807, 4808, 5, 69, 0, 0, 4808, 4809, + 5, 65, 0, 0, 4809, 4810, 5, 77, 0, 0, 4810, 922, 1, 0, 0, 0, 4811, 4812, + 5, 83, 0, 0, 4812, 4813, 5, 84, 0, 0, 4813, 4814, 5, 82, 0, 0, 4814, 4815, + 5, 69, 0, 0, 4815, 4816, 5, 65, 0, 0, 4816, 4817, 5, 77, 0, 0, 4817, 4818, + 5, 73, 0, 0, 4818, 4819, 5, 78, 0, 0, 4819, 4820, 5, 71, 0, 0, 4820, 924, + 1, 0, 0, 0, 4821, 4822, 5, 83, 0, 0, 4822, 4823, 5, 84, 0, 0, 4823, 4824, + 5, 82, 0, 0, 4824, 4825, 5, 73, 0, 0, 4825, 4826, 5, 78, 0, 0, 4826, 4827, + 5, 71, 0, 0, 4827, 926, 1, 0, 0, 0, 4828, 4829, 5, 83, 0, 0, 4829, 4830, + 5, 84, 0, 0, 4830, 4831, 5, 82, 0, 0, 4831, 4832, 5, 85, 0, 0, 4832, 4833, + 5, 67, 0, 0, 4833, 4834, 5, 84, 0, 0, 4834, 928, 1, 0, 0, 0, 4835, 4836, + 5, 83, 0, 0, 4836, 4837, 5, 85, 0, 0, 4837, 4838, 5, 66, 0, 0, 4838, 4839, + 5, 83, 0, 0, 4839, 4840, 5, 84, 0, 0, 4840, 4841, 5, 82, 0, 0, 4841, 930, + 1, 0, 0, 0, 4842, 4843, 5, 83, 0, 0, 4843, 4844, 5, 85, 0, 0, 4844, 4845, + 5, 66, 0, 0, 4845, 4846, 5, 83, 0, 0, 4846, 4847, 5, 84, 0, 0, 4847, 4848, + 5, 82, 0, 0, 4848, 4849, 5, 73, 0, 0, 4849, 4850, 5, 78, 0, 0, 4850, 4851, + 5, 71, 0, 0, 4851, 932, 1, 0, 0, 0, 4852, 4853, 5, 83, 0, 0, 4853, 4854, + 5, 85, 0, 0, 4854, 4855, 5, 77, 0, 0, 4855, 934, 1, 0, 0, 0, 4856, 4857, + 5, 83, 0, 0, 4857, 4858, 5, 85, 0, 0, 4858, 4859, 5, 80, 0, 0, 4859, 4860, + 5, 69, 0, 0, 4860, 4861, 5, 82, 0, 0, 4861, 4862, 5, 85, 0, 0, 4862, 4863, + 5, 83, 0, 0, 4863, 4864, 5, 69, 0, 0, 4864, 4865, 5, 82, 0, 0, 4865, 936, + 1, 0, 0, 0, 4866, 4867, 5, 83, 0, 0, 4867, 4868, 5, 87, 0, 0, 4868, 4869, + 5, 73, 0, 0, 4869, 4870, 5, 84, 0, 0, 4870, 4871, 5, 67, 0, 0, 4871, 4872, + 5, 72, 0, 0, 4872, 938, 1, 0, 0, 0, 4873, 4874, 5, 83, 0, 0, 4874, 4875, + 5, 89, 0, 0, 4875, 4876, 5, 78, 0, 0, 4876, 4877, 5, 67, 0, 0, 4877, 940, + 1, 0, 0, 0, 4878, 4879, 5, 83, 0, 0, 4879, 4880, 5, 89, 0, 0, 4880, 4881, + 5, 83, 0, 0, 4881, 4882, 5, 84, 0, 0, 4882, 4883, 5, 69, 0, 0, 4883, 4884, + 5, 77, 0, 0, 4884, 942, 1, 0, 0, 0, 4885, 4886, 5, 84, 0, 0, 4886, 4887, + 5, 65, 0, 0, 4887, 4888, 5, 66, 0, 0, 4888, 4889, 5, 76, 0, 0, 4889, 4890, + 5, 69, 0, 0, 4890, 944, 1, 0, 0, 0, 4891, 4892, 5, 84, 0, 0, 4892, 4893, + 5, 65, 0, 0, 4893, 4894, 5, 66, 0, 0, 4894, 4895, 5, 76, 0, 0, 4895, 4896, + 5, 69, 0, 0, 4896, 4897, 5, 83, 0, 0, 4897, 946, 1, 0, 0, 0, 4898, 4899, + 5, 84, 0, 0, 4899, 4900, 5, 65, 0, 0, 4900, 4901, 5, 66, 0, 0, 4901, 4902, + 5, 76, 0, 0, 4902, 4903, 5, 69, 0, 0, 4903, 4904, 5, 83, 0, 0, 4904, 4905, + 5, 65, 0, 0, 4905, 4906, 5, 77, 0, 0, 4906, 4907, 5, 80, 0, 0, 4907, 4908, + 5, 76, 0, 0, 4908, 4909, 5, 69, 0, 0, 4909, 948, 1, 0, 0, 0, 4910, 4911, + 5, 84, 0, 0, 4911, 4912, 5, 65, 0, 0, 4912, 4913, 5, 66, 0, 0, 4913, 4914, + 5, 76, 0, 0, 4914, 4915, 5, 69, 0, 0, 4915, 4916, 5, 84, 0, 0, 4916, 950, + 1, 0, 0, 0, 4917, 4918, 5, 84, 0, 0, 4918, 4919, 5, 65, 0, 0, 4919, 4920, + 5, 66, 0, 0, 4920, 4921, 5, 76, 0, 0, 4921, 4922, 5, 69, 0, 0, 4922, 4923, + 5, 84, 0, 0, 4923, 4924, 5, 83, 0, 0, 4924, 952, 1, 0, 0, 0, 4925, 4926, + 5, 84, 0, 0, 4926, 4927, 5, 65, 0, 0, 4927, 4928, 5, 71, 0, 0, 4928, 954, + 1, 0, 0, 0, 4929, 4930, 5, 84, 0, 0, 4930, 4931, 5, 65, 0, 0, 4931, 4932, + 5, 83, 0, 0, 4932, 4933, 5, 75, 0, 0, 4933, 956, 1, 0, 0, 0, 4934, 4935, + 5, 84, 0, 0, 4935, 4936, 5, 65, 0, 0, 4936, 4937, 5, 83, 0, 0, 4937, 4938, + 5, 75, 0, 0, 4938, 4939, 5, 83, 0, 0, 4939, 958, 1, 0, 0, 0, 4940, 4941, + 5, 84, 0, 0, 4941, 4942, 5, 68, 0, 0, 4942, 4943, 5, 69, 0, 0, 4943, 960, + 1, 0, 0, 0, 4944, 4945, 5, 84, 0, 0, 4945, 4946, 5, 69, 0, 0, 4946, 4947, + 5, 77, 0, 0, 4947, 4948, 5, 80, 0, 0, 4948, 4949, 5, 79, 0, 0, 4949, 4950, + 5, 82, 0, 0, 4950, 4951, 5, 65, 0, 0, 4951, 4952, 5, 82, 0, 0, 4952, 4953, + 5, 89, 0, 0, 4953, 962, 1, 0, 0, 0, 4954, 4955, 5, 84, 0, 0, 4955, 4956, + 5, 69, 0, 0, 4956, 4957, 5, 82, 0, 0, 4957, 4958, 5, 77, 0, 0, 4958, 4959, + 5, 73, 0, 0, 4959, 4960, 5, 78, 0, 0, 4960, 4961, 5, 65, 0, 0, 4961, 4962, + 5, 84, 0, 0, 4962, 4963, 5, 69, 0, 0, 4963, 4964, 5, 68, 0, 0, 4964, 964, + 1, 0, 0, 0, 4965, 4966, 5, 84, 0, 0, 4966, 4967, 5, 69, 0, 0, 4967, 4968, + 5, 88, 0, 0, 4968, 4969, 5, 84, 0, 0, 4969, 966, 1, 0, 0, 0, 4970, 4971, + 5, 84, 0, 0, 4971, 4972, 5, 72, 0, 0, 4972, 4973, 5, 65, 0, 0, 4973, 4974, + 5, 78, 0, 0, 4974, 968, 1, 0, 0, 0, 4975, 4976, 5, 84, 0, 0, 4976, 4977, + 5, 72, 0, 0, 4977, 4978, 5, 69, 0, 0, 4978, 4979, 5, 78, 0, 0, 4979, 970, + 1, 0, 0, 0, 4980, 4981, 5, 84, 0, 0, 4981, 4982, 5, 73, 0, 0, 4982, 4983, + 5, 77, 0, 0, 4983, 4984, 5, 69, 0, 0, 4984, 972, 1, 0, 0, 0, 4985, 4986, + 5, 84, 0, 0, 4986, 4987, 5, 73, 0, 0, 4987, 4988, 5, 77, 0, 0, 4988, 4989, + 5, 69, 0, 0, 4989, 4990, 5, 83, 0, 0, 4990, 4991, 5, 84, 0, 0, 4991, 4992, + 5, 65, 0, 0, 4992, 4993, 5, 77, 0, 0, 4993, 4994, 5, 80, 0, 0, 4994, 974, + 1, 0, 0, 0, 4995, 4996, 5, 84, 0, 0, 4996, 4997, 5, 73, 0, 0, 4997, 4998, + 5, 78, 0, 0, 4998, 4999, 5, 89, 0, 0, 4999, 5000, 5, 73, 0, 0, 5000, 5001, + 5, 78, 0, 0, 5001, 5002, 5, 84, 0, 0, 5002, 976, 1, 0, 0, 0, 5003, 5004, + 5, 84, 0, 0, 5004, 5005, 5, 79, 0, 0, 5005, 978, 1, 0, 0, 0, 5006, 5007, + 5, 84, 0, 0, 5007, 5008, 5, 79, 0, 0, 5008, 5009, 5, 75, 0, 0, 5009, 5010, + 5, 69, 0, 0, 5010, 5011, 5, 78, 0, 0, 5011, 5012, 5, 73, 0, 0, 5012, 5013, + 5, 90, 0, 0, 5013, 5014, 5, 69, 0, 0, 5014, 5015, 5, 82, 0, 0, 5015, 980, + 1, 0, 0, 0, 5016, 5017, 5, 84, 0, 0, 5017, 5018, 5, 79, 0, 0, 5018, 5019, + 5, 75, 0, 0, 5019, 5020, 5, 69, 0, 0, 5020, 5021, 5, 78, 0, 0, 5021, 5022, + 5, 95, 0, 0, 5022, 5023, 5, 70, 0, 0, 5023, 5024, 5, 73, 0, 0, 5024, 5025, + 5, 76, 0, 0, 5025, 5026, 5, 84, 0, 0, 5026, 5027, 5, 69, 0, 0, 5027, 5028, + 5, 82, 0, 0, 5028, 982, 1, 0, 0, 0, 5029, 5030, 5, 84, 0, 0, 5030, 5031, + 5, 82, 0, 0, 5031, 5032, 5, 65, 0, 0, 5032, 5033, 5, 73, 0, 0, 5033, 5034, + 5, 76, 0, 0, 5034, 5035, 5, 73, 0, 0, 5035, 5036, 5, 78, 0, 0, 5036, 5037, + 5, 71, 0, 0, 5037, 984, 1, 0, 0, 0, 5038, 5039, 5, 84, 0, 0, 5039, 5040, + 5, 82, 0, 0, 5040, 5041, 5, 65, 0, 0, 5041, 5042, 5, 78, 0, 0, 5042, 5043, + 5, 83, 0, 0, 5043, 5044, 5, 65, 0, 0, 5044, 5045, 5, 67, 0, 0, 5045, 5046, + 5, 84, 0, 0, 5046, 5047, 5, 73, 0, 0, 5047, 5048, 5, 79, 0, 0, 5048, 5049, + 5, 78, 0, 0, 5049, 986, 1, 0, 0, 0, 5050, 5051, 5, 84, 0, 0, 5051, 5052, + 5, 82, 0, 0, 5052, 5053, 5, 65, 0, 0, 5053, 5054, 5, 83, 0, 0, 5054, 5055, + 5, 72, 0, 0, 5055, 988, 1, 0, 0, 0, 5056, 5057, 5, 84, 0, 0, 5057, 5058, + 5, 82, 0, 0, 5058, 5059, 5, 69, 0, 0, 5059, 5060, 5, 69, 0, 0, 5060, 990, + 1, 0, 0, 0, 5061, 5062, 5, 84, 0, 0, 5062, 5063, 5, 82, 0, 0, 5063, 5064, + 5, 73, 0, 0, 5064, 5065, 5, 71, 0, 0, 5065, 5066, 5, 71, 0, 0, 5066, 5067, + 5, 69, 0, 0, 5067, 5068, 5, 82, 0, 0, 5068, 5069, 5, 83, 0, 0, 5069, 992, + 1, 0, 0, 0, 5070, 5071, 5, 84, 0, 0, 5071, 5072, 5, 82, 0, 0, 5072, 5073, + 5, 73, 0, 0, 5073, 5074, 5, 77, 0, 0, 5074, 994, 1, 0, 0, 0, 5075, 5076, + 5, 84, 0, 0, 5076, 5077, 5, 82, 0, 0, 5077, 5078, 5, 85, 0, 0, 5078, 5079, + 5, 69, 0, 0, 5079, 996, 1, 0, 0, 0, 5080, 5081, 5, 84, 0, 0, 5081, 5082, + 5, 82, 0, 0, 5082, 5083, 5, 85, 0, 0, 5083, 5084, 5, 78, 0, 0, 5084, 5085, + 5, 67, 0, 0, 5085, 5086, 5, 65, 0, 0, 5086, 5087, 5, 84, 0, 0, 5087, 5088, + 5, 69, 0, 0, 5088, 998, 1, 0, 0, 0, 5089, 5090, 5, 84, 0, 0, 5090, 5091, + 5, 82, 0, 0, 5091, 5092, 5, 89, 0, 0, 5092, 5093, 5, 95, 0, 0, 5093, 5094, + 5, 67, 0, 0, 5094, 5095, 5, 65, 0, 0, 5095, 5096, 5, 83, 0, 0, 5096, 5097, + 5, 84, 0, 0, 5097, 1000, 1, 0, 0, 0, 5098, 5099, 5, 84, 0, 0, 5099, 5100, + 5, 89, 0, 0, 5100, 5101, 5, 80, 0, 0, 5101, 5102, 5, 69, 0, 0, 5102, 1002, + 1, 0, 0, 0, 5103, 5104, 5, 84, 0, 0, 5104, 5105, 5, 89, 0, 0, 5105, 5106, + 5, 80, 0, 0, 5106, 5107, 5, 69, 0, 0, 5107, 5108, 5, 95, 0, 0, 5108, 5109, + 5, 67, 0, 0, 5109, 5110, 5, 65, 0, 0, 5110, 5111, 5, 83, 0, 0, 5111, 5112, + 5, 84, 0, 0, 5112, 1004, 1, 0, 0, 0, 5113, 5114, 5, 84, 0, 0, 5114, 5115, + 5, 89, 0, 0, 5115, 5116, 5, 80, 0, 0, 5116, 5117, 5, 69, 0, 0, 5117, 5118, + 5, 83, 0, 0, 5118, 1006, 1, 0, 0, 0, 5119, 5120, 5, 85, 0, 0, 5120, 5121, + 5, 78, 0, 0, 5121, 5122, 5, 66, 0, 0, 5122, 5123, 5, 79, 0, 0, 5123, 5124, + 5, 85, 0, 0, 5124, 5125, 5, 78, 0, 0, 5125, 5126, 5, 68, 0, 0, 5126, 5127, + 5, 69, 0, 0, 5127, 5128, 5, 68, 0, 0, 5128, 1008, 1, 0, 0, 0, 5129, 5130, + 5, 85, 0, 0, 5130, 5131, 5, 78, 0, 0, 5131, 5132, 5, 67, 0, 0, 5132, 5133, + 5, 79, 0, 0, 5133, 5134, 5, 77, 0, 0, 5134, 5135, 5, 77, 0, 0, 5135, 5136, + 5, 73, 0, 0, 5136, 5137, 5, 84, 0, 0, 5137, 5138, 5, 84, 0, 0, 5138, 5139, + 5, 69, 0, 0, 5139, 5140, 5, 68, 0, 0, 5140, 1010, 1, 0, 0, 0, 5141, 5142, + 5, 85, 0, 0, 5142, 5143, 5, 78, 0, 0, 5143, 5144, 5, 73, 0, 0, 5144, 5145, + 5, 78, 0, 0, 5145, 5146, 5, 83, 0, 0, 5146, 5147, 5, 84, 0, 0, 5147, 5148, + 5, 65, 0, 0, 5148, 5149, 5, 76, 0, 0, 5149, 5150, 5, 76, 0, 0, 5150, 1012, + 1, 0, 0, 0, 5151, 5152, 5, 85, 0, 0, 5152, 5153, 5, 78, 0, 0, 5153, 5154, + 5, 73, 0, 0, 5154, 5155, 5, 79, 0, 0, 5155, 5156, 5, 78, 0, 0, 5156, 1014, + 1, 0, 0, 0, 5157, 5158, 5, 85, 0, 0, 5158, 5159, 5, 78, 0, 0, 5159, 5160, + 5, 73, 0, 0, 5160, 5161, 5, 81, 0, 0, 5161, 5162, 5, 85, 0, 0, 5162, 5163, + 5, 69, 0, 0, 5163, 1016, 1, 0, 0, 0, 5164, 5165, 5, 85, 0, 0, 5165, 5166, + 5, 78, 0, 0, 5166, 5167, 5, 76, 0, 0, 5167, 5168, 5, 79, 0, 0, 5168, 5169, + 5, 67, 0, 0, 5169, 5170, 5, 75, 0, 0, 5170, 1018, 1, 0, 0, 0, 5171, 5172, + 5, 85, 0, 0, 5172, 5173, 5, 78, 0, 0, 5173, 5174, 5, 83, 0, 0, 5174, 5175, + 5, 69, 0, 0, 5175, 5176, 5, 84, 0, 0, 5176, 1020, 1, 0, 0, 0, 5177, 5178, + 5, 85, 0, 0, 5178, 5179, 5, 78, 0, 0, 5179, 5180, 5, 83, 0, 0, 5180, 5181, + 5, 73, 0, 0, 5181, 5182, 5, 71, 0, 0, 5182, 5183, 5, 78, 0, 0, 5183, 5184, + 5, 69, 0, 0, 5184, 5185, 5, 68, 0, 0, 5185, 1022, 1, 0, 0, 0, 5186, 5187, + 5, 85, 0, 0, 5187, 5188, 5, 80, 0, 0, 5188, 1024, 1, 0, 0, 0, 5189, 5190, + 5, 85, 0, 0, 5190, 5191, 5, 80, 0, 0, 5191, 5192, 5, 68, 0, 0, 5192, 5193, + 5, 65, 0, 0, 5193, 5194, 5, 84, 0, 0, 5194, 5195, 5, 69, 0, 0, 5195, 1026, + 1, 0, 0, 0, 5196, 5197, 5, 85, 0, 0, 5197, 5198, 5, 83, 0, 0, 5198, 5199, + 5, 69, 0, 0, 5199, 1028, 1, 0, 0, 0, 5200, 5201, 5, 85, 0, 0, 5201, 5202, + 5, 83, 0, 0, 5202, 5203, 5, 69, 0, 0, 5203, 5204, 5, 82, 0, 0, 5204, 1030, + 1, 0, 0, 0, 5205, 5206, 5, 85, 0, 0, 5206, 5207, 5, 83, 0, 0, 5207, 5208, + 5, 69, 0, 0, 5208, 5209, 5, 95, 0, 0, 5209, 5210, 5, 77, 0, 0, 5210, 5211, + 5, 86, 0, 0, 5211, 1032, 1, 0, 0, 0, 5212, 5213, 5, 85, 0, 0, 5213, 5214, + 5, 83, 0, 0, 5214, 5215, 5, 73, 0, 0, 5215, 5216, 5, 78, 0, 0, 5216, 5217, + 5, 71, 0, 0, 5217, 1034, 1, 0, 0, 0, 5218, 5219, 5, 86, 0, 0, 5219, 5220, + 5, 65, 0, 0, 5220, 5221, 5, 76, 0, 0, 5221, 5222, 5, 85, 0, 0, 5222, 5223, + 5, 69, 0, 0, 5223, 1036, 1, 0, 0, 0, 5224, 5225, 5, 86, 0, 0, 5225, 5226, + 5, 65, 0, 0, 5226, 5227, 5, 76, 0, 0, 5227, 5228, 5, 85, 0, 0, 5228, 5229, + 5, 69, 0, 0, 5229, 5230, 5, 83, 0, 0, 5230, 1038, 1, 0, 0, 0, 5231, 5232, + 5, 86, 0, 0, 5232, 5233, 5, 65, 0, 0, 5233, 5234, 5, 82, 0, 0, 5234, 5235, + 5, 66, 0, 0, 5235, 5236, 5, 73, 0, 0, 5236, 5237, 5, 78, 0, 0, 5237, 5238, + 5, 65, 0, 0, 5238, 5239, 5, 82, 0, 0, 5239, 5240, 5, 89, 0, 0, 5240, 1040, + 1, 0, 0, 0, 5241, 5242, 5, 86, 0, 0, 5242, 5243, 5, 65, 0, 0, 5243, 5244, + 5, 82, 0, 0, 5244, 5245, 5, 67, 0, 0, 5245, 5246, 5, 72, 0, 0, 5246, 5247, + 5, 65, 0, 0, 5247, 5248, 5, 82, 0, 0, 5248, 1042, 1, 0, 0, 0, 5249, 5250, + 5, 86, 0, 0, 5250, 5251, 5, 65, 0, 0, 5251, 5252, 5, 82, 0, 0, 5252, 5253, + 5, 73, 0, 0, 5253, 5254, 5, 65, 0, 0, 5254, 5255, 5, 66, 0, 0, 5255, 5256, + 5, 76, 0, 0, 5256, 5257, 5, 69, 0, 0, 5257, 1044, 1, 0, 0, 0, 5258, 5259, + 5, 86, 0, 0, 5259, 5260, 5, 65, 0, 0, 5260, 5261, 5, 82, 0, 0, 5261, 5262, + 5, 73, 0, 0, 5262, 5263, 5, 65, 0, 0, 5263, 5264, 5, 66, 0, 0, 5264, 5265, + 5, 76, 0, 0, 5265, 5266, 5, 69, 0, 0, 5266, 5267, 5, 83, 0, 0, 5267, 1046, + 1, 0, 0, 0, 5268, 5269, 5, 86, 0, 0, 5269, 5270, 5, 65, 0, 0, 5270, 5271, + 5, 82, 0, 0, 5271, 5272, 5, 73, 0, 0, 5272, 5273, 5, 65, 0, 0, 5273, 5274, + 5, 78, 0, 0, 5274, 5275, 5, 84, 0, 0, 5275, 1048, 1, 0, 0, 0, 5276, 5277, + 5, 86, 0, 0, 5277, 5278, 5, 65, 0, 0, 5278, 5279, 5, 85, 0, 0, 5279, 5280, + 5, 76, 0, 0, 5280, 5281, 5, 84, 0, 0, 5281, 1050, 1, 0, 0, 0, 5282, 5283, + 5, 86, 0, 0, 5283, 5284, 5, 65, 0, 0, 5284, 5285, 5, 85, 0, 0, 5285, 5286, + 5, 76, 0, 0, 5286, 5287, 5, 84, 0, 0, 5287, 5288, 5, 83, 0, 0, 5288, 1052, + 1, 0, 0, 0, 5289, 5290, 5, 86, 0, 0, 5290, 5291, 5, 69, 0, 0, 5291, 5292, + 5, 82, 0, 0, 5292, 5293, 5, 66, 0, 0, 5293, 5294, 5, 79, 0, 0, 5294, 5295, + 5, 83, 0, 0, 5295, 5296, 5, 69, 0, 0, 5296, 1054, 1, 0, 0, 0, 5297, 5298, + 5, 86, 0, 0, 5298, 5299, 5, 69, 0, 0, 5299, 5300, 5, 82, 0, 0, 5300, 5301, + 5, 83, 0, 0, 5301, 5302, 5, 73, 0, 0, 5302, 5303, 5, 79, 0, 0, 5303, 5304, + 5, 78, 0, 0, 5304, 1056, 1, 0, 0, 0, 5305, 5306, 5, 86, 0, 0, 5306, 5307, + 5, 73, 0, 0, 5307, 5308, 5, 69, 0, 0, 5308, 5309, 5, 87, 0, 0, 5309, 1058, + 1, 0, 0, 0, 5310, 5311, 5, 86, 0, 0, 5311, 5312, 5, 73, 0, 0, 5312, 5313, + 5, 69, 0, 0, 5313, 5314, 5, 87, 0, 0, 5314, 5315, 5, 83, 0, 0, 5315, 1060, + 1, 0, 0, 0, 5316, 5317, 5, 87, 0, 0, 5317, 5318, 5, 65, 0, 0, 5318, 5319, + 5, 82, 0, 0, 5319, 5320, 5, 77, 0, 0, 5320, 1062, 1, 0, 0, 0, 5321, 5322, + 5, 87, 0, 0, 5322, 5323, 5, 65, 0, 0, 5323, 5324, 5, 82, 0, 0, 5324, 5325, + 5, 78, 0, 0, 5325, 5326, 5, 73, 0, 0, 5326, 5327, 5, 78, 0, 0, 5327, 5328, + 5, 71, 0, 0, 5328, 5329, 5, 83, 0, 0, 5329, 1064, 1, 0, 0, 0, 5330, 5331, + 5, 87, 0, 0, 5331, 5332, 5, 69, 0, 0, 5332, 5333, 5, 69, 0, 0, 5333, 5334, + 5, 75, 0, 0, 5334, 1066, 1, 0, 0, 0, 5335, 5336, 5, 87, 0, 0, 5336, 5337, + 5, 72, 0, 0, 5337, 5338, 5, 69, 0, 0, 5338, 5339, 5, 78, 0, 0, 5339, 1068, + 1, 0, 0, 0, 5340, 5341, 5, 87, 0, 0, 5341, 5342, 5, 72, 0, 0, 5342, 5343, + 5, 69, 0, 0, 5343, 5344, 5, 82, 0, 0, 5344, 5345, 5, 69, 0, 0, 5345, 1070, + 1, 0, 0, 0, 5346, 5347, 5, 87, 0, 0, 5347, 5348, 5, 72, 0, 0, 5348, 5349, + 5, 73, 0, 0, 5349, 5350, 5, 84, 0, 0, 5350, 5351, 5, 69, 0, 0, 5351, 5352, + 5, 76, 0, 0, 5352, 5353, 5, 73, 0, 0, 5353, 5354, 5, 83, 0, 0, 5354, 5355, + 5, 84, 0, 0, 5355, 1072, 1, 0, 0, 0, 5356, 5357, 5, 87, 0, 0, 5357, 5358, + 5, 73, 0, 0, 5358, 5359, 5, 84, 0, 0, 5359, 5360, 5, 72, 0, 0, 5360, 1074, + 1, 0, 0, 0, 5361, 5362, 5, 87, 0, 0, 5362, 5363, 5, 79, 0, 0, 5363, 5364, + 5, 82, 0, 0, 5364, 5365, 5, 75, 0, 0, 5365, 1076, 1, 0, 0, 0, 5366, 5367, + 5, 87, 0, 0, 5367, 5368, 5, 79, 0, 0, 5368, 5369, 5, 82, 0, 0, 5369, 5370, + 5, 75, 0, 0, 5370, 5371, 5, 76, 0, 0, 5371, 5372, 5, 79, 0, 0, 5372, 5373, + 5, 65, 0, 0, 5373, 5374, 5, 68, 0, 0, 5374, 1078, 1, 0, 0, 0, 5375, 5376, + 5, 87, 0, 0, 5376, 5377, 5, 82, 0, 0, 5377, 5378, 5, 73, 0, 0, 5378, 5379, + 5, 84, 0, 0, 5379, 5380, 5, 69, 0, 0, 5380, 1080, 1, 0, 0, 0, 5381, 5382, + 5, 88, 0, 0, 5382, 5383, 5, 79, 0, 0, 5383, 5384, 5, 82, 0, 0, 5384, 1082, + 1, 0, 0, 0, 5385, 5386, 5, 89, 0, 0, 5386, 5387, 5, 69, 0, 0, 5387, 5388, + 5, 65, 0, 0, 5388, 5389, 5, 82, 0, 0, 5389, 1084, 1, 0, 0, 0, 5390, 5394, + 5, 61, 0, 0, 5391, 5392, 5, 61, 0, 0, 5392, 5394, 5, 61, 0, 0, 5393, 5390, + 1, 0, 0, 0, 5393, 5391, 1, 0, 0, 0, 5394, 1086, 1, 0, 0, 0, 5395, 5396, + 5, 60, 0, 0, 5396, 5397, 5, 61, 0, 0, 5397, 5398, 5, 62, 0, 0, 5398, 1088, + 1, 0, 0, 0, 5399, 5400, 5, 60, 0, 0, 5400, 5404, 5, 62, 0, 0, 5401, 5402, + 5, 33, 0, 0, 5402, 5404, 5, 61, 0, 0, 5403, 5399, 1, 0, 0, 0, 5403, 5401, + 1, 0, 0, 0, 5404, 1090, 1, 0, 0, 0, 5405, 5406, 5, 60, 0, 0, 5406, 1092, + 1, 0, 0, 0, 5407, 5408, 5, 60, 0, 0, 5408, 5412, 5, 61, 0, 0, 5409, 5410, + 5, 33, 0, 0, 5410, 5412, 5, 62, 0, 0, 5411, 5407, 1, 0, 0, 0, 5411, 5409, + 1, 0, 0, 0, 5412, 1094, 1, 0, 0, 0, 5413, 5414, 5, 62, 0, 0, 5414, 1096, + 1, 0, 0, 0, 5415, 5416, 5, 62, 0, 0, 5416, 5420, 5, 61, 0, 0, 5417, 5418, + 5, 33, 0, 0, 5418, 5420, 5, 60, 0, 0, 5419, 5415, 1, 0, 0, 0, 5419, 5417, + 1, 0, 0, 0, 5420, 1098, 1, 0, 0, 0, 5421, 5422, 5, 43, 0, 0, 5422, 1100, + 1, 0, 0, 0, 5423, 5424, 5, 45, 0, 0, 5424, 1102, 1, 0, 0, 0, 5425, 5426, + 5, 42, 0, 0, 5426, 1104, 1, 0, 0, 0, 5427, 5428, 5, 47, 0, 0, 5428, 1106, + 1, 0, 0, 0, 5429, 5430, 5, 37, 0, 0, 5430, 1108, 1, 0, 0, 0, 5431, 5432, + 5, 126, 0, 0, 5432, 1110, 1, 0, 0, 0, 5433, 5434, 5, 38, 0, 0, 5434, 1112, + 1, 0, 0, 0, 5435, 5436, 5, 38, 0, 0, 5436, 5437, 5, 38, 0, 0, 5437, 1114, + 1, 0, 0, 0, 5438, 5439, 5, 33, 0, 0, 5439, 1116, 1, 0, 0, 0, 5440, 5441, + 5, 124, 0, 0, 5441, 1118, 1, 0, 0, 0, 5442, 5443, 5, 124, 0, 0, 5443, 5444, + 5, 124, 0, 0, 5444, 1120, 1, 0, 0, 0, 5445, 5446, 5, 94, 0, 0, 5446, 1122, + 1, 0, 0, 0, 5447, 5448, 5, 58, 0, 0, 5448, 1124, 1, 0, 0, 0, 5449, 5450, + 5, 45, 0, 0, 5450, 5451, 5, 62, 0, 0, 5451, 1126, 1, 0, 0, 0, 5452, 5453, + 5, 47, 0, 0, 5453, 5454, 5, 42, 0, 0, 5454, 5455, 5, 43, 0, 0, 5455, 1128, + 1, 0, 0, 0, 5456, 5457, 5, 42, 0, 0, 5457, 5458, 5, 47, 0, 0, 5458, 1130, + 1, 0, 0, 0, 5459, 5460, 5, 47, 0, 0, 5460, 5461, 5, 42, 0, 0, 5461, 1132, + 1, 0, 0, 0, 5462, 5463, 5, 64, 0, 0, 5463, 1134, 1, 0, 0, 0, 5464, 5465, + 5, 64, 0, 0, 5465, 5466, 5, 64, 0, 0, 5466, 1136, 1, 0, 0, 0, 5467, 5475, + 5, 39, 0, 0, 5468, 5469, 5, 92, 0, 0, 5469, 5474, 9, 0, 0, 0, 5470, 5471, + 5, 39, 0, 0, 5471, 5474, 5, 39, 0, 0, 5472, 5474, 8, 0, 0, 0, 5473, 5468, + 1, 0, 0, 0, 5473, 5470, 1, 0, 0, 0, 5473, 5472, 1, 0, 0, 0, 5474, 5477, + 1, 0, 0, 0, 5475, 5473, 1, 0, 0, 0, 5475, 5476, 1, 0, 0, 0, 5476, 5478, + 1, 0, 0, 0, 5477, 5475, 1, 0, 0, 0, 5478, 5492, 5, 39, 0, 0, 5479, 5487, + 5, 34, 0, 0, 5480, 5481, 5, 92, 0, 0, 5481, 5486, 9, 0, 0, 0, 5482, 5483, + 5, 34, 0, 0, 5483, 5486, 5, 34, 0, 0, 5484, 5486, 8, 1, 0, 0, 5485, 5480, + 1, 0, 0, 0, 5485, 5482, 1, 0, 0, 0, 5485, 5484, 1, 0, 0, 0, 5486, 5489, + 1, 0, 0, 0, 5487, 5485, 1, 0, 0, 0, 5487, 5488, 1, 0, 0, 0, 5488, 5490, + 1, 0, 0, 0, 5489, 5487, 1, 0, 0, 0, 5490, 5492, 5, 34, 0, 0, 5491, 5467, + 1, 0, 0, 0, 5491, 5479, 1, 0, 0, 0, 5492, 1138, 1, 0, 0, 0, 5493, 5494, + 7, 2, 0, 0, 5494, 5498, 5, 39, 0, 0, 5495, 5497, 3, 1167, 583, 0, 5496, + 5495, 1, 0, 0, 0, 5497, 5500, 1, 0, 0, 0, 5498, 5496, 1, 0, 0, 0, 5498, + 5499, 1, 0, 0, 0, 5499, 5501, 1, 0, 0, 0, 5500, 5498, 1, 0, 0, 0, 5501, + 5512, 5, 39, 0, 0, 5502, 5503, 7, 2, 0, 0, 5503, 5507, 5, 34, 0, 0, 5504, + 5506, 3, 1167, 583, 0, 5505, 5504, 1, 0, 0, 0, 5506, 5509, 1, 0, 0, 0, + 5507, 5505, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 5510, 1, 0, 0, 0, + 5509, 5507, 1, 0, 0, 0, 5510, 5512, 5, 34, 0, 0, 5511, 5493, 1, 0, 0, 0, + 5511, 5502, 1, 0, 0, 0, 5512, 1140, 1, 0, 0, 0, 5513, 5518, 3, 17, 8, 0, + 5514, 5518, 3, 19, 9, 0, 5515, 5518, 3, 13, 6, 0, 5516, 5518, 3, 15, 7, + 0, 5517, 5513, 1, 0, 0, 0, 5517, 5514, 1, 0, 0, 0, 5517, 5515, 1, 0, 0, + 0, 5517, 5516, 1, 0, 0, 0, 5518, 1142, 1, 0, 0, 0, 5519, 5521, 3, 1165, + 582, 0, 5520, 5519, 1, 0, 0, 0, 5521, 5522, 1, 0, 0, 0, 5522, 5520, 1, + 0, 0, 0, 5522, 5523, 1, 0, 0, 0, 5523, 5524, 1, 0, 0, 0, 5524, 5525, 5, + 76, 0, 0, 5525, 1144, 1, 0, 0, 0, 5526, 5528, 3, 1165, 582, 0, 5527, 5526, + 1, 0, 0, 0, 5528, 5529, 1, 0, 0, 0, 5529, 5527, 1, 0, 0, 0, 5529, 5530, + 1, 0, 0, 0, 5530, 5531, 1, 0, 0, 0, 5531, 5532, 5, 83, 0, 0, 5532, 1146, + 1, 0, 0, 0, 5533, 5535, 3, 1165, 582, 0, 5534, 5533, 1, 0, 0, 0, 5535, + 5536, 1, 0, 0, 0, 5536, 5534, 1, 0, 0, 0, 5536, 5537, 1, 0, 0, 0, 5537, + 5538, 1, 0, 0, 0, 5538, 5539, 5, 89, 0, 0, 5539, 1148, 1, 0, 0, 0, 5540, + 5542, 3, 1165, 582, 0, 5541, 5540, 1, 0, 0, 0, 5542, 5543, 1, 0, 0, 0, + 5543, 5541, 1, 0, 0, 0, 5543, 5544, 1, 0, 0, 0, 5544, 1150, 1, 0, 0, 0, + 5545, 5547, 3, 1165, 582, 0, 5546, 5545, 1, 0, 0, 0, 5547, 5548, 1, 0, + 0, 0, 5548, 5546, 1, 0, 0, 0, 5548, 5549, 1, 0, 0, 0, 5549, 5550, 1, 0, + 0, 0, 5550, 5551, 3, 1163, 581, 0, 5551, 5556, 1, 0, 0, 0, 5552, 5553, + 3, 1161, 580, 0, 5553, 5554, 3, 1163, 581, 0, 5554, 5556, 1, 0, 0, 0, 5555, + 5546, 1, 0, 0, 0, 5555, 5552, 1, 0, 0, 0, 5556, 1152, 1, 0, 0, 0, 5557, + 5558, 3, 1161, 580, 0, 5558, 1154, 1, 0, 0, 0, 5559, 5561, 3, 1165, 582, + 0, 5560, 5559, 1, 0, 0, 0, 5561, 5562, 1, 0, 0, 0, 5562, 5560, 1, 0, 0, + 0, 5562, 5563, 1, 0, 0, 0, 5563, 5565, 1, 0, 0, 0, 5564, 5566, 3, 1163, + 581, 0, 5565, 5564, 1, 0, 0, 0, 5565, 5566, 1, 0, 0, 0, 5566, 5567, 1, + 0, 0, 0, 5567, 5568, 5, 66, 0, 0, 5568, 5569, 5, 68, 0, 0, 5569, 5578, + 1, 0, 0, 0, 5570, 5572, 3, 1161, 580, 0, 5571, 5573, 3, 1163, 581, 0, 5572, + 5571, 1, 0, 0, 0, 5572, 5573, 1, 0, 0, 0, 5573, 5574, 1, 0, 0, 0, 5574, + 5575, 5, 66, 0, 0, 5575, 5576, 5, 68, 0, 0, 5576, 5578, 1, 0, 0, 0, 5577, + 5560, 1, 0, 0, 0, 5577, 5570, 1, 0, 0, 0, 5578, 1156, 1, 0, 0, 0, 5579, + 5583, 3, 1169, 584, 0, 5580, 5583, 3, 1165, 582, 0, 5581, 5583, 5, 95, + 0, 0, 5582, 5579, 1, 0, 0, 0, 5582, 5580, 1, 0, 0, 0, 5582, 5581, 1, 0, + 0, 0, 5583, 5584, 1, 0, 0, 0, 5584, 5582, 1, 0, 0, 0, 5584, 5585, 1, 0, + 0, 0, 5585, 1158, 1, 0, 0, 0, 5586, 5592, 5, 96, 0, 0, 5587, 5591, 8, 3, + 0, 0, 5588, 5589, 5, 96, 0, 0, 5589, 5591, 5, 96, 0, 0, 5590, 5587, 1, + 0, 0, 0, 5590, 5588, 1, 0, 0, 0, 5591, 5594, 1, 0, 0, 0, 5592, 5590, 1, + 0, 0, 0, 5592, 5593, 1, 0, 0, 0, 5593, 5595, 1, 0, 0, 0, 5594, 5592, 1, + 0, 0, 0, 5595, 5596, 5, 96, 0, 0, 5596, 1160, 1, 0, 0, 0, 5597, 5599, 3, + 1165, 582, 0, 5598, 5597, 1, 0, 0, 0, 5599, 5600, 1, 0, 0, 0, 5600, 5598, + 1, 0, 0, 0, 5600, 5601, 1, 0, 0, 0, 5601, 5602, 1, 0, 0, 0, 5602, 5606, + 5, 46, 0, 0, 5603, 5605, 3, 1165, 582, 0, 5604, 5603, 1, 0, 0, 0, 5605, + 5608, 1, 0, 0, 0, 5606, 5604, 1, 0, 0, 0, 5606, 5607, 1, 0, 0, 0, 5607, + 5616, 1, 0, 0, 0, 5608, 5606, 1, 0, 0, 0, 5609, 5611, 5, 46, 0, 0, 5610, + 5612, 3, 1165, 582, 0, 5611, 5610, 1, 0, 0, 0, 5612, 5613, 1, 0, 0, 0, + 5613, 5611, 1, 0, 0, 0, 5613, 5614, 1, 0, 0, 0, 5614, 5616, 1, 0, 0, 0, + 5615, 5598, 1, 0, 0, 0, 5615, 5609, 1, 0, 0, 0, 5616, 1162, 1, 0, 0, 0, + 5617, 5619, 5, 69, 0, 0, 5618, 5620, 7, 4, 0, 0, 5619, 5618, 1, 0, 0, 0, + 5619, 5620, 1, 0, 0, 0, 5620, 5622, 1, 0, 0, 0, 5621, 5623, 3, 1165, 582, + 0, 5622, 5621, 1, 0, 0, 0, 5623, 5624, 1, 0, 0, 0, 5624, 5622, 1, 0, 0, + 0, 5624, 5625, 1, 0, 0, 0, 5625, 1164, 1, 0, 0, 0, 5626, 5627, 7, 5, 0, + 0, 5627, 1166, 1, 0, 0, 0, 5628, 5629, 7, 6, 0, 0, 5629, 1168, 1, 0, 0, + 0, 5630, 5635, 7, 7, 0, 0, 5631, 5635, 8, 8, 0, 0, 5632, 5633, 7, 9, 0, + 0, 5633, 5635, 7, 10, 0, 0, 5634, 5630, 1, 0, 0, 0, 5634, 5631, 1, 0, 0, + 0, 5634, 5632, 1, 0, 0, 0, 5635, 1170, 1, 0, 0, 0, 5636, 5637, 5, 45, 0, + 0, 5637, 5638, 5, 45, 0, 0, 5638, 5644, 1, 0, 0, 0, 5639, 5640, 5, 92, + 0, 0, 5640, 5643, 5, 10, 0, 0, 5641, 5643, 8, 11, 0, 0, 5642, 5639, 1, + 0, 0, 0, 5642, 5641, 1, 0, 0, 0, 5643, 5646, 1, 0, 0, 0, 5644, 5642, 1, + 0, 0, 0, 5644, 5645, 1, 0, 0, 0, 5645, 5648, 1, 0, 0, 0, 5646, 5644, 1, + 0, 0, 0, 5647, 5649, 5, 13, 0, 0, 5648, 5647, 1, 0, 0, 0, 5648, 5649, 1, + 0, 0, 0, 5649, 5651, 1, 0, 0, 0, 5650, 5652, 5, 10, 0, 0, 5651, 5650, 1, + 0, 0, 0, 5651, 5652, 1, 0, 0, 0, 5652, 5653, 1, 0, 0, 0, 5653, 5654, 6, + 585, 0, 0, 5654, 1172, 1, 0, 0, 0, 5655, 5660, 3, 1131, 565, 0, 5656, 5659, + 3, 1173, 586, 0, 5657, 5659, 9, 0, 0, 0, 5658, 5656, 1, 0, 0, 0, 5658, + 5657, 1, 0, 0, 0, 5659, 5662, 1, 0, 0, 0, 5660, 5661, 1, 0, 0, 0, 5660, + 5658, 1, 0, 0, 0, 5661, 5663, 1, 0, 0, 0, 5662, 5660, 1, 0, 0, 0, 5663, + 5664, 5, 42, 0, 0, 5664, 5665, 5, 47, 0, 0, 5665, 5666, 1, 0, 0, 0, 5666, + 5667, 6, 586, 1, 0, 5667, 1174, 1, 0, 0, 0, 5668, 5669, 5, 70, 0, 0, 5669, + 5670, 5, 82, 0, 0, 5670, 5671, 5, 79, 0, 0, 5671, 5672, 5, 77, 0, 0, 5672, + 5674, 1, 0, 0, 0, 5673, 5675, 3, 1177, 588, 0, 5674, 5673, 1, 0, 0, 0, + 5675, 5676, 1, 0, 0, 0, 5676, 5674, 1, 0, 0, 0, 5676, 5677, 1, 0, 0, 0, + 5677, 5678, 1, 0, 0, 0, 5678, 5679, 5, 68, 0, 0, 5679, 5680, 5, 85, 0, + 0, 5680, 5681, 5, 65, 0, 0, 5681, 5682, 5, 76, 0, 0, 5682, 5683, 1, 0, + 0, 0, 5683, 5684, 6, 587, 0, 0, 5684, 1176, 1, 0, 0, 0, 5685, 5687, 7, + 12, 0, 0, 5686, 5685, 1, 0, 0, 0, 5687, 5688, 1, 0, 0, 0, 5688, 5686, 1, + 0, 0, 0, 5688, 5689, 1, 0, 0, 0, 5689, 5690, 1, 0, 0, 0, 5690, 5691, 6, + 588, 0, 0, 5691, 1178, 1, 0, 0, 0, 5692, 5693, 9, 0, 0, 0, 5693, 1180, + 1, 0, 0, 0, 44, 0, 1646, 5393, 5403, 5411, 5419, 5473, 5475, 5485, 5487, + 5491, 5498, 5507, 5511, 5517, 5522, 5529, 5536, 5543, 5548, 5555, 5562, + 5565, 5572, 5577, 5582, 5584, 5590, 5592, 5600, 5606, 5613, 5615, 5619, + 5624, 5634, 5642, 5644, 5648, 5651, 5658, 5660, 5676, 5688, 2, 0, 1, 0, + 0, 2, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// DorisLexerInit initializes any static state used to implement DorisLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewDorisLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func DorisLexerInit() { + staticData := &DorisLexerLexerStaticData + staticData.once.Do(dorislexerLexerInit) +} + +// NewDorisLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewDorisLexer(input antlr.CharStream) *DorisLexer { + DorisLexerInit() + l := new(DorisLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &DorisLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "DorisLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// DorisLexer tokens. +const ( + DorisLexerSEMICOLON = 1 + DorisLexerLEFT_PAREN = 2 + DorisLexerRIGHT_PAREN = 3 + DorisLexerCOMMA = 4 + DorisLexerDOT = 5 + DorisLexerDOTDOTDOT = 6 + DorisLexerLEFT_BRACKET = 7 + DorisLexerRIGHT_BRACKET = 8 + DorisLexerLEFT_BRACE = 9 + DorisLexerRIGHT_BRACE = 10 + DorisLexerACCOUNT_LOCK = 11 + DorisLexerACCOUNT_UNLOCK = 12 + DorisLexerACTIONS = 13 + DorisLexerADD = 14 + DorisLexerADMIN = 15 + DorisLexerAFTER = 16 + DorisLexerAGG_STATE = 17 + DorisLexerAGGREGATE = 18 + DorisLexerALIAS = 19 + DorisLexerALL = 20 + DorisLexerALTER = 21 + DorisLexerANALYZE = 22 + DorisLexerANALYZED = 23 + DorisLexerANALYZER = 24 + DorisLexerAND = 25 + DorisLexerANTI = 26 + DorisLexerAPPEND = 27 + DorisLexerARRAY = 28 + DorisLexerAS = 29 + DorisLexerASC = 30 + DorisLexerAT = 31 + DorisLexerAUTHORS = 32 + DorisLexerAUTO = 33 + DorisLexerAUTO_INCREMENT = 34 + DorisLexerALWAYS = 35 + DorisLexerBACKEND = 36 + DorisLexerBACKENDS = 37 + DorisLexerBACKUP = 38 + DorisLexerBEGIN = 39 + DorisLexerBELONG = 40 + DorisLexerBETWEEN = 41 + DorisLexerBIGINT = 42 + DorisLexerBIN = 43 + DorisLexerBINARY = 44 + DorisLexerBINLOG = 45 + DorisLexerBITAND = 46 + DorisLexerBITMAP = 47 + DorisLexerBITMAP_EMPTY = 48 + DorisLexerBITMAP_UNION = 49 + DorisLexerBITOR = 50 + DorisLexerBITXOR = 51 + DorisLexerBLOB = 52 + DorisLexerBOOLEAN = 53 + DorisLexerBOTH = 54 + DorisLexerBRANCH = 55 + DorisLexerBRIEF = 56 + DorisLexerBROKER = 57 + DorisLexerBUCKETS = 58 + DorisLexerBUILD = 59 + DorisLexerBUILTIN = 60 + DorisLexerBULK = 61 + DorisLexerBY = 62 + DorisLexerCACHE = 63 + DorisLexerCACHED = 64 + DorisLexerCALL = 65 + DorisLexerCANCEL = 66 + DorisLexerCASE = 67 + DorisLexerCAST = 68 + DorisLexerCATALOG = 69 + DorisLexerCATALOGS = 70 + DorisLexerCHAIN = 71 + DorisLexerCHAR = 72 + DorisLexerCHARSET = 73 + DorisLexerCHAR_FILTER = 74 + DorisLexerCHECK = 75 + DorisLexerCLEAN = 76 + DorisLexerCLUSTER = 77 + DorisLexerCLUSTERS = 78 + DorisLexerCOLLATE = 79 + DorisLexerCOLLATION = 80 + DorisLexerCOLLECT = 81 + DorisLexerCOLOCATE = 82 + DorisLexerCOLUMN = 83 + DorisLexerCOLUMNS = 84 + DorisLexerCOMMENT = 85 + DorisLexerCOMMIT = 86 + DorisLexerCOMMITTED = 87 + DorisLexerCOMPACT = 88 + DorisLexerCOMPLETE = 89 + DorisLexerCOMPRESS_TYPE = 90 + DorisLexerCOMPUTE = 91 + DorisLexerCONDITIONS = 92 + DorisLexerCONFIG = 93 + DorisLexerCONNECTION = 94 + DorisLexerCONNECTION_ID = 95 + DorisLexerCONSISTENT = 96 + DorisLexerCONSTRAINT = 97 + DorisLexerCONSTRAINTS = 98 + DorisLexerCONVERT = 99 + DorisLexerCONVERT_LSC = 100 + DorisLexerCOPY = 101 + DorisLexerCOUNT = 102 + DorisLexerCREATE = 103 + DorisLexerCREATION = 104 + DorisLexerCRON = 105 + DorisLexerCROSS = 106 + DorisLexerCUBE = 107 + DorisLexerCURRENT = 108 + DorisLexerCURRENT_CATALOG = 109 + DorisLexerCURRENT_DATE = 110 + DorisLexerCURRENT_TIME = 111 + DorisLexerCURRENT_TIMESTAMP = 112 + DorisLexerCURRENT_USER = 113 + DorisLexerDATA = 114 + DorisLexerDATABASE = 115 + DorisLexerDATABASES = 116 + DorisLexerDATE = 117 + DorisLexerDATETIME = 118 + DorisLexerDATETIMEV2 = 119 + DorisLexerDATEV2 = 120 + DorisLexerDATETIMEV1 = 121 + DorisLexerDATEV1 = 122 + DorisLexerDAY = 123 + DorisLexerDAY_SECOND = 124 + DorisLexerDAYS = 125 + DorisLexerDAY_HOUR = 126 + DorisLexerDECIMAL = 127 + DorisLexerDECIMALV2 = 128 + DorisLexerDECIMALV3 = 129 + DorisLexerDECOMMISSION = 130 + DorisLexerDEFAULT = 131 + DorisLexerDEFERRED = 132 + DorisLexerDELETE = 133 + DorisLexerDEMAND = 134 + DorisLexerDESC = 135 + DorisLexerDESCRIBE = 136 + DorisLexerDIAGNOSE = 137 + DorisLexerDIAGNOSIS = 138 + DorisLexerDICTIONARIES = 139 + DorisLexerDICTIONARY = 140 + DorisLexerDISK = 141 + DorisLexerDISTINCT = 142 + DorisLexerDISTINCTPC = 143 + DorisLexerDISTINCTPCSA = 144 + DorisLexerDISTRIBUTED = 145 + DorisLexerDISTRIBUTION = 146 + DorisLexerDIV = 147 + DorisLexerDO = 148 + DorisLexerDORIS_INTERNAL_TABLE_ID = 149 + DorisLexerDOUBLE = 150 + DorisLexerDROP = 151 + DorisLexerDROPP = 152 + DorisLexerDUAL = 153 + DorisLexerDUMP = 154 + DorisLexerDUPLICATE = 155 + DorisLexerDYNAMIC = 156 + DorisLexerE = 157 + DorisLexerELSE = 158 + DorisLexerENABLE = 159 + DorisLexerENCRYPTION = 160 + DorisLexerENCRYPTKEY = 161 + DorisLexerENCRYPTKEYS = 162 + DorisLexerEND = 163 + DorisLexerENDS = 164 + DorisLexerENGINE = 165 + DorisLexerENGINES = 166 + DorisLexerENTER = 167 + DorisLexerERRORS = 168 + DorisLexerESCAPE = 169 + DorisLexerEVENTS = 170 + DorisLexerEVERY = 171 + DorisLexerEXCEPT = 172 + DorisLexerEXCLUDE = 173 + DorisLexerEXECUTE = 174 + DorisLexerEXISTS = 175 + DorisLexerEXPIRED = 176 + DorisLexerEXPLAIN = 177 + DorisLexerEXPORT = 178 + DorisLexerEXTENDED = 179 + DorisLexerEXTERNAL = 180 + DorisLexerEXTRACT = 181 + DorisLexerFAILED_LOGIN_ATTEMPTS = 182 + DorisLexerFALSE = 183 + DorisLexerFAST = 184 + DorisLexerFEATURE = 185 + DorisLexerFIELDS = 186 + DorisLexerFILE = 187 + DorisLexerFILTER = 188 + DorisLexerFIRST = 189 + DorisLexerFLOAT = 190 + DorisLexerFOLLOWER = 191 + DorisLexerFOLLOWING = 192 + DorisLexerFOR = 193 + DorisLexerFOREIGN = 194 + DorisLexerFORCE = 195 + DorisLexerFORMAT = 196 + DorisLexerFREE = 197 + DorisLexerFROM = 198 + DorisLexerFRONTEND = 199 + DorisLexerFRONTENDS = 200 + DorisLexerFULL = 201 + DorisLexerFUNCTION = 202 + DorisLexerFUNCTIONS = 203 + DorisLexerGENERATED = 204 + DorisLexerGENERIC = 205 + DorisLexerGLOBAL = 206 + DorisLexerGRANT = 207 + DorisLexerGRANTS = 208 + DorisLexerGRAPH = 209 + DorisLexerGROUP = 210 + DorisLexerGROUPING = 211 + DorisLexerGROUPS = 212 + DorisLexerGROUP_CONCAT = 213 + DorisLexerHASH = 214 + DorisLexerHASH_MAP = 215 + DorisLexerHAVING = 216 + DorisLexerHDFS = 217 + DorisLexerHELP = 218 + DorisLexerHISTOGRAM = 219 + DorisLexerHLL = 220 + DorisLexerHLL_UNION = 221 + DorisLexerHOSTNAME = 222 + DorisLexerHOTSPOT = 223 + DorisLexerHOUR = 224 + DorisLexerHOURS = 225 + DorisLexerHUB = 226 + DorisLexerIDENTIFIED = 227 + DorisLexerIF = 228 + DorisLexerIGNORE = 229 + DorisLexerIMMEDIATE = 230 + DorisLexerIN = 231 + DorisLexerINCREMENTAL = 232 + DorisLexerINDEX = 233 + DorisLexerINDEXES = 234 + DorisLexerINFILE = 235 + DorisLexerINNER = 236 + DorisLexerINSERT = 237 + DorisLexerINSTALL = 238 + DorisLexerINT = 239 + DorisLexerINTEGER = 240 + DorisLexerINTERMEDIATE = 241 + DorisLexerINTERSECT = 242 + DorisLexerINTERVAL = 243 + DorisLexerINTO = 244 + DorisLexerINVERTED = 245 + DorisLexerIP_TRIE = 246 + DorisLexerIPV4 = 247 + DorisLexerIPV6 = 248 + DorisLexerIS = 249 + DorisLexerIS_NOT_NULL_PRED = 250 + DorisLexerIS_NULL_PRED = 251 + DorisLexerISNULL = 252 + DorisLexerISOLATION = 253 + DorisLexerJOB = 254 + DorisLexerJOBS = 255 + DorisLexerJOIN = 256 + DorisLexerJSON = 257 + DorisLexerJSONB = 258 + DorisLexerKEY = 259 + DorisLexerKEYS = 260 + DorisLexerKILL = 261 + DorisLexerLABEL = 262 + DorisLexerLARGEINT = 263 + DorisLexerLAYOUT = 264 + DorisLexerLAST = 265 + DorisLexerLATERAL = 266 + DorisLexerLDAP = 267 + DorisLexerLDAP_ADMIN_PASSWORD = 268 + DorisLexerLEADING = 269 + DorisLexerLEFT = 270 + DorisLexerLESS = 271 + DorisLexerLEVEL = 272 + DorisLexerLIKE = 273 + DorisLexerLIMIT = 274 + DorisLexerLINES = 275 + DorisLexerLINK = 276 + DorisLexerLIST = 277 + DorisLexerLOAD = 278 + DorisLexerLOCAL = 279 + DorisLexerLOCALTIME = 280 + DorisLexerLOCALTIMESTAMP = 281 + DorisLexerLOCATION = 282 + DorisLexerLOCK = 283 + DorisLexerLOGICAL = 284 + DorisLexerLOW_PRIORITY = 285 + DorisLexerMANUAL = 286 + DorisLexerMAP = 287 + DorisLexerMATCH = 288 + DorisLexerMATCHED = 289 + DorisLexerMATCH_ALL = 290 + DorisLexerMATCH_ANY = 291 + DorisLexerMATCH_NAME = 292 + DorisLexerMATCH_NAME_GLOB = 293 + DorisLexerMATCH_PHRASE = 294 + DorisLexerMATCH_PHRASE_EDGE = 295 + DorisLexerMATCH_PHRASE_PREFIX = 296 + DorisLexerMATCH_REGEXP = 297 + DorisLexerMATERIALIZED = 298 + DorisLexerMAX = 299 + DorisLexerMAXVALUE = 300 + DorisLexerMEMO = 301 + DorisLexerMERGE = 302 + DorisLexerMID = 303 + DorisLexerMIGRATE = 304 + DorisLexerMIGRATIONS = 305 + DorisLexerMIN = 306 + DorisLexerMINUS = 307 + DorisLexerMINUTE = 308 + DorisLexerMINUTES = 309 + DorisLexerMINUTE_SECOND = 310 + DorisLexerMODIFY = 311 + DorisLexerMONTH = 312 + DorisLexerMTMV = 313 + DorisLexerNAME = 314 + DorisLexerNAMES = 315 + DorisLexerNATURAL = 316 + DorisLexerNEGATIVE = 317 + DorisLexerNEVER = 318 + DorisLexerNEXT = 319 + DorisLexerNGRAM_BF = 320 + DorisLexerANN = 321 + DorisLexerNO = 322 + DorisLexerNO_USE_MV = 323 + DorisLexerNON_NULLABLE = 324 + DorisLexerNOT = 325 + DorisLexerNULL = 326 + DorisLexerNULLS = 327 + DorisLexerOBSERVER = 328 + DorisLexerOF = 329 + DorisLexerOFFSET = 330 + DorisLexerON = 331 + DorisLexerOFF = 332 + DorisLexerONLY = 333 + DorisLexerOPEN = 334 + DorisLexerOPTIMIZE = 335 + DorisLexerOPTIMIZED = 336 + DorisLexerOR = 337 + DorisLexerORDER = 338 + DorisLexerOUTER = 339 + DorisLexerOUTFILE = 340 + DorisLexerOVER = 341 + DorisLexerOVERWRITE = 342 + DorisLexerPARAMETER = 343 + DorisLexerPARSED = 344 + DorisLexerPARTITION = 345 + DorisLexerPARTITIONS = 346 + DorisLexerPASSWORD = 347 + DorisLexerPASSWORD_EXPIRE = 348 + DorisLexerPASSWORD_HISTORY = 349 + DorisLexerPASSWORD_LOCK_TIME = 350 + DorisLexerPASSWORD_REUSE = 351 + DorisLexerPATH = 352 + DorisLexerPAUSE = 353 + DorisLexerPERCENT = 354 + DorisLexerPERIOD = 355 + DorisLexerPERMISSIVE = 356 + DorisLexerPHYSICAL = 357 + DorisLexerPI = 358 + DorisLexerPLACEHOLDER = 359 + DorisLexerPLAN = 360 + DorisLexerPLAY = 361 + DorisLexerPRIVILEGES = 362 + DorisLexerPROCESS = 363 + DorisLexerPLUGIN = 364 + DorisLexerPLUGINS = 365 + DorisLexerPOLICY = 366 + DorisLexerPOSITION = 367 + DorisLexerPRECEDING = 368 + DorisLexerPREPARE = 369 + DorisLexerPRIMARY = 370 + DorisLexerPROC = 371 + DorisLexerPROCEDURE = 372 + DorisLexerPROCESSLIST = 373 + DorisLexerPROFILE = 374 + DorisLexerPROPERTIES = 375 + DorisLexerPROPERTY = 376 + DorisLexerQUANTILE_STATE = 377 + DorisLexerQUANTILE_UNION = 378 + DorisLexerQUERY = 379 + DorisLexerQUEUED = 380 + DorisLexerQUOTA = 381 + DorisLexerQUALIFY = 382 + DorisLexerQUARTER = 383 + DorisLexerRANDOM = 384 + DorisLexerRANGE = 385 + DorisLexerREAD = 386 + DorisLexerREAL = 387 + DorisLexerREBALANCE = 388 + DorisLexerRECENT = 389 + DorisLexerRECOVER = 390 + DorisLexerRECYCLE = 391 + DorisLexerREFRESH = 392 + DorisLexerREFERENCES = 393 + DorisLexerREGEXP = 394 + DorisLexerRELEASE = 395 + DorisLexerRENAME = 396 + DorisLexerREPAIR = 397 + DorisLexerREPEATABLE = 398 + DorisLexerREPLACE = 399 + DorisLexerREPLACE_IF_NOT_NULL = 400 + DorisLexerREPLAYER = 401 + DorisLexerREPLICA = 402 + DorisLexerREPOSITORIES = 403 + DorisLexerREPOSITORY = 404 + DorisLexerRESOURCE = 405 + DorisLexerRESOURCES = 406 + DorisLexerRESTORE = 407 + DorisLexerRESTRICTIVE = 408 + DorisLexerRESUME = 409 + DorisLexerRETAIN = 410 + DorisLexerRETENTION = 411 + DorisLexerRETURNS = 412 + DorisLexerREVOKE = 413 + DorisLexerREWRITTEN = 414 + DorisLexerRIGHT = 415 + DorisLexerRLIKE = 416 + DorisLexerROLE = 417 + DorisLexerROLES = 418 + DorisLexerROLLBACK = 419 + DorisLexerROLLUP = 420 + DorisLexerROOT = 421 + DorisLexerROTATE = 422 + DorisLexerROUTINE = 423 + DorisLexerROW = 424 + DorisLexerROWS = 425 + DorisLexerS3 = 426 + DorisLexerSAMPLE = 427 + DorisLexerSCHEDULE = 428 + DorisLexerSCHEDULER = 429 + DorisLexerSCHEMA = 430 + DorisLexerSCHEMAS = 431 + DorisLexerSECOND = 432 + DorisLexerSELECT = 433 + DorisLexerSEMI = 434 + DorisLexerSEPARATOR = 435 + DorisLexerSERIALIZABLE = 436 + DorisLexerSESSION = 437 + DorisLexerSESSION_USER = 438 + DorisLexerSET = 439 + DorisLexerSETS = 440 + DorisLexerSET_SESSION_VARIABLE = 441 + DorisLexerSHAPE = 442 + DorisLexerSHOW = 443 + DorisLexerSIGNED = 444 + DorisLexerSKEW = 445 + DorisLexerSMALLINT = 446 + DorisLexerSNAPSHOT = 447 + DorisLexerSNAPSHOTS = 448 + DorisLexerSONAME = 449 + DorisLexerSPLIT = 450 + DorisLexerSQL = 451 + DorisLexerSQL_BLOCK_RULE = 452 + DorisLexerSTAGE = 453 + DorisLexerSTAGES = 454 + DorisLexerSTART = 455 + DorisLexerSTARTS = 456 + DorisLexerSTATS = 457 + DorisLexerSTATUS = 458 + DorisLexerSTOP = 459 + DorisLexerSTORAGE = 460 + DorisLexerSTREAM = 461 + DorisLexerSTREAMING = 462 + DorisLexerSTRING = 463 + DorisLexerSTRUCT = 464 + DorisLexerSUBSTR = 465 + DorisLexerSUBSTRING = 466 + DorisLexerSUM = 467 + DorisLexerSUPERUSER = 468 + DorisLexerSWITCH = 469 + DorisLexerSYNC = 470 + DorisLexerSYSTEM = 471 + DorisLexerTABLE = 472 + DorisLexerTABLES = 473 + DorisLexerTABLESAMPLE = 474 + DorisLexerTABLET = 475 + DorisLexerTABLETS = 476 + DorisLexerTAG = 477 + DorisLexerTASK = 478 + DorisLexerTASKS = 479 + DorisLexerTDE = 480 + DorisLexerTEMPORARY = 481 + DorisLexerTERMINATED = 482 + DorisLexerTEXT = 483 + DorisLexerTHAN = 484 + DorisLexerTHEN = 485 + DorisLexerTIME = 486 + DorisLexerTIMESTAMP = 487 + DorisLexerTINYINT = 488 + DorisLexerTO = 489 + DorisLexerTOKENIZER = 490 + DorisLexerTOKEN_FILTER = 491 + DorisLexerTRAILING = 492 + DorisLexerTRANSACTION = 493 + DorisLexerTRASH = 494 + DorisLexerTREE = 495 + DorisLexerTRIGGERS = 496 + DorisLexerTRIM = 497 + DorisLexerTRUE = 498 + DorisLexerTRUNCATE = 499 + DorisLexerTRY_CAST = 500 + DorisLexerTYPE = 501 + DorisLexerTYPECAST = 502 + DorisLexerTYPES = 503 + DorisLexerUNBOUNDED = 504 + DorisLexerUNCOMMITTED = 505 + DorisLexerUNINSTALL = 506 + DorisLexerUNION = 507 + DorisLexerUNIQUE = 508 + DorisLexerUNLOCK = 509 + DorisLexerUNSET = 510 + DorisLexerUNSIGNED = 511 + DorisLexerUP = 512 + DorisLexerUPDATE = 513 + DorisLexerUSE = 514 + DorisLexerUSER = 515 + DorisLexerUSE_MV = 516 + DorisLexerUSING = 517 + DorisLexerVALUE = 518 + DorisLexerVALUES = 519 + DorisLexerVARBINARY = 520 + DorisLexerVARCHAR = 521 + DorisLexerVARIABLE = 522 + DorisLexerVARIABLES = 523 + DorisLexerVARIANT = 524 + DorisLexerVAULT = 525 + DorisLexerVAULTS = 526 + DorisLexerVERBOSE = 527 + DorisLexerVERSION = 528 + DorisLexerVIEW = 529 + DorisLexerVIEWS = 530 + DorisLexerWARM = 531 + DorisLexerWARNINGS = 532 + DorisLexerWEEK = 533 + DorisLexerWHEN = 534 + DorisLexerWHERE = 535 + DorisLexerWHITELIST = 536 + DorisLexerWITH = 537 + DorisLexerWORK = 538 + DorisLexerWORKLOAD = 539 + DorisLexerWRITE = 540 + DorisLexerXOR = 541 + DorisLexerYEAR = 542 + DorisLexerEQ = 543 + DorisLexerNSEQ = 544 + DorisLexerNEQ = 545 + DorisLexerLT = 546 + DorisLexerLTE = 547 + DorisLexerGT = 548 + DorisLexerGTE = 549 + DorisLexerPLUS = 550 + DorisLexerSUBTRACT = 551 + DorisLexerASTERISK = 552 + DorisLexerSLASH = 553 + DorisLexerMOD = 554 + DorisLexerTILDE = 555 + DorisLexerAMPERSAND = 556 + DorisLexerLOGICALAND = 557 + DorisLexerLOGICALNOT = 558 + DorisLexerPIPE = 559 + DorisLexerDOUBLEPIPES = 560 + DorisLexerHAT = 561 + DorisLexerCOLON = 562 + DorisLexerARROW = 563 + DorisLexerHINT_START = 564 + DorisLexerHINT_END = 565 + DorisLexerCOMMENT_START = 566 + DorisLexerATSIGN = 567 + DorisLexerDOUBLEATSIGN = 568 + DorisLexerSTRING_LITERAL = 569 + DorisLexerVARBINARY_LITERAL = 570 + DorisLexerLEADING_STRING = 571 + DorisLexerBIGINT_LITERAL = 572 + DorisLexerSMALLINT_LITERAL = 573 + DorisLexerTINYINT_LITERAL = 574 + DorisLexerINTEGER_VALUE = 575 + DorisLexerEXPONENT_VALUE = 576 + DorisLexerDECIMAL_VALUE = 577 + DorisLexerBIGDECIMAL_LITERAL = 578 + DorisLexerIDENTIFIER = 579 + DorisLexerBACKQUOTED_IDENTIFIER = 580 + DorisLexerSIMPLE_COMMENT = 581 + DorisLexerBRACKETED_COMMENT = 582 + DorisLexerFROM_DUAL = 583 + DorisLexerWS = 584 + DorisLexerUNRECOGNIZED = 585 +) diff --git a/doris/doris_parser.go b/doris/doris_parser.go new file mode 100644 index 0000000..55ae5ec --- /dev/null +++ b/doris/doris_parser.go @@ -0,0 +1,126490 @@ +// Code generated from DorisParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package doris // DorisParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type DorisParser struct { + *antlr.BaseParser +} + +var DorisParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func dorisparserParserInit() { + staticData := &DorisParserParserStaticData + staticData.LiteralNames = []string{ + "", "';'", "'('", "')'", "','", "'.'", "'...'", "'['", "']'", "'{'", + "'}'", "'ACCOUNT_LOCK'", "'ACCOUNT_UNLOCK'", "'ACTIONS'", "'ADD'", "'ADMIN'", + "'AFTER'", "'AGG_STATE'", "'AGGREGATE'", "'ALIAS'", "'ALL'", "'ALTER'", + "'ANALYZE'", "'ANALYZED'", "'ANALYZER'", "'AND'", "'ANTI'", "'APPEND'", + "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORS'", "'AUTO'", "'AUTO_INCREMENT'", + "'ALWAYS'", "'BACKEND'", "'BACKENDS'", "'BACKUP'", "'BEGIN'", "'BELONG'", + "'BETWEEN'", "'BIGINT'", "'BIN'", "'BINARY'", "'BINLOG'", "'BITAND'", + "'BITMAP'", "'BITMAP_EMPTY'", "'BITMAP_UNION'", "'BITOR'", "'BITXOR'", + "'BLOB'", "'BOOLEAN'", "'BOTH'", "'BRANCH'", "'BRIEF'", "'BROKER'", + "'BUCKETS'", "'BUILD'", "'BUILTIN'", "'BULK'", "'BY'", "'CACHE'", "'CACHED'", + "'CALL'", "'CANCEL'", "'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'", + "'CHAIN'", "", "'CHARSET'", "'CHAR_FILTER'", "'CHECK'", "'CLEAN'", "'CLUSTER'", + "'CLUSTERS'", "'COLLATE'", "'COLLATION'", "'COLLECT'", "'COLOCATE'", + "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMMITTED'", "'COMPACT'", + "'COMPLETE'", "'COMPRESS_TYPE'", "'COMPUTE'", "'CONDITIONS'", "'CONFIG'", + "'CONNECTION'", "'CONNECTION_ID'", "'CONSISTENT'", "'CONSTRAINT'", "'CONSTRAINTS'", + "'CONVERT'", "'CONVERT_LIGHT_SCHEMA_CHANGE_PROCESS'", "'COPY'", "'COUNT'", + "'CREATE'", "'CREATION'", "'CRON'", "'CROSS'", "'CUBE'", "'CURRENT'", + "'CURRENT_CATALOG'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'DATA'", "'DATABASE'", "'DATABASES'", "'DATE'", "'DATETIME'", + "'DATETIMEV2'", "'DATEV2'", "'DATETIMEV1'", "'DATEV1'", "'DAY'", "'DAY_SECOND'", + "'DAYS'", "'DAY_HOUR'", "'DECIMAL'", "'DECIMALV2'", "'DECIMALV3'", "'DECOMMISSION'", + "'DEFAULT'", "'DEFERRED'", "'DELETE'", "'DEMAND'", "'DESC'", "'DESCRIBE'", + "'DIAGNOSE'", "'DIAGNOSIS'", "'DICTIONARIES'", "'DICTIONARY'", "'DISK'", + "'DISTINCT'", "'DISTINCTPC'", "'DISTINCTPCSA'", "'DISTRIBUTED'", "'DISTRIBUTION'", + "'DIV'", "'DO'", "'DORIS_INTERNAL_TABLE_ID'", "'DOUBLE'", "'DROP'", + "'DROPP'", "'DUAL'", "'DUMP'", "'DUPLICATE'", "'DYNAMIC'", "'E'", "'ELSE'", + "'ENABLE'", "'ENCRYPTION'", "'ENCRYPTKEY'", "'ENCRYPTKEYS'", "'END'", + "'ENDS'", "'ENGINE'", "'ENGINES'", "'ENTER'", "'ERRORS'", "'ESCAPE'", + "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCLUDE'", "'EXECUTE'", "'EXISTS'", + "'EXPIRED'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", + "'FAILED_LOGIN_ATTEMPTS'", "'FALSE'", "'FAST'", "'FEATURE'", "'FIELDS'", + "'FILE'", "'FILTER'", "'FIRST'", "'FLOAT'", "'FOLLOWER'", "'FOLLOWING'", + "'FOR'", "'FOREIGN'", "'FORCE'", "'FORMAT'", "'FREE'", "'FROM'", "'FRONTEND'", + "'FRONTENDS'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GENERATED'", + "'GENERIC'", "'GLOBAL'", "'GRANT'", "'GRANTS'", "'GRAPH'", "'GROUP'", + "'GROUPING'", "'GROUPS'", "'GROUP_CONCAT'", "'HASH'", "'HASH_MAP'", + "'HAVING'", "'HDFS'", "'HELP'", "'HISTOGRAM'", "'HLL'", "'HLL_UNION'", + "'HOSTNAME'", "'HOTSPOT'", "'HOUR'", "'HOURS'", "'HUB'", "'IDENTIFIED'", + "'IF'", "'IGNORE'", "'IMMEDIATE'", "'IN'", "'INCREMENTAL'", "'INDEX'", + "'INDEXES'", "'INFILE'", "'INNER'", "'INSERT'", "'INSTALL'", "'INT'", + "'INTEGER'", "'INTERMEDIATE'", "'INTERSECT'", "'INTERVAL'", "'INTO'", + "'INVERTED'", "'IP_TRIE'", "'IPV4'", "'IPV6'", "'IS'", "'IS_NOT_NULL_PRED'", + "'IS_NULL_PRED'", "'ISNULL'", "'ISOLATION'", "'JOB'", "'JOBS'", "'JOIN'", + "'JSON'", "'JSONB'", "'KEY'", "'KEYS'", "'KILL'", "'LABEL'", "'LARGEINT'", + "'LAYOUT'", "'LAST'", "'LATERAL'", "'LDAP'", "'LDAP_ADMIN_PASSWORD'", + "'LEADING'", "'LEFT'", "'LESS'", "'LEVEL'", "'LIKE'", "'LIMIT'", "'LINES'", + "'LINK'", "'LIST'", "'LOAD'", "'LOCAL'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'LOCATION'", "'LOCK'", "'LOGICAL'", "'LOW_PRIORITY'", "'MANUAL'", "'MAP'", + "'MATCH'", "'MATCHED'", "'MATCH_ALL'", "'MATCH_ANY'", "'MATCH_NAME'", + "'MATCH_NAME_GLOB'", "'MATCH_PHRASE'", "'MATCH_PHRASE_EDGE'", "'MATCH_PHRASE_PREFIX'", + "'MATCH_REGEXP'", "'MATERIALIZED'", "'MAX'", "'MAXVALUE'", "'MEMO'", + "'MERGE'", "'MID'", "'MIGRATE'", "'MIGRATIONS'", "'MIN'", "'MINUS'", + "'MINUTE'", "'MINUTES'", "'MINUTE_SECOND'", "'MODIFY'", "'MONTH'", "'MTMV'", + "'NAME'", "'NAMES'", "'NATURAL'", "'NEGATIVE'", "'NEVER'", "'NEXT'", + "'NGRAM_BF'", "'ANN'", "'NO'", "'NO_USE_MV'", "'NON_NULLABLE'", "'NOT'", + "'NULL'", "'NULLS'", "'OBSERVER'", "'OF'", "'OFFSET'", "'ON'", "'OFF'", + "'ONLY'", "'OPEN'", "'OPTIMIZE'", "'OPTIMIZED'", "'OR'", "'ORDER'", + "'OUTER'", "'OUTFILE'", "'OVER'", "'OVERWRITE'", "'PARAMETER'", "'PARSED'", + "'PARTITION'", "'PARTITIONS'", "'PASSWORD'", "'PASSWORD_EXPIRE'", "'PASSWORD_HISTORY'", + "'PASSWORD_LOCK_TIME'", "'PASSWORD_REUSE'", "'PATH'", "'PAUSE'", "'PERCENT'", + "'PERIOD'", "'PERMISSIVE'", "'PHYSICAL'", "'PI'", "'?'", "'PLAN'", "'PLAY'", + "'PRIVILEGES'", "'PROCESS'", "'PLUGIN'", "'PLUGINS'", "'POLICY'", "'POSITION'", + "'PRECEDING'", "'PREPARE'", "'PRIMARY'", "'PROC'", "'PROCEDURE'", "'PROCESSLIST'", + "'PROFILE'", "'PROPERTIES'", "'PROPERTY'", "'QUANTILE_STATE'", "'QUANTILE_UNION'", + "'QUERY'", "'QUEUED'", "'QUOTA'", "'QUALIFY'", "'QUARTER'", "'RANDOM'", + "'RANGE'", "'READ'", "'REAL'", "'REBALANCE'", "'RECENT'", "'RECOVER'", + "'RECYCLE'", "'REFRESH'", "'REFERENCES'", "'REGEXP'", "'RELEASE'", "'RENAME'", + "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'REPLACE_IF_NOT_NULL'", "'REPLAYER'", + "'REPLICA'", "'REPOSITORIES'", "'REPOSITORY'", "'RESOURCE'", "'RESOURCES'", + "'RESTORE'", "'RESTRICTIVE'", "'RESUME'", "'RETAIN'", "'RETENTION'", + "'RETURNS'", "'REVOKE'", "'REWRITTEN'", "'RIGHT'", "'RLIKE'", "'ROLE'", + "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROOT'", "'ROTATE'", "'ROUTINE'", + "'ROW'", "'ROWS'", "'S3'", "'SAMPLE'", "'SCHEDULE'", "'SCHEDULER'", + "'SCHEMA'", "'SCHEMAS'", "'SECOND'", "'SELECT'", "'SEMI'", "'SEPARATOR'", + "'SERIALIZABLE'", "'SESSION'", "'SESSION_USER'", "'SET'", "'SETS'", + "'SET_SESSION_VARIABLE'", "'SHAPE'", "'SHOW'", "'SIGNED'", "'SKEW'", + "'SMALLINT'", "'SNAPSHOT'", "'SNAPSHOTS'", "'SONAME'", "'SPLIT'", "'SQL'", + "'SQL_BLOCK_RULE'", "'STAGE'", "'STAGES'", "'START'", "'STARTS'", "'STATS'", + "'STATUS'", "'STOP'", "'STORAGE'", "'STREAM'", "'STREAMING'", "'STRING'", + "'STRUCT'", "'SUBSTR'", "'SUBSTRING'", "'SUM'", "'SUPERUSER'", "'SWITCH'", + "'SYNC'", "'SYSTEM'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TABLET'", + "'TABLETS'", "'TAG'", "'TASK'", "'TASKS'", "'TDE'", "'TEMPORARY'", "'TERMINATED'", + "'TEXT'", "'THAN'", "'THEN'", "'TIME'", "'TIMESTAMP'", "'TINYINT'", + "'TO'", "'TOKENIZER'", "'TOKEN_FILTER'", "'TRAILING'", "'TRANSACTION'", + "'TRASH'", "'TREE'", "'TRIGGERS'", "'TRIM'", "'TRUE'", "'TRUNCATE'", + "'TRY_CAST'", "'TYPE'", "'TYPE_CAST'", "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", + "'UNINSTALL'", "'UNION'", "'UNIQUE'", "'UNLOCK'", "'UNSET'", "'UNSIGNED'", + "'UP'", "'UPDATE'", "'USE'", "'USER'", "'USE_MV'", "'USING'", "'VALUE'", + "'VALUES'", "'VARBINARY'", "'VARCHAR'", "'VARIABLE'", "'VARIABLES'", + "'VARIANT'", "'VAULT'", "'VAULTS'", "'VERBOSE'", "'VERSION'", "'VIEW'", + "'VIEWS'", "'WARM'", "'WARNINGS'", "'WEEK'", "'WHEN'", "'WHERE'", "'WHITELIST'", + "'WITH'", "'WORK'", "'WORKLOAD'", "'WRITE'", "'XOR'", "'YEAR'", "", + "'<=>'", "", "'<'", "", "'>'", "", "'+'", "'-'", "'*'", "'/'", "'%'", + "'~'", "'&'", "'&&'", "'!'", "'|'", "'||'", "'^'", "':'", "'->'", "'/*+'", + "'*/'", "'/*'", "'@'", "'@@'", + } + staticData.SymbolicNames = []string{ + "", "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "DOTDOTDOT", + "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_BRACE", "RIGHT_BRACE", "ACCOUNT_LOCK", + "ACCOUNT_UNLOCK", "ACTIONS", "ADD", "ADMIN", "AFTER", "AGG_STATE", "AGGREGATE", + "ALIAS", "ALL", "ALTER", "ANALYZE", "ANALYZED", "ANALYZER", "AND", "ANTI", + "APPEND", "ARRAY", "AS", "ASC", "AT", "AUTHORS", "AUTO", "AUTO_INCREMENT", + "ALWAYS", "BACKEND", "BACKENDS", "BACKUP", "BEGIN", "BELONG", "BETWEEN", + "BIGINT", "BIN", "BINARY", "BINLOG", "BITAND", "BITMAP", "BITMAP_EMPTY", + "BITMAP_UNION", "BITOR", "BITXOR", "BLOB", "BOOLEAN", "BOTH", "BRANCH", + "BRIEF", "BROKER", "BUCKETS", "BUILD", "BUILTIN", "BULK", "BY", "CACHE", + "CACHED", "CALL", "CANCEL", "CASE", "CAST", "CATALOG", "CATALOGS", "CHAIN", + "CHAR", "CHARSET", "CHAR_FILTER", "CHECK", "CLEAN", "CLUSTER", "CLUSTERS", + "COLLATE", "COLLATION", "COLLECT", "COLOCATE", "COLUMN", "COLUMNS", + "COMMENT", "COMMIT", "COMMITTED", "COMPACT", "COMPLETE", "COMPRESS_TYPE", + "COMPUTE", "CONDITIONS", "CONFIG", "CONNECTION", "CONNECTION_ID", "CONSISTENT", + "CONSTRAINT", "CONSTRAINTS", "CONVERT", "CONVERT_LSC", "COPY", "COUNT", + "CREATE", "CREATION", "CRON", "CROSS", "CUBE", "CURRENT", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "DATA", "DATABASE", "DATABASES", "DATE", "DATETIME", "DATETIMEV2", "DATEV2", + "DATETIMEV1", "DATEV1", "DAY", "DAY_SECOND", "DAYS", "DAY_HOUR", "DECIMAL", + "DECIMALV2", "DECIMALV3", "DECOMMISSION", "DEFAULT", "DEFERRED", "DELETE", + "DEMAND", "DESC", "DESCRIBE", "DIAGNOSE", "DIAGNOSIS", "DICTIONARIES", + "DICTIONARY", "DISK", "DISTINCT", "DISTINCTPC", "DISTINCTPCSA", "DISTRIBUTED", + "DISTRIBUTION", "DIV", "DO", "DORIS_INTERNAL_TABLE_ID", "DOUBLE", "DROP", + "DROPP", "DUAL", "DUMP", "DUPLICATE", "DYNAMIC", "E", "ELSE", "ENABLE", + "ENCRYPTION", "ENCRYPTKEY", "ENCRYPTKEYS", "END", "ENDS", "ENGINE", + "ENGINES", "ENTER", "ERRORS", "ESCAPE", "EVENTS", "EVERY", "EXCEPT", + "EXCLUDE", "EXECUTE", "EXISTS", "EXPIRED", "EXPLAIN", "EXPORT", "EXTENDED", + "EXTERNAL", "EXTRACT", "FAILED_LOGIN_ATTEMPTS", "FALSE", "FAST", "FEATURE", + "FIELDS", "FILE", "FILTER", "FIRST", "FLOAT", "FOLLOWER", "FOLLOWING", + "FOR", "FOREIGN", "FORCE", "FORMAT", "FREE", "FROM", "FRONTEND", "FRONTENDS", + "FULL", "FUNCTION", "FUNCTIONS", "GENERATED", "GENERIC", "GLOBAL", "GRANT", + "GRANTS", "GRAPH", "GROUP", "GROUPING", "GROUPS", "GROUP_CONCAT", "HASH", + "HASH_MAP", "HAVING", "HDFS", "HELP", "HISTOGRAM", "HLL", "HLL_UNION", + "HOSTNAME", "HOTSPOT", "HOUR", "HOURS", "HUB", "IDENTIFIED", "IF", "IGNORE", + "IMMEDIATE", "IN", "INCREMENTAL", "INDEX", "INDEXES", "INFILE", "INNER", + "INSERT", "INSTALL", "INT", "INTEGER", "INTERMEDIATE", "INTERSECT", + "INTERVAL", "INTO", "INVERTED", "IP_TRIE", "IPV4", "IPV6", "IS", "IS_NOT_NULL_PRED", + "IS_NULL_PRED", "ISNULL", "ISOLATION", "JOB", "JOBS", "JOIN", "JSON", + "JSONB", "KEY", "KEYS", "KILL", "LABEL", "LARGEINT", "LAYOUT", "LAST", + "LATERAL", "LDAP", "LDAP_ADMIN_PASSWORD", "LEADING", "LEFT", "LESS", + "LEVEL", "LIKE", "LIMIT", "LINES", "LINK", "LIST", "LOAD", "LOCAL", + "LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCK", "LOGICAL", "LOW_PRIORITY", + "MANUAL", "MAP", "MATCH", "MATCHED", "MATCH_ALL", "MATCH_ANY", "MATCH_NAME", + "MATCH_NAME_GLOB", "MATCH_PHRASE", "MATCH_PHRASE_EDGE", "MATCH_PHRASE_PREFIX", + "MATCH_REGEXP", "MATERIALIZED", "MAX", "MAXVALUE", "MEMO", "MERGE", + "MID", "MIGRATE", "MIGRATIONS", "MIN", "MINUS", "MINUTE", "MINUTES", + "MINUTE_SECOND", "MODIFY", "MONTH", "MTMV", "NAME", "NAMES", "NATURAL", + "NEGATIVE", "NEVER", "NEXT", "NGRAM_BF", "ANN", "NO", "NO_USE_MV", "NON_NULLABLE", + "NOT", "NULL", "NULLS", "OBSERVER", "OF", "OFFSET", "ON", "OFF", "ONLY", + "OPEN", "OPTIMIZE", "OPTIMIZED", "OR", "ORDER", "OUTER", "OUTFILE", + "OVER", "OVERWRITE", "PARAMETER", "PARSED", "PARTITION", "PARTITIONS", + "PASSWORD", "PASSWORD_EXPIRE", "PASSWORD_HISTORY", "PASSWORD_LOCK_TIME", + "PASSWORD_REUSE", "PATH", "PAUSE", "PERCENT", "PERIOD", "PERMISSIVE", + "PHYSICAL", "PI", "PLACEHOLDER", "PLAN", "PLAY", "PRIVILEGES", "PROCESS", + "PLUGIN", "PLUGINS", "POLICY", "POSITION", "PRECEDING", "PREPARE", "PRIMARY", + "PROC", "PROCEDURE", "PROCESSLIST", "PROFILE", "PROPERTIES", "PROPERTY", + "QUANTILE_STATE", "QUANTILE_UNION", "QUERY", "QUEUED", "QUOTA", "QUALIFY", + "QUARTER", "RANDOM", "RANGE", "READ", "REAL", "REBALANCE", "RECENT", + "RECOVER", "RECYCLE", "REFRESH", "REFERENCES", "REGEXP", "RELEASE", + "RENAME", "REPAIR", "REPEATABLE", "REPLACE", "REPLACE_IF_NOT_NULL", + "REPLAYER", "REPLICA", "REPOSITORIES", "REPOSITORY", "RESOURCE", "RESOURCES", + "RESTORE", "RESTRICTIVE", "RESUME", "RETAIN", "RETENTION", "RETURNS", + "REVOKE", "REWRITTEN", "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK", + "ROLLUP", "ROOT", "ROTATE", "ROUTINE", "ROW", "ROWS", "S3", "SAMPLE", + "SCHEDULE", "SCHEDULER", "SCHEMA", "SCHEMAS", "SECOND", "SELECT", "SEMI", + "SEPARATOR", "SERIALIZABLE", "SESSION", "SESSION_USER", "SET", "SETS", + "SET_SESSION_VARIABLE", "SHAPE", "SHOW", "SIGNED", "SKEW", "SMALLINT", + "SNAPSHOT", "SNAPSHOTS", "SONAME", "SPLIT", "SQL", "SQL_BLOCK_RULE", + "STAGE", "STAGES", "START", "STARTS", "STATS", "STATUS", "STOP", "STORAGE", + "STREAM", "STREAMING", "STRING", "STRUCT", "SUBSTR", "SUBSTRING", "SUM", + "SUPERUSER", "SWITCH", "SYNC", "SYSTEM", "TABLE", "TABLES", "TABLESAMPLE", + "TABLET", "TABLETS", "TAG", "TASK", "TASKS", "TDE", "TEMPORARY", "TERMINATED", + "TEXT", "THAN", "THEN", "TIME", "TIMESTAMP", "TINYINT", "TO", "TOKENIZER", + "TOKEN_FILTER", "TRAILING", "TRANSACTION", "TRASH", "TREE", "TRIGGERS", + "TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "TYPECAST", "TYPES", + "UNBOUNDED", "UNCOMMITTED", "UNINSTALL", "UNION", "UNIQUE", "UNLOCK", + "UNSET", "UNSIGNED", "UP", "UPDATE", "USE", "USER", "USE_MV", "USING", + "VALUE", "VALUES", "VARBINARY", "VARCHAR", "VARIABLE", "VARIABLES", + "VARIANT", "VAULT", "VAULTS", "VERBOSE", "VERSION", "VIEW", "VIEWS", + "WARM", "WARNINGS", "WEEK", "WHEN", "WHERE", "WHITELIST", "WITH", "WORK", + "WORKLOAD", "WRITE", "XOR", "YEAR", "EQ", "NSEQ", "NEQ", "LT", "LTE", + "GT", "GTE", "PLUS", "SUBTRACT", "ASTERISK", "SLASH", "MOD", "TILDE", + "AMPERSAND", "LOGICALAND", "LOGICALNOT", "PIPE", "DOUBLEPIPES", "HAT", + "COLON", "ARROW", "HINT_START", "HINT_END", "COMMENT_START", "ATSIGN", + "DOUBLEATSIGN", "STRING_LITERAL", "VARBINARY_LITERAL", "LEADING_STRING", + "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", + "EXPONENT_VALUE", "DECIMAL_VALUE", "BIGDECIMAL_LITERAL", "IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "FROM_DUAL", + "WS", "UNRECOGNIZED", "GET_FORMAT", + } + staticData.RuleNames = []string{ + "multiStatements", "singleStatement", "expressionWithEof", "statement", + "statementBase", "materializedViewStatement", "supportedJobStatement", + "constraintStatement", "optSpecBranch", "supportedDmlStatement", "mergeMatchedClause", + "mergeNotMatchedClause", "supportedCreateStatement", "dictionaryColumnDefs", + "dictionaryColumnDef", "supportedAlterStatement", "supportedDropStatement", + "supportedShowStatement", "supportedLoadStatement", "supportedKillStatement", + "supportedOtherStatement", "warmUpItem", "warmUpSingleTableRef", "lockTable", + "createRoutineLoad", "loadProperty", "importSequenceStatement", "importDeleteOnStatement", + "importWhereStatement", "importPrecedingFilterStatement", "importColumnsStatement", + "importColumnDesc", "supportedRefreshStatement", "supportedCleanStatement", + "supportedCancelStatement", "supportedAdminStatement", "supportedRecoverStatement", + "baseTableRef", "wildWhere", "supportedTransactionStatement", "supportedGrantRevokeStatement", + "privilege", "privilegeList", "alterSystemClause", "dropRollupClause", + "addRollupClause", "alterTableClause", "createOrReplaceTagClause", "createOrReplaceBranchClause", + "tagOptions", "branchOptions", "retainTime", "retentionSnapshot", "minSnapshotsToKeep", + "timeValueWithUnit", "dropBranchClause", "dropTagClause", "partitionTransform", + "columnPosition", "toRollup", "fromRollup", "supportedStatsStatement", + "analyzeProperties", "workloadPolicyActions", "workloadPolicyAction", + "workloadPolicyConditions", "workloadPolicyCondition", "storageBackend", + "passwordOption", "functionArguments", "dataTypeList", "supportedSetStatement", + "optionWithType", "optionWithoutType", "variable", "transactionAccessMode", + "isolationLevel", "supportedUnsetStatement", "supportedUseStatement", + "stageAndPattern", "supportedDescribeStatement", "constraint", "partitionSpec", + "partitionTable", "identityOrFunctionList", "identityOrFunction", "dataDesc", + "statementScope", "buildMode", "refreshTrigger", "refreshSchedule", + "refreshMethod", "mvPartition", "identifierOrText", "identifierOrTextOrAsterisk", + "multipartIdentifierOrAsterisk", "identifierOrAsterisk", "userIdentify", + "grantUserIdentify", "explain", "explainCommand", "planType", "replayCommand", + "replayType", "mergeType", "preFilterClause", "deleteOnClause", "sequenceColClause", + "colFromPath", "colMappingList", "mappingExpr", "withRemoteStorageSystem", + "resourceDesc", "mysqlDataDesc", "skipLines", "outFileClause", "query", + "queryTerm", "setQuantifier", "queryPrimary", "querySpecification", + "cte", "aliasQuery", "columnAliases", "selectClause", "selectColumnClause", + "whereClause", "fromClause", "intoClause", "bulkCollectClause", "tableRow", + "relations", "relation", "joinRelation", "distributeType", "skewHint", + "constantList", "relationHint", "expressionWithOrder", "aggClause", + "groupingElement", "groupingSet", "havingClause", "qualifyClause", "selectHint", + "hintStatement", "hintName", "hintAssignment", "updateAssignment", "updateAssignmentSeq", + "lateralView", "queryOrganization", "sortClause", "sortItem", "limitClause", + "partitionClause", "joinType", "joinCriteria", "identifierList", "identifierSeq", + "optScanParams", "relationPrimary", "materializedViewName", "propertyClause", + "propertyItemList", "propertyItem", "propertyKey", "propertyValue", + "tableAlias", "multipartIdentifier", "simpleColumnDefs", "simpleColumnDef", + "columnDefs", "columnDef", "indexDefs", "indexDef", "partitionsDef", + "partitionDef", "lessThanPartitionDef", "fixedPartitionDef", "stepPartitionDef", + "inPartitionDef", "partitionValueList", "partitionValueDef", "rollupDefs", + "rollupDef", "aggTypeDef", "tabletList", "inlineTable", "namedExpression", + "namedExpressionSeq", "expression", "funcExpression", "lambdaExpression", + "booleanExpression", "rowConstructor", "rowConstructorItem", "predicate", + "valueExpression", "primaryExpression", "exceptOrReplace", "castDataType", + "functionCallExpression", "functionIdentifier", "functionNameIdentifier", + "windowSpec", "windowFrame", "frameUnits", "frameBoundary", "qualifiedName", + "specifiedPartition", "constant", "comparisonOperator", "booleanValue", + "whenClause", "interval", "unitIdentifier", "dataTypeWithNullable", + "dataType", "primitiveColType", "complexColTypeList", "complexColType", + "variantTypeDefinitions", "variantSubColTypeList", "variantSubColType", + "variantSubColMatchType", "commentSpec", "sample", "sampleMethod", "tableSnapshot", + "errorCapturingIdentifier", "errorCapturingIdentifierExtra", "identifier", + "strictIdentifier", "quotedIdentifier", "number", "nonReserved", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 586, 6774, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, + 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, + 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, + 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, + 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, + 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, + 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, + 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, + 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, + 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, + 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, + 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, + 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, + 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, + 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, + 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, + 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, + 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, + 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, + 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, + 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, + 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, + 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, + 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, + 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, + 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, + 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, + 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, + 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, + 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, + 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, + 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, + 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, + 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, + 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, + 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, + 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, + 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, + 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, + 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, + 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, + 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, + 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, + 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, + 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, + 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, + 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, + 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, + 234, 2, 235, 7, 235, 2, 236, 7, 236, 1, 0, 5, 0, 476, 8, 0, 10, 0, 12, + 0, 479, 9, 0, 1, 0, 3, 0, 482, 8, 0, 1, 0, 4, 0, 485, 8, 0, 11, 0, 12, + 0, 486, 1, 0, 5, 0, 490, 8, 0, 10, 0, 12, 0, 493, 9, 0, 1, 0, 5, 0, 496, + 8, 0, 10, 0, 12, 0, 499, 9, 0, 1, 0, 1, 0, 1, 1, 5, 1, 504, 8, 1, 10, 1, + 12, 1, 507, 9, 1, 1, 1, 3, 1, 510, 8, 1, 1, 1, 5, 1, 513, 8, 1, 10, 1, + 12, 1, 516, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, + 1, 3, 1, 3, 1, 3, 5, 3, 530, 8, 3, 10, 3, 12, 3, 533, 9, 3, 3, 3, 535, + 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 543, 8, 3, 1, 3, 3, 3, + 546, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 552, 8, 3, 10, 3, 12, 3, 555, + 9, 3, 1, 3, 1, 3, 5, 3, 559, 8, 3, 10, 3, 12, 3, 562, 9, 3, 1, 3, 1, 3, + 1, 3, 1, 3, 3, 3, 568, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, + 3, 3, 577, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 584, 8, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 3, 3, 591, 8, 3, 1, 3, 1, 3, 3, 3, 595, 8, 3, 3, 3, + 597, 8, 3, 1, 4, 3, 4, 600, 8, 4, 1, 4, 1, 4, 3, 4, 604, 8, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 629, 8, + 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 637, 8, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 3, 5, 644, 8, 5, 1, 5, 3, 5, 647, 8, 5, 1, 5, 1, 5, 3, 5, + 651, 8, 5, 1, 5, 3, 5, 654, 8, 5, 3, 5, 656, 8, 5, 1, 5, 3, 5, 659, 8, + 5, 1, 5, 1, 5, 3, 5, 663, 8, 5, 1, 5, 1, 5, 3, 5, 667, 8, 5, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 675, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, + 3, 5, 682, 8, 5, 1, 5, 1, 5, 3, 5, 686, 8, 5, 3, 5, 688, 8, 5, 1, 5, 3, + 5, 691, 8, 5, 1, 5, 3, 5, 694, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 5, 3, 5, 705, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 719, 8, 5, 1, 5, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 5, 3, 5, 727, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, + 734, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 741, 8, 5, 1, 5, 1, 5, 1, + 5, 3, 5, 746, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 3, 5, 772, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 778, + 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 789, + 8, 6, 3, 6, 791, 8, 6, 1, 6, 1, 6, 3, 6, 795, 8, 6, 1, 6, 1, 6, 1, 6, 3, + 6, 800, 8, 6, 3, 6, 802, 8, 6, 3, 6, 804, 8, 6, 1, 6, 3, 6, 807, 8, 6, + 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, + 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 827, 8, 6, 1, 6, 1, 6, 1, 6, + 1, 6, 3, 6, 833, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, + 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, + 1, 6, 1, 6, 1, 6, 3, 6, 858, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, + 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, + 1, 7, 3, 7, 879, 8, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 3, 9, + 888, 8, 9, 1, 9, 3, 9, 891, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 897, 8, + 9, 1, 9, 1, 9, 3, 9, 901, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 907, 8, 9, + 1, 9, 3, 9, 910, 8, 9, 1, 9, 1, 9, 1, 9, 3, 9, 915, 8, 9, 1, 9, 3, 9, 918, + 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 924, 8, 9, 1, 9, 1, 9, 3, 9, 928, 8, + 9, 1, 9, 3, 9, 931, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 939, + 8, 9, 1, 9, 3, 9, 942, 8, 9, 1, 9, 3, 9, 945, 8, 9, 1, 9, 3, 9, 948, 8, + 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 954, 8, 9, 1, 9, 1, 9, 1, 9, 3, 9, 959, + 8, 9, 1, 9, 3, 9, 962, 8, 9, 1, 9, 3, 9, 965, 8, 9, 1, 9, 3, 9, 968, 8, + 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 974, 8, 9, 1, 9, 3, 9, 977, 8, 9, 1, 9, + 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 4, 9, 985, 8, 9, 11, 9, 12, 9, 986, 1, 9, + 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 996, 8, 9, 10, 9, 12, 9, 999, + 9, 9, 1, 9, 1, 9, 3, 9, 1003, 8, 9, 1, 9, 3, 9, 1006, 8, 9, 1, 9, 3, 9, + 1009, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1016, 8, 9, 1, 9, 3, 9, + 1019, 8, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1024, 8, 9, 1, 9, 3, 9, 1027, 8, 9, + 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1033, 8, 9, 1, 9, 1, 9, 3, 9, 1037, 8, 9, + 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1047, 8, 9, 1, 9, + 1, 9, 3, 9, 1051, 8, 9, 1, 9, 3, 9, 1054, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, + 3, 9, 1060, 8, 9, 1, 9, 3, 9, 1063, 8, 9, 3, 9, 1065, 8, 9, 1, 10, 1, 10, + 1, 10, 1, 10, 3, 10, 1071, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, + 10, 1078, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1085, 8, 11, + 1, 11, 1, 11, 1, 11, 3, 11, 1090, 8, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, + 12, 3, 12, 1097, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1103, 8, 12, + 1, 12, 1, 12, 3, 12, 1107, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1113, + 8, 12, 1, 12, 3, 12, 1116, 8, 12, 1, 12, 1, 12, 3, 12, 1120, 8, 12, 1, + 12, 1, 12, 1, 12, 3, 12, 1125, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, + 1, 12, 3, 12, 1133, 8, 12, 3, 12, 1135, 8, 12, 1, 12, 1, 12, 3, 12, 1139, + 8, 12, 1, 12, 3, 12, 1142, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, + 12, 1149, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1154, 8, 12, 3, 12, 1156, + 8, 12, 3, 12, 1158, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1165, + 8, 12, 1, 12, 3, 12, 1168, 8, 12, 1, 12, 1, 12, 3, 12, 1172, 8, 12, 1, + 12, 3, 12, 1175, 8, 12, 1, 12, 3, 12, 1178, 8, 12, 1, 12, 1, 12, 1, 12, + 3, 12, 1183, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1189, 8, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1196, 8, 12, 1, 12, 1, 12, 3, 12, + 1200, 8, 12, 1, 12, 3, 12, 1203, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 3, 12, 1212, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1217, + 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1223, 8, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 3, 12, 1231, 8, 12, 3, 12, 1233, 8, 12, 1, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1240, 8, 12, 1, 12, 1, 12, 1, 12, 3, + 12, 1245, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1253, + 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1258, 8, 12, 1, 12, 3, 12, 1261, 8, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1268, 8, 12, 1, 12, 1, 12, + 1, 12, 1, 12, 3, 12, 1274, 8, 12, 1, 12, 1, 12, 3, 12, 1278, 8, 12, 1, + 12, 3, 12, 1281, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, + 1289, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 3, 12, 1300, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1313, 8, 12, 1, 12, 1, 12, 3, 12, 1317, + 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1322, 8, 12, 1, 12, 1, 12, 1, 12, 3, + 12, 1327, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1334, 8, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1342, 8, 12, 1, 12, 3, + 12, 1345, 8, 12, 1, 12, 1, 12, 3, 12, 1349, 8, 12, 1, 12, 1, 12, 1, 12, + 1, 12, 1, 12, 1, 12, 3, 12, 1357, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 3, 12, 1365, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, + 1372, 8, 12, 1, 12, 3, 12, 1375, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 3, 12, 1382, 8, 12, 1, 12, 1, 12, 3, 12, 1386, 8, 12, 1, 12, 1, 12, + 1, 12, 1, 12, 1, 12, 3, 12, 1393, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 3, 12, 1401, 8, 12, 1, 12, 3, 12, 1404, 8, 12, 1, 12, 1, 12, + 1, 12, 1, 12, 3, 12, 1410, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1415, 8, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1422, 8, 12, 1, 12, 3, 12, + 1425, 8, 12, 1, 12, 1, 12, 3, 12, 1429, 8, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 3, 12, 1436, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1441, 8, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1448, 8, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1459, 8, 12, 1, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1466, 8, 12, 1, 12, 1, 12, 3, 12, 1470, + 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1477, 8, 12, 1, 12, 1, + 12, 3, 12, 1481, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1486, 8, 12, 1, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1495, 8, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 3, 12, 1501, 8, 12, 1, 12, 1, 12, 3, 12, 1505, 8, 12, + 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1512, 8, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1525, + 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1532, 8, 12, 1, 12, 1, + 12, 3, 12, 1536, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, + 1544, 8, 12, 1, 12, 1, 12, 3, 12, 1548, 8, 12, 1, 12, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 3, 12, 1557, 8, 12, 1, 12, 1, 12, 3, 12, 1561, + 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1570, 8, + 12, 1, 12, 1, 12, 3, 12, 1574, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, + 1, 12, 1, 12, 3, 12, 1583, 8, 12, 1, 12, 1, 12, 3, 12, 1587, 8, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1596, 8, 12, 1, 12, + 1, 12, 3, 12, 1600, 8, 12, 3, 12, 1602, 8, 12, 1, 13, 1, 13, 1, 13, 5, + 13, 1607, 8, 13, 10, 13, 12, 13, 1610, 9, 13, 1, 14, 1, 14, 1, 14, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 3, 15, 1627, 8, 15, 1, 15, 1, 15, 3, 15, 1631, 8, 15, 1, 15, 1, 15, + 3, 15, 1635, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1660, 8, 15, 1, 15, 3, 15, 1663, + 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1670, 8, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 3, 15, 1686, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1692, + 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1719, 8, 15, 10, 15, 12, 15, + 1722, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1731, + 8, 15, 1, 15, 1, 15, 3, 15, 1735, 8, 15, 1, 15, 1, 15, 3, 15, 1739, 8, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1749, + 8, 15, 10, 15, 12, 15, 1752, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 5, 15, 1762, 8, 15, 10, 15, 12, 15, 1765, 9, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1783, 8, 15, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1806, 8, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1812, 8, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1822, 8, 15, 10, 15, 12, 15, + 1825, 9, 15, 3, 15, 1827, 8, 15, 1, 15, 3, 15, 1830, 8, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1838, 8, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, + 1853, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1859, 8, 15, 3, 15, 1861, + 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 3, 16, 1875, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, + 3, 16, 1882, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1889, 8, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1896, 8, 16, 1, 16, 1, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1904, 8, 16, 1, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 3, 16, 1912, 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1917, + 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1923, 8, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 3, 16, 1931, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, + 1, 16, 1, 16, 3, 16, 1939, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, + 16, 3, 16, 1947, 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1952, 8, 16, 1, 16, + 1, 16, 3, 16, 1956, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1962, 8, + 16, 1, 16, 1, 16, 3, 16, 1966, 8, 16, 1, 16, 1, 16, 3, 16, 1970, 8, 16, + 1, 16, 1, 16, 1, 16, 3, 16, 1975, 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1980, + 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1988, 8, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1998, 8, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 2006, 8, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 2015, 8, 16, 3, 16, 2017, + 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 2023, 8, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 3, 16, 2030, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, + 3, 16, 2037, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, + 16, 2046, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, + 2055, 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 2064, + 8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 2073, 8, + 16, 1, 16, 3, 16, 2076, 8, 16, 1, 17, 1, 17, 3, 17, 2080, 8, 17, 1, 17, + 1, 17, 3, 17, 2084, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 3, 17, 2095, 8, 17, 1, 17, 1, 17, 3, 17, 2099, 8, 17, + 1, 17, 3, 17, 2102, 8, 17, 1, 17, 3, 17, 2105, 8, 17, 1, 17, 3, 17, 2108, + 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2118, + 8, 17, 1, 17, 3, 17, 2121, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 3, 17, 2130, 8, 17, 1, 17, 3, 17, 2133, 8, 17, 1, 17, 3, 17, + 2136, 8, 17, 1, 17, 3, 17, 2139, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 3, 17, 2147, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2153, + 8, 17, 1, 17, 3, 17, 2156, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2162, + 8, 17, 1, 17, 3, 17, 2165, 8, 17, 1, 17, 3, 17, 2168, 8, 17, 1, 17, 3, + 17, 2171, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, + 2180, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2186, 8, 17, 1, 17, 1, + 17, 1, 17, 3, 17, 2191, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2197, + 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2202, 8, 17, 1, 17, 1, 17, 3, 17, 2206, + 8, 17, 1, 17, 3, 17, 2209, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2214, 8, + 17, 1, 17, 1, 17, 3, 17, 2218, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2223, + 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2228, 8, 17, 1, 17, 1, 17, 3, 17, 2232, + 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2248, 8, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 3, 17, 2254, 8, 17, 1, 17, 3, 17, 2257, 8, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2270, + 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 3, 17, 2283, 8, 17, 1, 17, 1, 17, 3, 17, 2287, 8, 17, 1, 17, + 1, 17, 3, 17, 2291, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2298, + 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2303, 8, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 3, 17, 2309, 8, 17, 1, 17, 3, 17, 2312, 8, 17, 1, 17, 3, 17, 2315, + 8, 17, 1, 17, 1, 17, 3, 17, 2319, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2324, + 8, 17, 1, 17, 3, 17, 2327, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2343, + 8, 17, 1, 17, 1, 17, 3, 17, 2347, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2360, 8, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 3, 17, 2366, 8, 17, 1, 17, 1, 17, 3, 17, 2370, 8, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2377, 8, 17, 1, 17, 1, 17, + 1, 17, 3, 17, 2382, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 3, 17, 2391, 8, 17, 3, 17, 2393, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 3, 17, 2401, 8, 17, 3, 17, 2403, 8, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 3, 17, 2409, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2426, + 8, 17, 1, 17, 1, 17, 3, 17, 2430, 8, 17, 1, 17, 3, 17, 2433, 8, 17, 1, + 17, 3, 17, 2436, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2449, 8, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2469, 8, 17, 1, 17, 3, 17, 2472, 8, + 17, 1, 17, 3, 17, 2475, 8, 17, 1, 17, 1, 17, 3, 17, 2479, 8, 17, 1, 17, + 1, 17, 1, 17, 3, 17, 2484, 8, 17, 1, 17, 3, 17, 2487, 8, 17, 1, 17, 3, + 17, 2490, 8, 17, 1, 17, 3, 17, 2493, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 3, 17, 2500, 8, 17, 1, 17, 3, 17, 2503, 8, 17, 1, 17, 3, 17, 2506, + 8, 17, 1, 17, 1, 17, 3, 17, 2510, 8, 17, 1, 17, 1, 17, 3, 17, 2514, 8, + 17, 1, 17, 1, 17, 1, 17, 3, 17, 2519, 8, 17, 1, 17, 3, 17, 2522, 8, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2533, + 8, 17, 1, 17, 3, 17, 2536, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2541, 8, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2548, 8, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 3, 17, 2555, 8, 17, 1, 17, 3, 17, 2558, 8, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2567, 8, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 3, 17, 2573, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, + 17, 2579, 8, 17, 1, 17, 1, 17, 3, 17, 2583, 8, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 5, 17, 2594, 8, 17, 10, 17, 12, + 17, 2597, 9, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 1, 17, 3, 17, 2609, 8, 17, 1, 17, 1, 17, 3, 17, 2613, 8, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2620, 8, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 3, 17, 2626, 8, 17, 1, 17, 3, 17, 2629, 8, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 3, 17, 2635, 8, 17, 1, 17, 1, 17, 3, 17, 2639, 8, 17, 1, 17, + 1, 17, 1, 17, 3, 17, 2644, 8, 17, 1, 17, 3, 17, 2647, 8, 17, 1, 17, 1, + 17, 3, 17, 2651, 8, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2656, 8, 17, 1, 17, + 3, 17, 2659, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2666, 8, + 17, 1, 17, 3, 17, 2669, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2675, + 8, 17, 1, 17, 3, 17, 2678, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, + 17, 2685, 8, 17, 1, 17, 3, 17, 2688, 8, 17, 1, 17, 3, 17, 2691, 8, 17, + 1, 17, 3, 17, 2694, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, + 17, 2702, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2710, + 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2716, 8, 17, 1, 17, 3, 17, 2719, + 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2727, 8, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2734, 8, 17, 1, 17, 1, 17, 1, 17, + 1, 17, 3, 17, 2740, 8, 17, 1, 17, 3, 17, 2743, 8, 17, 1, 17, 3, 17, 2746, + 8, 17, 1, 17, 3, 17, 2749, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 3, 17, 2760, 8, 17, 3, 17, 2762, 8, 17, 3, 17, + 2764, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2772, 8, + 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2779, 8, 17, 3, 17, 2781, + 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 2797, 8, 18, 1, 18, 3, 18, 2800, + 8, 18, 1, 18, 1, 18, 3, 18, 2804, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, + 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 2836, 8, 18, 1, 18, 1, 18, 1, 18, + 1, 18, 1, 18, 1, 18, 3, 18, 2844, 8, 18, 3, 18, 2846, 8, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 2854, 8, 18, 1, 18, 3, 18, 2857, + 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 2875, 8, 18, 1, 19, + 1, 19, 3, 19, 2879, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 2885, 8, + 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, + 2896, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, + 20, 2906, 8, 20, 10, 20, 12, 20, 2909, 9, 20, 3, 20, 2911, 8, 20, 1, 20, + 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 2923, + 8, 20, 10, 20, 12, 20, 2926, 9, 20, 1, 20, 1, 20, 3, 20, 2930, 8, 20, 1, + 20, 3, 20, 2933, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2940, + 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2947, 8, 20, 1, 20, 1, + 20, 1, 20, 1, 20, 5, 20, 2953, 8, 20, 10, 20, 12, 20, 2956, 9, 20, 3, 20, + 2958, 8, 20, 1, 20, 3, 20, 2961, 8, 20, 1, 20, 3, 20, 2964, 8, 20, 1, 20, + 3, 20, 2967, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, + 20, 2976, 8, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 5, 20, 2988, 8, 20, 10, 20, 12, 20, 2991, 9, 20, 1, 20, 1, + 20, 3, 20, 2995, 8, 20, 1, 20, 3, 20, 2998, 8, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 3, 20, 3005, 8, 20, 3, 20, 3007, 8, 20, 1, 21, 1, 21, 1, + 21, 1, 21, 3, 21, 3013, 8, 21, 1, 22, 1, 22, 3, 22, 3017, 8, 22, 1, 23, + 1, 23, 1, 23, 3, 23, 3022, 8, 23, 1, 23, 1, 23, 3, 23, 3026, 8, 23, 1, + 23, 3, 23, 3029, 8, 23, 1, 23, 3, 23, 3032, 8, 23, 1, 24, 1, 24, 1, 24, + 1, 24, 1, 24, 1, 24, 3, 24, 3040, 8, 24, 1, 24, 1, 24, 3, 24, 3044, 8, + 24, 1, 24, 1, 24, 1, 24, 5, 24, 3049, 8, 24, 10, 24, 12, 24, 3052, 9, 24, + 3, 24, 3054, 8, 24, 1, 24, 3, 24, 3057, 8, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 1, 24, 3, 24, 3065, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, + 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 3077, 8, 25, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, + 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 3099, 8, 30, 10, + 30, 12, 30, 3102, 9, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 3, 31, 3109, + 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 3115, 8, 31, 1, 31, 1, 31, 3, + 31, 3119, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 3125, 8, 32, 1, 32, + 1, 32, 1, 32, 1, 32, 3, 32, 3131, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, + 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 3144, 8, 32, 3, 32, + 3146, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 3154, 8, + 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, + 3165, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 3171, 8, 33, 1, 34, 1, + 34, 1, 34, 1, 34, 3, 34, 3177, 8, 34, 1, 34, 3, 34, 3180, 8, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 3, 34, 3186, 8, 34, 1, 34, 3, 34, 3189, 8, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 3196, 8, 34, 1, 34, 1, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 5, 34, 3204, 8, 34, 10, 34, 12, 34, 3207, 9, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 3, 34, 3213, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, + 3, 34, 3219, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 34, 5, 34, 3230, 8, 34, 10, 34, 12, 34, 3233, 9, 34, 1, 34, 3, 34, + 3236, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 3245, + 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 3253, 8, 34, 10, + 34, 12, 34, 3256, 9, 34, 1, 34, 3, 34, 3259, 8, 34, 3, 34, 3261, 8, 34, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 5, 35, 3277, 8, 35, 10, 35, 12, 35, 3280, 9, 35, + 1, 35, 3, 35, 3283, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 5, 35, 3294, 8, 35, 10, 35, 12, 35, 3297, 9, 35, 1, 35, + 3, 35, 3300, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3317, 8, 35, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3327, 8, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3333, 8, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 3, 35, 3341, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 3, 35, 3348, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3355, + 8, 35, 1, 35, 3, 35, 3358, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 5, 35, 3368, 8, 35, 10, 35, 12, 35, 3371, 9, 35, 1, 35, + 3, 35, 3374, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3391, 8, 35, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 3, 35, 3416, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 3, 35, 3435, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3442, + 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 3450, 8, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, + 35, 3473, 8, 35, 3, 35, 3475, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, + 3481, 8, 36, 1, 36, 1, 36, 3, 36, 3485, 8, 36, 1, 36, 1, 36, 1, 36, 1, + 36, 3, 36, 3491, 8, 36, 1, 36, 1, 36, 3, 36, 3495, 8, 36, 1, 36, 1, 36, + 1, 36, 1, 36, 3, 36, 3501, 8, 36, 1, 36, 1, 36, 3, 36, 3505, 8, 36, 1, + 36, 1, 36, 1, 36, 3, 36, 3510, 8, 36, 1, 37, 1, 37, 3, 37, 3514, 8, 37, + 1, 37, 3, 37, 3517, 8, 37, 1, 37, 3, 37, 3520, 8, 37, 1, 37, 3, 37, 3523, + 8, 37, 1, 37, 1, 37, 3, 37, 3527, 8, 37, 1, 37, 3, 37, 3530, 8, 37, 1, + 38, 1, 38, 1, 38, 1, 38, 3, 38, 3536, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, + 3, 39, 3542, 8, 39, 3, 39, 3544, 8, 39, 1, 39, 1, 39, 3, 39, 3548, 8, 39, + 1, 39, 1, 39, 3, 39, 3552, 8, 39, 1, 39, 3, 39, 3555, 8, 39, 1, 39, 3, + 39, 3558, 8, 39, 1, 39, 3, 39, 3561, 8, 39, 1, 39, 1, 39, 3, 39, 3565, + 8, 39, 1, 39, 1, 39, 3, 39, 3569, 8, 39, 1, 39, 3, 39, 3572, 8, 39, 1, + 39, 3, 39, 3575, 8, 39, 1, 39, 3, 39, 3578, 8, 39, 3, 39, 3580, 8, 39, + 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 3590, 8, + 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, + 1, 40, 1, 40, 3, 40, 3604, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, + 40, 3611, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 5, 40, 3617, 8, 40, 10, 40, + 12, 40, 3620, 9, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 5, + 40, 3629, 8, 40, 10, 40, 12, 40, 3632, 9, 40, 1, 40, 1, 40, 1, 40, 1, 40, + 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, + 40, 3, 40, 3649, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 3656, + 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 3666, + 8, 40, 3, 40, 3668, 8, 40, 1, 41, 1, 41, 3, 41, 3672, 8, 41, 1, 41, 3, + 41, 3675, 8, 41, 1, 42, 1, 42, 1, 42, 5, 42, 3680, 8, 42, 10, 42, 12, 42, + 3683, 9, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 3690, 8, 43, 10, + 43, 12, 43, 3693, 9, 43, 1, 43, 3, 43, 3696, 8, 43, 1, 43, 1, 43, 1, 43, + 1, 43, 1, 43, 5, 43, 3703, 8, 43, 10, 43, 12, 43, 3706, 9, 43, 1, 43, 1, + 43, 1, 43, 1, 43, 1, 43, 5, 43, 3713, 8, 43, 10, 43, 12, 43, 3716, 9, 43, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, + 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 3736, 8, 43, + 10, 43, 12, 43, 3739, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, + 5, 43, 3747, 8, 43, 10, 43, 12, 43, 3750, 9, 43, 1, 43, 1, 43, 1, 43, 1, + 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 3761, 8, 43, 1, 43, 1, 43, + 1, 43, 1, 43, 1, 43, 5, 43, 3768, 8, 43, 10, 43, 12, 43, 3771, 9, 43, 1, + 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, + 3783, 8, 43, 1, 44, 1, 44, 3, 44, 3787, 8, 44, 1, 45, 1, 45, 1, 45, 1, + 45, 1, 45, 3, 45, 3794, 8, 45, 1, 45, 3, 45, 3797, 8, 45, 1, 45, 3, 45, + 3800, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 3806, 8, 46, 1, 46, 3, + 46, 3809, 8, 46, 1, 46, 3, 46, 3812, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, + 1, 46, 1, 46, 3, 46, 3820, 8, 46, 1, 46, 3, 46, 3823, 8, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 3, 46, 3829, 8, 46, 1, 46, 3, 46, 3832, 8, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 3, 46, 3838, 8, 46, 1, 46, 3, 46, 3841, 8, 46, 1, + 46, 3, 46, 3844, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 3850, 8, 46, + 1, 46, 3, 46, 3853, 8, 46, 1, 46, 1, 46, 3, 46, 3857, 8, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 3865, 8, 46, 1, 46, 1, 46, 1, 46, + 3, 46, 3870, 8, 46, 3, 46, 3872, 8, 46, 3, 46, 3874, 8, 46, 1, 46, 3, 46, + 3877, 8, 46, 1, 46, 1, 46, 3, 46, 3881, 8, 46, 1, 46, 1, 46, 1, 46, 3, + 46, 3886, 8, 46, 1, 46, 1, 46, 3, 46, 3890, 8, 46, 1, 46, 1, 46, 1, 46, + 3, 46, 3895, 8, 46, 1, 46, 1, 46, 3, 46, 3899, 8, 46, 1, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 3, 46, 3907, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 3, 46, 3916, 8, 46, 1, 46, 1, 46, 3, 46, 3920, 8, + 46, 1, 46, 3, 46, 3923, 8, 46, 1, 46, 3, 46, 3926, 8, 46, 1, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 3, 46, 3933, 8, 46, 1, 46, 3, 46, 3936, 8, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, + 46, 1, 46, 3, 46, 3961, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, + 3, 46, 3969, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, + 46, 3978, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 3983, 8, 46, 3, 46, 3985, + 8, 46, 3, 46, 3987, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 4003, 8, 46, + 1, 46, 1, 46, 3, 46, 4007, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 3, 46, 4017, 8, 46, 1, 46, 3, 46, 4020, 8, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 4032, + 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 4039, 8, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 3, 46, 4046, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, + 3, 46, 4052, 8, 46, 3, 46, 4054, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 47, 3, 47, 4061, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 4068, + 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 4075, 8, 47, 1, 48, 1, + 48, 1, 48, 1, 48, 1, 48, 3, 48, 4082, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, + 1, 48, 3, 48, 4089, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 4096, + 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 4102, 8, 49, 1, 49, 3, 49, 4105, + 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 4111, 8, 50, 1, 50, 3, 50, 4114, + 8, 50, 1, 50, 3, 50, 4117, 8, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, + 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, + 1, 52, 3, 52, 4136, 8, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, + 55, 1, 55, 1, 55, 1, 55, 3, 55, 4148, 8, 55, 1, 55, 1, 55, 1, 56, 1, 56, + 1, 56, 1, 56, 3, 56, 4156, 8, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, + 4173, 8, 57, 1, 58, 1, 58, 1, 58, 3, 58, 4178, 8, 58, 1, 59, 1, 59, 1, + 59, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 3, 61, 4188, 8, 61, 1, 61, 1, 61, + 1, 61, 3, 61, 4193, 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4200, + 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4207, 8, 61, 1, 61, 1, + 61, 1, 61, 1, 61, 1, 61, 3, 61, 4214, 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, + 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4225, 8, 61, 1, 61, 1, 61, 1, + 61, 3, 61, 4230, 8, 61, 1, 61, 3, 61, 4233, 8, 61, 1, 61, 1, 61, 1, 61, + 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 5, 61, 4245, 8, 61, 10, + 61, 12, 61, 4248, 9, 61, 1, 61, 3, 61, 4251, 8, 61, 1, 61, 1, 61, 1, 61, + 1, 61, 3, 61, 4257, 8, 61, 1, 61, 3, 61, 4260, 8, 61, 1, 61, 1, 61, 5, + 61, 4264, 8, 61, 10, 61, 12, 61, 4267, 9, 61, 1, 61, 3, 61, 4270, 8, 61, + 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4281, + 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4288, 8, 61, 1, 61, 1, + 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4299, 8, 61, + 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, + 61, 4311, 8, 61, 1, 61, 3, 61, 4314, 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, + 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, + 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4335, 8, 61, 1, 61, 3, 61, 4338, + 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 4344, 8, 61, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 4356, 8, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 4364, 8, 62, 1, 63, 1, + 63, 1, 63, 5, 63, 4369, 8, 63, 10, 63, 12, 63, 4372, 9, 63, 1, 64, 1, 64, + 1, 64, 1, 64, 3, 64, 4378, 8, 64, 3, 64, 4380, 8, 64, 1, 65, 1, 65, 1, + 65, 5, 65, 4385, 8, 65, 10, 65, 12, 65, 4388, 9, 65, 1, 66, 1, 66, 1, 66, + 1, 66, 3, 66, 4394, 8, 66, 1, 67, 1, 67, 3, 67, 4398, 8, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 3, 67, 4404, 8, 67, 1, 68, 1, 68, 1, 68, 3, 68, 4409, + 8, 68, 3, 68, 4411, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, + 68, 4419, 8, 68, 3, 68, 4421, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, + 3, 68, 4428, 8, 68, 3, 68, 4430, 8, 68, 1, 68, 1, 68, 3, 68, 4434, 8, 68, + 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 4440, 8, 68, 3, 68, 4442, 8, 68, 1, + 68, 3, 68, 4445, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, + 4453, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 4458, 8, 70, 10, 70, 12, 70, 4461, + 9, 70, 1, 71, 1, 71, 1, 71, 3, 71, 4466, 8, 71, 1, 71, 1, 71, 1, 71, 3, + 71, 4471, 8, 71, 5, 71, 4473, 8, 71, 10, 71, 12, 71, 4476, 9, 71, 1, 71, + 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, + 71, 4489, 8, 71, 1, 71, 1, 71, 1, 71, 3, 71, 4494, 8, 71, 1, 71, 1, 71, + 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 4507, + 8, 71, 3, 71, 4509, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, + 72, 3, 72, 4518, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, + 4526, 8, 73, 1, 73, 1, 73, 3, 73, 4530, 8, 73, 1, 73, 1, 73, 1, 73, 3, + 73, 4535, 8, 73, 1, 73, 1, 73, 1, 73, 3, 73, 4540, 8, 73, 1, 73, 1, 73, + 1, 73, 3, 73, 4545, 8, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, + 73, 4553, 8, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, + 4562, 8, 73, 1, 73, 3, 73, 4565, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 3, + 74, 4571, 8, 74, 3, 74, 4573, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 3, 74, 4581, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 4588, + 8, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, + 76, 1, 76, 1, 76, 3, 76, 4602, 8, 76, 1, 77, 1, 77, 3, 77, 4606, 8, 77, + 1, 77, 1, 77, 1, 77, 3, 77, 4611, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, + 77, 4617, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 4625, + 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 4632, 8, 78, 1, 78, 3, + 78, 4635, 8, 78, 1, 78, 1, 78, 3, 78, 4639, 8, 78, 1, 79, 1, 79, 1, 79, + 3, 79, 4644, 8, 79, 1, 79, 1, 79, 1, 79, 3, 79, 4649, 8, 79, 1, 80, 1, + 80, 1, 80, 1, 80, 1, 80, 3, 80, 4656, 8, 80, 1, 80, 1, 80, 1, 80, 1, 80, + 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 4668, 8, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 3, 80, 4674, 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 4688, 8, 81, 1, + 82, 3, 82, 4691, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 4696, 8, 82, 1, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 4704, 8, 82, 1, 83, 3, 83, 4707, + 8, 83, 1, 83, 1, 83, 1, 83, 3, 83, 4712, 8, 83, 1, 83, 1, 83, 1, 83, 3, + 83, 4717, 8, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 5, 84, 4725, + 8, 84, 10, 84, 12, 84, 4728, 9, 84, 1, 84, 1, 84, 1, 85, 1, 85, 3, 85, + 4734, 8, 85, 1, 86, 3, 86, 4737, 8, 86, 1, 86, 3, 86, 4740, 8, 86, 1, 86, + 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 5, 86, 4748, 8, 86, 10, 86, 12, 86, + 4751, 9, 86, 1, 86, 1, 86, 3, 86, 4755, 8, 86, 1, 86, 1, 86, 1, 86, 1, + 86, 3, 86, 4761, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 4767, 8, 86, + 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 4773, 8, 86, 1, 86, 1, 86, 1, 86, 3, + 86, 4778, 8, 86, 1, 86, 1, 86, 1, 86, 3, 86, 4783, 8, 86, 1, 86, 3, 86, + 4786, 8, 86, 1, 86, 3, 86, 4789, 8, 86, 1, 86, 3, 86, 4792, 8, 86, 1, 86, + 3, 86, 4795, 8, 86, 1, 86, 3, 86, 4798, 8, 86, 1, 86, 3, 86, 4801, 8, 86, + 1, 86, 3, 86, 4804, 8, 86, 1, 86, 3, 86, 4807, 8, 86, 1, 86, 3, 86, 4810, + 8, 86, 1, 86, 3, 86, 4813, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, + 86, 4820, 8, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 4827, 8, 86, + 1, 86, 3, 86, 4830, 8, 86, 1, 86, 3, 86, 4833, 8, 86, 1, 86, 3, 86, 4836, + 8, 86, 1, 86, 3, 86, 4839, 8, 86, 3, 86, 4841, 8, 86, 1, 87, 1, 87, 1, + 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, + 4855, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 4862, 8, 90, 1, + 91, 1, 91, 1, 92, 1, 92, 3, 92, 4868, 8, 92, 1, 93, 1, 93, 3, 93, 4872, + 8, 93, 1, 94, 1, 94, 1, 94, 3, 94, 4877, 8, 94, 1, 95, 1, 95, 1, 95, 5, + 95, 4882, 8, 95, 10, 95, 12, 95, 4885, 9, 95, 1, 96, 1, 96, 3, 96, 4889, + 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 4898, 8, + 97, 3, 97, 4900, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 4906, 8, 98, + 1, 98, 3, 98, 4909, 8, 98, 1, 99, 1, 99, 3, 99, 4913, 8, 99, 1, 99, 3, + 99, 4916, 8, 99, 1, 99, 3, 99, 4919, 8, 99, 1, 100, 1, 100, 1, 101, 1, + 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 3, + 103, 4933, 8, 103, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, + 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, + 5, 109, 4960, 8, 109, 10, 109, 12, 109, 4963, 9, 109, 1, 109, 1, 109, 1, + 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 3, 111, 4997, 8, 111, 3, 111, 4999, 8, 111, 1, 112, + 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 5008, 8, 112, 1, + 113, 1, 113, 3, 113, 5012, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 113, 1, 113, 3, 113, 5021, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, + 113, 5027, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 5033, 8, 113, + 1, 113, 3, 113, 5036, 8, 113, 1, 113, 3, 113, 5039, 8, 113, 1, 113, 3, + 113, 5042, 8, 113, 1, 113, 3, 113, 5045, 8, 113, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 114, 3, 114, 5053, 8, 114, 1, 115, 1, 115, 1, 115, 1, + 115, 1, 115, 1, 115, 3, 115, 5061, 8, 115, 1, 115, 3, 115, 5064, 8, 115, + 1, 116, 3, 116, 5067, 8, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, + 117, 1, 117, 1, 117, 1, 117, 3, 117, 5078, 8, 117, 1, 117, 1, 117, 1, 117, + 1, 117, 3, 117, 5084, 8, 117, 1, 117, 5, 117, 5087, 8, 117, 10, 117, 12, + 117, 5090, 9, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 3, 119, 5100, 8, 119, 1, 120, 1, 120, 3, 120, 5104, 8, 120, 1, + 120, 3, 120, 5107, 8, 120, 1, 120, 3, 120, 5110, 8, 120, 1, 120, 3, 120, + 5113, 8, 120, 1, 120, 3, 120, 5116, 8, 120, 1, 120, 3, 120, 5119, 8, 120, + 1, 120, 3, 120, 5122, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 5, 121, 5128, + 8, 121, 10, 121, 12, 121, 5131, 9, 121, 1, 122, 1, 122, 3, 122, 5135, 8, + 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, + 123, 5, 123, 5146, 8, 123, 10, 123, 12, 123, 5149, 9, 123, 1, 123, 1, 123, + 1, 124, 1, 124, 3, 124, 5155, 8, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, + 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 128, 3, 128, 5168, 8, 128, + 1, 128, 1, 128, 1, 128, 3, 128, 5173, 8, 128, 1, 128, 1, 128, 1, 128, 3, + 128, 5178, 8, 128, 5, 128, 5180, 8, 128, 10, 128, 12, 128, 5183, 9, 128, + 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, + 1, 131, 1, 131, 5, 131, 5196, 8, 131, 10, 131, 12, 131, 5199, 9, 131, 1, + 132, 1, 132, 5, 132, 5203, 8, 132, 10, 132, 12, 132, 5206, 9, 132, 1, 133, + 1, 133, 1, 133, 3, 133, 5211, 8, 133, 1, 133, 1, 133, 3, 133, 5215, 8, + 133, 1, 134, 1, 134, 1, 134, 3, 134, 5220, 8, 134, 1, 134, 1, 134, 1, 134, + 1, 134, 1, 134, 3, 134, 5227, 8, 134, 1, 134, 1, 134, 3, 134, 5231, 8, + 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, + 136, 1, 136, 1, 136, 1, 136, 5, 136, 5245, 8, 136, 10, 136, 12, 136, 5248, + 9, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 5, 137, 5256, 8, + 137, 10, 137, 12, 137, 5259, 9, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 1, 137, 5, 137, 5267, 8, 137, 10, 137, 12, 137, 5270, 9, 137, 1, 137, + 1, 137, 3, 137, 5274, 8, 137, 1, 138, 1, 138, 3, 138, 5278, 8, 138, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, + 140, 5289, 8, 140, 10, 140, 12, 140, 5292, 9, 140, 3, 140, 5294, 8, 140, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 5302, 8, 140, 10, + 140, 12, 140, 5305, 9, 140, 3, 140, 5307, 8, 140, 1, 140, 1, 140, 1, 140, + 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 5316, 8, 140, 10, 140, 12, 140, + 5319, 9, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 5326, 8, + 140, 10, 140, 12, 140, 5329, 9, 140, 1, 140, 1, 140, 3, 140, 5333, 8, 140, + 3, 140, 5335, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 5341, 8, + 141, 10, 141, 12, 141, 5344, 9, 141, 3, 141, 5346, 8, 141, 1, 141, 1, 141, + 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 3, 144, + 5358, 8, 144, 1, 144, 5, 144, 5361, 8, 144, 10, 144, 12, 144, 5364, 9, + 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 5372, 8, 145, + 1, 145, 5, 145, 5375, 8, 145, 10, 145, 12, 145, 5378, 9, 145, 1, 145, 1, + 145, 3, 145, 5382, 8, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 5, 145, + 5389, 8, 145, 10, 145, 12, 145, 5392, 9, 145, 1, 145, 1, 145, 3, 145, 5396, + 8, 145, 3, 145, 5398, 8, 145, 1, 146, 1, 146, 3, 146, 5402, 8, 146, 1, + 147, 1, 147, 3, 147, 5406, 8, 147, 1, 147, 1, 147, 1, 147, 3, 147, 5411, + 8, 147, 3, 147, 5413, 8, 147, 1, 147, 3, 147, 5416, 8, 147, 1, 148, 1, + 148, 1, 148, 1, 148, 3, 148, 5422, 8, 148, 1, 149, 1, 149, 1, 149, 5, 149, + 5427, 8, 149, 10, 149, 12, 149, 5430, 9, 149, 1, 150, 1, 150, 1, 150, 1, + 150, 1, 150, 1, 150, 1, 150, 5, 150, 5439, 8, 150, 10, 150, 12, 150, 5442, + 9, 150, 3, 150, 5444, 8, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, + 150, 5, 150, 5452, 8, 150, 10, 150, 12, 150, 5455, 9, 150, 1, 151, 3, 151, + 5458, 8, 151, 1, 151, 3, 151, 5461, 8, 151, 1, 152, 1, 152, 1, 152, 1, + 152, 1, 152, 5, 152, 5468, 8, 152, 10, 152, 12, 152, 5471, 9, 152, 1, 153, + 1, 153, 3, 153, 5475, 8, 153, 1, 153, 1, 153, 3, 153, 5479, 8, 153, 1, + 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, + 154, 3, 154, 5491, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, + 3, 155, 5499, 8, 155, 1, 155, 1, 155, 1, 155, 5, 155, 5504, 8, 155, 10, + 155, 12, 155, 5507, 9, 155, 1, 156, 3, 156, 5510, 8, 156, 1, 156, 1, 156, + 1, 156, 3, 156, 5515, 8, 156, 1, 156, 1, 156, 3, 156, 5519, 8, 156, 1, + 156, 1, 156, 3, 156, 5523, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 156, 1, 156, 1, 156, 3, 156, 5533, 8, 156, 1, 157, 1, 157, 1, 157, 1, + 157, 3, 157, 5539, 8, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, + 1, 159, 5, 159, 5548, 8, 159, 10, 159, 12, 159, 5551, 9, 159, 1, 160, 1, + 160, 1, 160, 1, 160, 1, 160, 3, 160, 5558, 8, 160, 1, 160, 1, 160, 1, 161, + 1, 161, 3, 161, 5564, 8, 161, 1, 161, 3, 161, 5567, 8, 161, 1, 161, 3, + 161, 5570, 8, 161, 1, 161, 3, 161, 5573, 8, 161, 1, 161, 3, 161, 5576, + 8, 161, 1, 161, 1, 161, 3, 161, 5580, 8, 161, 1, 161, 3, 161, 5583, 8, + 161, 1, 161, 5, 161, 5586, 8, 161, 10, 161, 12, 161, 5589, 9, 161, 1, 161, + 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 5596, 8, 161, 10, 161, 12, 161, + 5599, 9, 161, 1, 161, 1, 161, 1, 161, 3, 161, 5604, 8, 161, 1, 161, 1, + 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 5613, 8, 161, 1, 162, + 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, + 1, 164, 5, 164, 5626, 8, 164, 10, 164, 12, 164, 5629, 9, 164, 1, 165, 1, + 165, 1, 165, 1, 165, 1, 166, 1, 166, 3, 166, 5637, 8, 166, 1, 167, 1, 167, + 3, 167, 5641, 8, 167, 1, 168, 3, 168, 5644, 8, 168, 1, 168, 1, 168, 3, + 168, 5648, 8, 168, 3, 168, 5650, 8, 168, 1, 169, 1, 169, 1, 169, 5, 169, + 5655, 8, 169, 10, 169, 12, 169, 5658, 9, 169, 1, 170, 1, 170, 1, 170, 5, + 170, 5663, 8, 170, 10, 170, 12, 170, 5666, 9, 170, 1, 171, 1, 171, 1, 171, + 3, 171, 5671, 8, 171, 1, 172, 1, 172, 1, 172, 5, 172, 5676, 8, 172, 10, + 172, 12, 172, 5679, 9, 172, 1, 173, 1, 173, 1, 173, 3, 173, 5684, 8, 173, + 1, 173, 3, 173, 5687, 8, 173, 1, 173, 1, 173, 3, 173, 5691, 8, 173, 1, + 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 5698, 8, 173, 1, 173, 3, 173, + 5701, 8, 173, 1, 173, 3, 173, 5704, 8, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 3, 173, 5711, 8, 173, 3, 173, 5713, 8, 173, 1, 173, 1, 173, + 1, 173, 3, 173, 5718, 8, 173, 1, 173, 1, 173, 3, 173, 5722, 8, 173, 1, + 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 3, 173, 5735, 8, 173, 3, 173, 5737, 8, 173, 3, 173, 5739, + 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, + 5748, 8, 173, 3, 173, 5750, 8, 173, 1, 173, 1, 173, 3, 173, 5754, 8, 173, + 1, 174, 1, 174, 1, 174, 5, 174, 5759, 8, 174, 10, 174, 12, 174, 5762, 9, + 174, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 5768, 8, 175, 1, 175, 1, 175, + 1, 175, 1, 175, 3, 175, 5774, 8, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, + 175, 3, 175, 5781, 8, 175, 1, 175, 1, 175, 3, 175, 5785, 8, 175, 1, 176, + 1, 176, 1, 176, 5, 176, 5790, 8, 176, 10, 176, 12, 176, 5793, 9, 176, 1, + 177, 1, 177, 1, 177, 1, 177, 3, 177, 5799, 8, 177, 1, 177, 1, 177, 1, 177, + 1, 177, 3, 177, 5805, 8, 177, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 5811, + 8, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 5819, 8, + 178, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 5825, 8, 179, 1, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, + 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 5842, 8, 180, 1, 181, 1, 181, 1, + 181, 1, 181, 3, 181, 5848, 8, 181, 1, 181, 1, 181, 1, 181, 3, 181, 5853, + 8, 181, 1, 181, 1, 181, 1, 181, 1, 181, 5, 181, 5859, 8, 181, 10, 181, + 12, 181, 5862, 9, 181, 1, 181, 1, 181, 1, 181, 3, 181, 5867, 8, 181, 3, + 181, 5869, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 5875, 8, 182, + 10, 182, 12, 182, 5878, 9, 182, 1, 182, 1, 182, 1, 183, 3, 183, 5883, 8, + 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 5889, 8, 183, 1, 184, 1, 184, + 1, 184, 5, 184, 5894, 8, 184, 10, 184, 12, 184, 5897, 9, 184, 1, 185, 1, + 185, 1, 185, 1, 185, 1, 185, 3, 185, 5904, 8, 185, 1, 185, 3, 185, 5907, + 8, 185, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 5, 187, + 5916, 8, 187, 10, 187, 12, 187, 5919, 9, 187, 1, 187, 1, 187, 1, 188, 1, + 188, 1, 188, 1, 188, 5, 188, 5927, 8, 188, 10, 188, 12, 188, 5930, 9, 188, + 1, 189, 1, 189, 3, 189, 5934, 8, 189, 1, 189, 3, 189, 5937, 8, 189, 1, + 190, 1, 190, 1, 190, 5, 190, 5942, 8, 190, 10, 190, 12, 190, 5945, 9, 190, + 1, 191, 1, 191, 1, 192, 1, 192, 3, 192, 5951, 8, 192, 1, 193, 1, 193, 1, + 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 4, 193, 5961, 8, 193, 11, + 193, 12, 193, 5962, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 5969, 8, 193, + 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, + 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, + 1, 194, 1, 194, 3, 194, 5991, 8, 194, 1, 194, 1, 194, 3, 194, 5995, 8, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 5, 194, 6009, 8, 194, 10, 194, 12, 194, 6012, + 9, 194, 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 6018, 8, 195, 10, 195, + 12, 195, 6021, 9, 195, 3, 195, 6023, 8, 195, 1, 195, 1, 195, 1, 196, 1, + 196, 1, 196, 3, 196, 6030, 8, 196, 1, 197, 3, 197, 6033, 8, 197, 1, 197, + 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 6041, 8, 197, 1, 197, 1, + 197, 1, 197, 3, 197, 6046, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, + 6052, 8, 197, 1, 197, 3, 197, 6055, 8, 197, 1, 197, 1, 197, 1, 197, 3, + 197, 6060, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, + 6068, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 5, 197, 6075, 8, + 197, 10, 197, 12, 197, 6078, 9, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, + 197, 6084, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 6089, 8, 197, 1, 197, + 3, 197, 6092, 8, 197, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 6098, 8, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, + 198, 1, 198, 5, 198, 6119, 8, 198, 10, 198, 12, 198, 6122, 9, 198, 1, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, + 4, 199, 6134, 8, 199, 11, 199, 12, 199, 6135, 1, 199, 1, 199, 3, 199, 6140, + 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 4, 199, 6147, 8, 199, 11, + 199, 12, 199, 6148, 1, 199, 1, 199, 3, 199, 6153, 8, 199, 1, 199, 1, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, + 5, 199, 6175, 8, 199, 10, 199, 12, 199, 6178, 9, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 5, 199, 6184, 8, 199, 10, 199, 12, 199, 6187, 9, 199, 1, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 5, 199, 6194, 8, 199, 10, 199, 12, 199, + 6197, 9, 199, 1, 199, 1, 199, 3, 199, 6201, 8, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 6222, + 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 6228, 8, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 5, 199, 6236, 8, 199, 10, 199, 12, + 199, 6239, 9, 199, 3, 199, 6241, 8, 199, 1, 199, 1, 199, 3, 199, 6245, + 8, 199, 1, 199, 1, 199, 1, 199, 3, 199, 6250, 8, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, + 199, 6263, 8, 199, 1, 199, 3, 199, 6266, 8, 199, 1, 199, 1, 199, 1, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, + 6279, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 3, 199, 6300, 8, 199, 1, 199, 1, 199, 3, 199, 6304, + 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, + 1, 199, 3, 199, 6315, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 3, 199, 6323, 8, 199, 1, 199, 1, 199, 1, 199, 3, 199, 6328, 8, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, + 1, 199, 3, 199, 6340, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 6352, 8, 199, 5, 199, 6354, + 8, 199, 10, 199, 12, 199, 6357, 9, 199, 1, 200, 1, 200, 1, 200, 1, 200, + 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 3, 200, 6369, 8, 200, 1, + 201, 1, 201, 1, 201, 3, 201, 6374, 8, 201, 3, 201, 6376, 8, 201, 1, 202, + 1, 202, 1, 202, 3, 202, 6381, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, + 202, 6387, 8, 202, 1, 202, 1, 202, 1, 202, 5, 202, 6392, 8, 202, 10, 202, + 12, 202, 6395, 9, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 5, 202, + 6402, 8, 202, 10, 202, 12, 202, 6405, 9, 202, 3, 202, 6407, 8, 202, 3, + 202, 6409, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 6414, 8, 202, 1, 203, + 1, 203, 1, 203, 3, 203, 6419, 8, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, + 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 6439, 8, 204, 1, 205, 1, 205, + 3, 205, 6443, 8, 205, 1, 205, 3, 205, 6446, 8, 205, 1, 205, 3, 205, 6449, + 8, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, + 1, 206, 1, 206, 1, 206, 3, 206, 6462, 8, 206, 1, 207, 1, 207, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 6473, 8, 208, 1, 209, + 1, 209, 1, 209, 5, 209, 6478, 8, 209, 10, 209, 12, 209, 6481, 9, 209, 1, + 210, 3, 210, 6484, 8, 210, 1, 210, 1, 210, 1, 210, 3, 210, 6489, 8, 210, + 1, 210, 3, 210, 6492, 8, 210, 1, 210, 1, 210, 3, 210, 6496, 8, 210, 1, + 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 3, 211, 6504, 8, 211, 1, 211, + 1, 211, 1, 211, 1, 211, 3, 211, 6510, 8, 211, 1, 211, 1, 211, 5, 211, 6514, + 8, 211, 10, 211, 12, 211, 6517, 9, 211, 1, 211, 1, 211, 1, 211, 1, 211, + 1, 211, 1, 211, 3, 211, 6525, 8, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, + 211, 5, 211, 6532, 8, 211, 10, 211, 12, 211, 6535, 9, 211, 1, 211, 1, 211, + 1, 211, 1, 211, 1, 211, 5, 211, 6542, 8, 211, 10, 211, 12, 211, 6545, 9, + 211, 1, 211, 1, 211, 1, 211, 3, 211, 6550, 8, 211, 1, 212, 1, 212, 1, 213, + 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, + 1, 215, 1, 216, 1, 216, 1, 217, 1, 217, 3, 217, 6569, 8, 217, 1, 217, 3, + 217, 6572, 8, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, + 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, + 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, + 5, 218, 6599, 8, 218, 10, 218, 12, 218, 6602, 9, 218, 1, 218, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 5, 218, 6612, 8, 218, 10, + 218, 12, 218, 6615, 9, 218, 1, 218, 3, 218, 6618, 8, 218, 3, 218, 6620, + 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, + 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, + 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, + 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 6655, 8, + 219, 1, 220, 1, 220, 1, 220, 5, 220, 6660, 8, 220, 10, 220, 12, 220, 6663, + 9, 220, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 6669, 8, 221, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 6689, + 8, 222, 1, 223, 1, 223, 1, 223, 5, 223, 6694, 8, 223, 10, 223, 12, 223, + 6697, 9, 223, 1, 224, 3, 224, 6700, 8, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 3, 224, 6706, 8, 224, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 227, + 1, 227, 1, 227, 3, 227, 6716, 8, 227, 1, 227, 1, 227, 1, 227, 3, 227, 6721, + 8, 227, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 6727, 8, 228, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, + 229, 6739, 8, 229, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 4, 231, 6746, + 8, 231, 11, 231, 12, 231, 6747, 1, 231, 3, 231, 6751, 8, 231, 1, 232, 1, + 232, 1, 233, 1, 233, 1, 233, 3, 233, 6758, 8, 233, 1, 234, 1, 234, 1, 235, + 3, 235, 6763, 8, 235, 1, 235, 1, 235, 3, 235, 6767, 8, 235, 1, 235, 3, + 235, 6770, 8, 235, 1, 236, 1, 236, 1, 236, 2, 553, 560, 4, 234, 388, 396, + 398, 237, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, + 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, + 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, + 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, + 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, + 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, + 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, + 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, + 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, + 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, + 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, + 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, + 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, + 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, + 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, + 466, 468, 470, 472, 0, 66, 1, 0, 371, 372, 2, 0, 202, 202, 372, 372, 2, + 0, 36, 36, 199, 199, 2, 0, 33, 33, 575, 575, 2, 0, 180, 180, 481, 481, + 3, 0, 18, 18, 155, 155, 508, 508, 2, 0, 198, 198, 231, 231, 2, 0, 356, + 356, 408, 408, 3, 0, 47, 47, 245, 245, 320, 321, 2, 0, 18, 18, 473, 473, + 2, 0, 115, 115, 430, 430, 2, 0, 259, 259, 518, 518, 3, 0, 114, 114, 402, + 402, 493, 493, 1, 0, 525, 526, 2, 0, 168, 168, 532, 532, 2, 0, 84, 84, + 186, 186, 2, 0, 116, 116, 431, 431, 2, 0, 233, 234, 259, 260, 2, 0, 569, + 569, 575, 575, 2, 0, 173, 173, 331, 331, 3, 0, 27, 27, 133, 133, 302, 302, + 1, 0, 331, 332, 1, 0, 151, 152, 3, 0, 125, 125, 225, 225, 309, 309, 2, + 0, 231, 231, 489, 489, 4, 0, 57, 57, 217, 217, 279, 279, 426, 426, 3, 0, + 123, 123, 224, 224, 432, 432, 1, 0, 11, 12, 2, 0, 333, 333, 540, 540, 1, + 0, 345, 346, 2, 0, 277, 277, 385, 385, 3, 0, 206, 206, 279, 279, 437, 437, + 2, 0, 132, 132, 230, 230, 2, 0, 33, 33, 89, 89, 5, 0, 154, 154, 209, 209, + 360, 360, 495, 495, 527, 527, 2, 0, 135, 136, 177, 177, 10, 0, 20, 20, + 23, 23, 145, 145, 284, 284, 301, 301, 336, 336, 344, 344, 357, 357, 414, + 414, 442, 442, 3, 0, 172, 172, 307, 307, 507, 507, 2, 0, 20, 20, 142, 142, + 2, 0, 30, 30, 135, 135, 2, 0, 323, 323, 516, 516, 2, 0, 189, 189, 265, + 265, 8, 0, 49, 49, 205, 205, 221, 221, 299, 299, 306, 306, 378, 378, 399, + 400, 467, 467, 1, 0, 251, 252, 2, 0, 25, 25, 557, 557, 2, 0, 394, 394, + 416, 416, 3, 0, 288, 288, 290, 291, 294, 297, 2, 0, 183, 183, 498, 498, + 2, 0, 550, 551, 555, 555, 2, 0, 147, 147, 552, 554, 1, 0, 550, 551, 3, + 0, 54, 54, 269, 269, 492, 492, 2, 0, 303, 303, 465, 466, 2, 0, 206, 206, + 437, 437, 2, 0, 117, 117, 487, 487, 2, 0, 444, 444, 511, 511, 1, 0, 239, + 240, 2, 0, 385, 385, 425, 425, 2, 0, 192, 192, 368, 368, 4, 0, 117, 117, + 120, 120, 122, 122, 487, 487, 1, 0, 543, 549, 10, 0, 123, 124, 126, 126, + 224, 224, 308, 308, 310, 310, 312, 312, 383, 383, 432, 432, 533, 533, 542, + 542, 2, 0, 552, 552, 575, 575, 1, 0, 292, 293, 1, 0, 576, 577, 106, 0, + 9, 10, 13, 13, 16, 19, 23, 23, 28, 28, 31, 32, 34, 35, 37, 40, 43, 43, + 46, 53, 55, 61, 63, 65, 69, 73, 75, 75, 77, 78, 80, 82, 84, 96, 98, 102, + 104, 105, 109, 114, 117, 123, 125, 125, 127, 129, 132, 132, 134, 134, 137, + 140, 143, 144, 148, 149, 153, 153, 156, 157, 159, 166, 168, 171, 173, 173, + 176, 176, 180, 180, 182, 182, 184, 189, 196, 197, 200, 200, 202, 202, 204, + 206, 209, 209, 211, 215, 217, 219, 221, 227, 229, 230, 232, 232, 234, 234, + 237, 237, 245, 248, 250, 255, 257, 258, 262, 262, 265, 265, 267, 268, 271, + 272, 275, 276, 279, 284, 286, 287, 289, 299, 301, 306, 308, 309, 311, 315, + 317, 322, 324, 324, 327, 327, 329, 330, 332, 336, 343, 344, 346, 358, 360, + 360, 362, 367, 371, 371, 373, 384, 389, 392, 398, 401, 403, 412, 414, 414, + 416, 416, 419, 423, 426, 430, 432, 432, 435, 438, 441, 442, 445, 445, 447, + 451, 453, 467, 473, 473, 477, 481, 483, 484, 486, 487, 493, 493, 495, 496, + 499, 499, 501, 501, 503, 503, 505, 505, 509, 510, 512, 512, 515, 515, 518, + 518, 520, 533, 538, 538, 542, 542, 564, 566, 586, 586, 8012, 0, 477, 1, + 0, 0, 0, 2, 505, 1, 0, 0, 0, 4, 519, 1, 0, 0, 0, 6, 596, 1, 0, 0, 0, 8, + 628, 1, 0, 0, 0, 10, 771, 1, 0, 0, 0, 12, 857, 1, 0, 0, 0, 14, 878, 1, + 0, 0, 0, 16, 880, 1, 0, 0, 0, 18, 1064, 1, 0, 0, 0, 20, 1066, 1, 0, 0, + 0, 22, 1079, 1, 0, 0, 0, 24, 1601, 1, 0, 0, 0, 26, 1603, 1, 0, 0, 0, 28, + 1611, 1, 0, 0, 0, 30, 1860, 1, 0, 0, 0, 32, 2075, 1, 0, 0, 0, 34, 2780, + 1, 0, 0, 0, 36, 2874, 1, 0, 0, 0, 38, 2884, 1, 0, 0, 0, 40, 3006, 1, 0, + 0, 0, 42, 3008, 1, 0, 0, 0, 44, 3014, 1, 0, 0, 0, 46, 3018, 1, 0, 0, 0, + 48, 3033, 1, 0, 0, 0, 50, 3076, 1, 0, 0, 0, 52, 3078, 1, 0, 0, 0, 54, 3082, + 1, 0, 0, 0, 56, 3086, 1, 0, 0, 0, 58, 3089, 1, 0, 0, 0, 60, 3093, 1, 0, + 0, 0, 62, 3118, 1, 0, 0, 0, 64, 3145, 1, 0, 0, 0, 66, 3170, 1, 0, 0, 0, + 68, 3260, 1, 0, 0, 0, 70, 3474, 1, 0, 0, 0, 72, 3509, 1, 0, 0, 0, 74, 3511, + 1, 0, 0, 0, 76, 3535, 1, 0, 0, 0, 78, 3579, 1, 0, 0, 0, 80, 3667, 1, 0, + 0, 0, 82, 3674, 1, 0, 0, 0, 84, 3676, 1, 0, 0, 0, 86, 3782, 1, 0, 0, 0, + 88, 3784, 1, 0, 0, 0, 90, 3788, 1, 0, 0, 0, 92, 4053, 1, 0, 0, 0, 94, 4074, + 1, 0, 0, 0, 96, 4095, 1, 0, 0, 0, 98, 4101, 1, 0, 0, 0, 100, 4110, 1, 0, + 0, 0, 102, 4118, 1, 0, 0, 0, 104, 4135, 1, 0, 0, 0, 106, 4137, 1, 0, 0, + 0, 108, 4140, 1, 0, 0, 0, 110, 4143, 1, 0, 0, 0, 112, 4151, 1, 0, 0, 0, + 114, 4172, 1, 0, 0, 0, 116, 4177, 1, 0, 0, 0, 118, 4179, 1, 0, 0, 0, 120, + 4182, 1, 0, 0, 0, 122, 4343, 1, 0, 0, 0, 124, 4363, 1, 0, 0, 0, 126, 4365, + 1, 0, 0, 0, 128, 4379, 1, 0, 0, 0, 130, 4381, 1, 0, 0, 0, 132, 4389, 1, + 0, 0, 0, 134, 4395, 1, 0, 0, 0, 136, 4410, 1, 0, 0, 0, 138, 4452, 1, 0, + 0, 0, 140, 4454, 1, 0, 0, 0, 142, 4508, 1, 0, 0, 0, 144, 4510, 1, 0, 0, + 0, 146, 4564, 1, 0, 0, 0, 148, 4587, 1, 0, 0, 0, 150, 4589, 1, 0, 0, 0, + 152, 4592, 1, 0, 0, 0, 154, 4616, 1, 0, 0, 0, 156, 4638, 1, 0, 0, 0, 158, + 4640, 1, 0, 0, 0, 160, 4673, 1, 0, 0, 0, 162, 4687, 1, 0, 0, 0, 164, 4703, + 1, 0, 0, 0, 166, 4706, 1, 0, 0, 0, 168, 4720, 1, 0, 0, 0, 170, 4733, 1, + 0, 0, 0, 172, 4840, 1, 0, 0, 0, 174, 4842, 1, 0, 0, 0, 176, 4844, 1, 0, + 0, 0, 178, 4854, 1, 0, 0, 0, 180, 4856, 1, 0, 0, 0, 182, 4863, 1, 0, 0, + 0, 184, 4867, 1, 0, 0, 0, 186, 4871, 1, 0, 0, 0, 188, 4876, 1, 0, 0, 0, + 190, 4878, 1, 0, 0, 0, 192, 4888, 1, 0, 0, 0, 194, 4890, 1, 0, 0, 0, 196, + 4901, 1, 0, 0, 0, 198, 4910, 1, 0, 0, 0, 200, 4920, 1, 0, 0, 0, 202, 4922, + 1, 0, 0, 0, 204, 4924, 1, 0, 0, 0, 206, 4932, 1, 0, 0, 0, 208, 4934, 1, + 0, 0, 0, 210, 4936, 1, 0, 0, 0, 212, 4940, 1, 0, 0, 0, 214, 4944, 1, 0, + 0, 0, 216, 4948, 1, 0, 0, 0, 218, 4954, 1, 0, 0, 0, 220, 4966, 1, 0, 0, + 0, 222, 4998, 1, 0, 0, 0, 224, 5000, 1, 0, 0, 0, 226, 5009, 1, 0, 0, 0, + 228, 5052, 1, 0, 0, 0, 230, 5054, 1, 0, 0, 0, 232, 5066, 1, 0, 0, 0, 234, + 5071, 1, 0, 0, 0, 236, 5091, 1, 0, 0, 0, 238, 5099, 1, 0, 0, 0, 240, 5101, + 1, 0, 0, 0, 242, 5123, 1, 0, 0, 0, 244, 5132, 1, 0, 0, 0, 246, 5141, 1, + 0, 0, 0, 248, 5152, 1, 0, 0, 0, 250, 5158, 1, 0, 0, 0, 252, 5160, 1, 0, + 0, 0, 254, 5163, 1, 0, 0, 0, 256, 5167, 1, 0, 0, 0, 258, 5184, 1, 0, 0, + 0, 260, 5187, 1, 0, 0, 0, 262, 5192, 1, 0, 0, 0, 264, 5200, 1, 0, 0, 0, + 266, 5207, 1, 0, 0, 0, 268, 5230, 1, 0, 0, 0, 270, 5232, 1, 0, 0, 0, 272, + 5240, 1, 0, 0, 0, 274, 5273, 1, 0, 0, 0, 276, 5275, 1, 0, 0, 0, 278, 5279, + 1, 0, 0, 0, 280, 5334, 1, 0, 0, 0, 282, 5336, 1, 0, 0, 0, 284, 5349, 1, + 0, 0, 0, 286, 5352, 1, 0, 0, 0, 288, 5355, 1, 0, 0, 0, 290, 5397, 1, 0, + 0, 0, 292, 5401, 1, 0, 0, 0, 294, 5415, 1, 0, 0, 0, 296, 5417, 1, 0, 0, + 0, 298, 5423, 1, 0, 0, 0, 300, 5431, 1, 0, 0, 0, 302, 5457, 1, 0, 0, 0, + 304, 5462, 1, 0, 0, 0, 306, 5472, 1, 0, 0, 0, 308, 5490, 1, 0, 0, 0, 310, + 5492, 1, 0, 0, 0, 312, 5532, 1, 0, 0, 0, 314, 5538, 1, 0, 0, 0, 316, 5540, + 1, 0, 0, 0, 318, 5544, 1, 0, 0, 0, 320, 5552, 1, 0, 0, 0, 322, 5612, 1, + 0, 0, 0, 324, 5614, 1, 0, 0, 0, 326, 5617, 1, 0, 0, 0, 328, 5622, 1, 0, + 0, 0, 330, 5630, 1, 0, 0, 0, 332, 5636, 1, 0, 0, 0, 334, 5640, 1, 0, 0, + 0, 336, 5649, 1, 0, 0, 0, 338, 5651, 1, 0, 0, 0, 340, 5659, 1, 0, 0, 0, + 342, 5667, 1, 0, 0, 0, 344, 5672, 1, 0, 0, 0, 346, 5680, 1, 0, 0, 0, 348, + 5755, 1, 0, 0, 0, 350, 5763, 1, 0, 0, 0, 352, 5786, 1, 0, 0, 0, 354, 5798, + 1, 0, 0, 0, 356, 5806, 1, 0, 0, 0, 358, 5820, 1, 0, 0, 0, 360, 5834, 1, + 0, 0, 0, 362, 5843, 1, 0, 0, 0, 364, 5870, 1, 0, 0, 0, 366, 5888, 1, 0, + 0, 0, 368, 5890, 1, 0, 0, 0, 370, 5898, 1, 0, 0, 0, 372, 5908, 1, 0, 0, + 0, 374, 5910, 1, 0, 0, 0, 376, 5922, 1, 0, 0, 0, 378, 5931, 1, 0, 0, 0, + 380, 5938, 1, 0, 0, 0, 382, 5946, 1, 0, 0, 0, 384, 5950, 1, 0, 0, 0, 386, + 5968, 1, 0, 0, 0, 388, 5994, 1, 0, 0, 0, 390, 6013, 1, 0, 0, 0, 392, 6029, + 1, 0, 0, 0, 394, 6091, 1, 0, 0, 0, 396, 6097, 1, 0, 0, 0, 398, 6327, 1, + 0, 0, 0, 400, 6368, 1, 0, 0, 0, 402, 6375, 1, 0, 0, 0, 404, 6377, 1, 0, + 0, 0, 406, 6418, 1, 0, 0, 0, 408, 6438, 1, 0, 0, 0, 410, 6440, 1, 0, 0, + 0, 412, 6461, 1, 0, 0, 0, 414, 6463, 1, 0, 0, 0, 416, 6472, 1, 0, 0, 0, + 418, 6474, 1, 0, 0, 0, 420, 6495, 1, 0, 0, 0, 422, 6549, 1, 0, 0, 0, 424, + 6551, 1, 0, 0, 0, 426, 6553, 1, 0, 0, 0, 428, 6555, 1, 0, 0, 0, 430, 6560, + 1, 0, 0, 0, 432, 6564, 1, 0, 0, 0, 434, 6566, 1, 0, 0, 0, 436, 6619, 1, + 0, 0, 0, 438, 6654, 1, 0, 0, 0, 440, 6656, 1, 0, 0, 0, 442, 6664, 1, 0, + 0, 0, 444, 6688, 1, 0, 0, 0, 446, 6690, 1, 0, 0, 0, 448, 6699, 1, 0, 0, + 0, 450, 6707, 1, 0, 0, 0, 452, 6709, 1, 0, 0, 0, 454, 6712, 1, 0, 0, 0, + 456, 6726, 1, 0, 0, 0, 458, 6738, 1, 0, 0, 0, 460, 6740, 1, 0, 0, 0, 462, + 6750, 1, 0, 0, 0, 464, 6752, 1, 0, 0, 0, 466, 6757, 1, 0, 0, 0, 468, 6759, + 1, 0, 0, 0, 470, 6769, 1, 0, 0, 0, 472, 6771, 1, 0, 0, 0, 474, 476, 5, + 1, 0, 0, 475, 474, 1, 0, 0, 0, 476, 479, 1, 0, 0, 0, 477, 475, 1, 0, 0, + 0, 477, 478, 1, 0, 0, 0, 478, 481, 1, 0, 0, 0, 479, 477, 1, 0, 0, 0, 480, + 482, 3, 6, 3, 0, 481, 480, 1, 0, 0, 0, 481, 482, 1, 0, 0, 0, 482, 491, + 1, 0, 0, 0, 483, 485, 5, 1, 0, 0, 484, 483, 1, 0, 0, 0, 485, 486, 1, 0, + 0, 0, 486, 484, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 488, 1, 0, 0, 0, + 488, 490, 3, 6, 3, 0, 489, 484, 1, 0, 0, 0, 490, 493, 1, 0, 0, 0, 491, + 489, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 497, 1, 0, 0, 0, 493, 491, + 1, 0, 0, 0, 494, 496, 5, 1, 0, 0, 495, 494, 1, 0, 0, 0, 496, 499, 1, 0, + 0, 0, 497, 495, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 500, 1, 0, 0, 0, + 499, 497, 1, 0, 0, 0, 500, 501, 5, 0, 0, 1, 501, 1, 1, 0, 0, 0, 502, 504, + 5, 1, 0, 0, 503, 502, 1, 0, 0, 0, 504, 507, 1, 0, 0, 0, 505, 503, 1, 0, + 0, 0, 505, 506, 1, 0, 0, 0, 506, 509, 1, 0, 0, 0, 507, 505, 1, 0, 0, 0, + 508, 510, 3, 6, 3, 0, 509, 508, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, + 514, 1, 0, 0, 0, 511, 513, 5, 1, 0, 0, 512, 511, 1, 0, 0, 0, 513, 516, + 1, 0, 0, 0, 514, 512, 1, 0, 0, 0, 514, 515, 1, 0, 0, 0, 515, 517, 1, 0, + 0, 0, 516, 514, 1, 0, 0, 0, 517, 518, 5, 0, 0, 1, 518, 3, 1, 0, 0, 0, 519, + 520, 3, 382, 191, 0, 520, 521, 5, 0, 0, 1, 521, 5, 1, 0, 0, 0, 522, 597, + 3, 8, 4, 0, 523, 524, 5, 65, 0, 0, 524, 525, 3, 338, 169, 0, 525, 534, + 5, 2, 0, 0, 526, 531, 3, 382, 191, 0, 527, 528, 5, 4, 0, 0, 528, 530, 3, + 382, 191, 0, 529, 527, 1, 0, 0, 0, 530, 533, 1, 0, 0, 0, 531, 529, 1, 0, + 0, 0, 531, 532, 1, 0, 0, 0, 532, 535, 1, 0, 0, 0, 533, 531, 1, 0, 0, 0, + 534, 526, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, + 537, 5, 3, 0, 0, 537, 597, 1, 0, 0, 0, 538, 546, 5, 21, 0, 0, 539, 542, + 5, 103, 0, 0, 540, 541, 5, 337, 0, 0, 541, 543, 5, 399, 0, 0, 542, 540, + 1, 0, 0, 0, 542, 543, 1, 0, 0, 0, 543, 546, 1, 0, 0, 0, 544, 546, 5, 399, + 0, 0, 545, 538, 1, 0, 0, 0, 545, 539, 1, 0, 0, 0, 545, 544, 1, 0, 0, 0, + 546, 547, 1, 0, 0, 0, 547, 548, 7, 0, 0, 0, 548, 549, 3, 338, 169, 0, 549, + 553, 5, 2, 0, 0, 550, 552, 9, 0, 0, 0, 551, 550, 1, 0, 0, 0, 552, 555, + 1, 0, 0, 0, 553, 554, 1, 0, 0, 0, 553, 551, 1, 0, 0, 0, 554, 556, 1, 0, + 0, 0, 555, 553, 1, 0, 0, 0, 556, 560, 5, 3, 0, 0, 557, 559, 9, 0, 0, 0, + 558, 557, 1, 0, 0, 0, 559, 562, 1, 0, 0, 0, 560, 561, 1, 0, 0, 0, 560, + 558, 1, 0, 0, 0, 561, 597, 1, 0, 0, 0, 562, 560, 1, 0, 0, 0, 563, 564, + 5, 151, 0, 0, 564, 567, 7, 0, 0, 0, 565, 566, 5, 228, 0, 0, 566, 568, 5, + 175, 0, 0, 567, 565, 1, 0, 0, 0, 567, 568, 1, 0, 0, 0, 568, 569, 1, 0, + 0, 0, 569, 597, 3, 338, 169, 0, 570, 571, 5, 443, 0, 0, 571, 572, 7, 1, + 0, 0, 572, 576, 5, 458, 0, 0, 573, 574, 5, 273, 0, 0, 574, 577, 3, 396, + 198, 0, 575, 577, 3, 252, 126, 0, 576, 573, 1, 0, 0, 0, 576, 575, 1, 0, + 0, 0, 576, 577, 1, 0, 0, 0, 577, 597, 1, 0, 0, 0, 578, 579, 5, 443, 0, + 0, 579, 580, 5, 103, 0, 0, 580, 581, 5, 372, 0, 0, 581, 597, 3, 338, 169, + 0, 582, 584, 5, 15, 0, 0, 583, 582, 1, 0, 0, 0, 583, 584, 1, 0, 0, 0, 584, + 585, 1, 0, 0, 0, 585, 586, 5, 443, 0, 0, 586, 587, 7, 2, 0, 0, 587, 590, + 5, 93, 0, 0, 588, 589, 5, 273, 0, 0, 589, 591, 3, 396, 198, 0, 590, 588, + 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 594, 1, 0, 0, 0, 592, 593, 5, 198, + 0, 0, 593, 595, 5, 575, 0, 0, 594, 592, 1, 0, 0, 0, 594, 595, 1, 0, 0, + 0, 595, 597, 1, 0, 0, 0, 596, 522, 1, 0, 0, 0, 596, 523, 1, 0, 0, 0, 596, + 545, 1, 0, 0, 0, 596, 563, 1, 0, 0, 0, 596, 570, 1, 0, 0, 0, 596, 578, + 1, 0, 0, 0, 596, 583, 1, 0, 0, 0, 597, 7, 1, 0, 0, 0, 598, 600, 3, 198, + 99, 0, 599, 598, 1, 0, 0, 0, 599, 600, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, + 601, 603, 3, 232, 116, 0, 602, 604, 3, 230, 115, 0, 603, 602, 1, 0, 0, + 0, 603, 604, 1, 0, 0, 0, 604, 629, 1, 0, 0, 0, 605, 629, 3, 18, 9, 0, 606, + 629, 3, 24, 12, 0, 607, 629, 3, 30, 15, 0, 608, 629, 3, 10, 5, 0, 609, + 629, 3, 12, 6, 0, 610, 629, 3, 14, 7, 0, 611, 629, 3, 66, 33, 0, 612, 629, + 3, 160, 80, 0, 613, 629, 3, 32, 16, 0, 614, 629, 3, 142, 71, 0, 615, 629, + 3, 154, 77, 0, 616, 629, 3, 64, 32, 0, 617, 629, 3, 34, 17, 0, 618, 629, + 3, 36, 18, 0, 619, 629, 3, 68, 34, 0, 620, 629, 3, 72, 36, 0, 621, 629, + 3, 70, 35, 0, 622, 629, 3, 156, 78, 0, 623, 629, 3, 40, 20, 0, 624, 629, + 3, 38, 19, 0, 625, 629, 3, 122, 61, 0, 626, 629, 3, 78, 39, 0, 627, 629, + 3, 80, 40, 0, 628, 599, 1, 0, 0, 0, 628, 605, 1, 0, 0, 0, 628, 606, 1, + 0, 0, 0, 628, 607, 1, 0, 0, 0, 628, 608, 1, 0, 0, 0, 628, 609, 1, 0, 0, + 0, 628, 610, 1, 0, 0, 0, 628, 611, 1, 0, 0, 0, 628, 612, 1, 0, 0, 0, 628, + 613, 1, 0, 0, 0, 628, 614, 1, 0, 0, 0, 628, 615, 1, 0, 0, 0, 628, 616, + 1, 0, 0, 0, 628, 617, 1, 0, 0, 0, 628, 618, 1, 0, 0, 0, 628, 619, 1, 0, + 0, 0, 628, 620, 1, 0, 0, 0, 628, 621, 1, 0, 0, 0, 628, 622, 1, 0, 0, 0, + 628, 623, 1, 0, 0, 0, 628, 624, 1, 0, 0, 0, 628, 625, 1, 0, 0, 0, 628, + 626, 1, 0, 0, 0, 628, 627, 1, 0, 0, 0, 629, 9, 1, 0, 0, 0, 630, 631, 5, + 103, 0, 0, 631, 632, 5, 298, 0, 0, 632, 636, 5, 529, 0, 0, 633, 634, 5, + 228, 0, 0, 634, 635, 5, 325, 0, 0, 635, 637, 5, 175, 0, 0, 636, 633, 1, + 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 643, 3, 338, + 169, 0, 639, 640, 5, 2, 0, 0, 640, 641, 3, 340, 170, 0, 641, 642, 5, 3, + 0, 0, 642, 644, 1, 0, 0, 0, 643, 639, 1, 0, 0, 0, 643, 644, 1, 0, 0, 0, + 644, 646, 1, 0, 0, 0, 645, 647, 3, 176, 88, 0, 646, 645, 1, 0, 0, 0, 646, + 647, 1, 0, 0, 0, 647, 655, 1, 0, 0, 0, 648, 650, 5, 392, 0, 0, 649, 651, + 3, 182, 91, 0, 650, 649, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 653, 1, + 0, 0, 0, 652, 654, 3, 178, 89, 0, 653, 652, 1, 0, 0, 0, 653, 654, 1, 0, + 0, 0, 654, 656, 1, 0, 0, 0, 655, 648, 1, 0, 0, 0, 655, 656, 1, 0, 0, 0, + 656, 662, 1, 0, 0, 0, 657, 659, 5, 155, 0, 0, 658, 657, 1, 0, 0, 0, 658, + 659, 1, 0, 0, 0, 659, 660, 1, 0, 0, 0, 660, 661, 5, 259, 0, 0, 661, 663, + 3, 316, 158, 0, 662, 658, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 666, 1, + 0, 0, 0, 664, 665, 5, 85, 0, 0, 665, 667, 5, 569, 0, 0, 666, 664, 1, 0, + 0, 0, 666, 667, 1, 0, 0, 0, 667, 674, 1, 0, 0, 0, 668, 669, 5, 345, 0, + 0, 669, 670, 5, 62, 0, 0, 670, 671, 5, 2, 0, 0, 671, 672, 3, 184, 92, 0, + 672, 673, 5, 3, 0, 0, 673, 675, 1, 0, 0, 0, 674, 668, 1, 0, 0, 0, 674, + 675, 1, 0, 0, 0, 675, 687, 1, 0, 0, 0, 676, 677, 5, 145, 0, 0, 677, 681, + 5, 62, 0, 0, 678, 679, 5, 214, 0, 0, 679, 682, 3, 316, 158, 0, 680, 682, + 5, 384, 0, 0, 681, 678, 1, 0, 0, 0, 681, 680, 1, 0, 0, 0, 682, 685, 1, + 0, 0, 0, 683, 684, 5, 58, 0, 0, 684, 686, 7, 3, 0, 0, 685, 683, 1, 0, 0, + 0, 685, 686, 1, 0, 0, 0, 686, 688, 1, 0, 0, 0, 687, 676, 1, 0, 0, 0, 687, + 688, 1, 0, 0, 0, 688, 690, 1, 0, 0, 0, 689, 691, 3, 326, 163, 0, 690, 689, + 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 693, 1, 0, 0, 0, 692, 694, 5, 29, + 0, 0, 693, 692, 1, 0, 0, 0, 693, 694, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, + 695, 696, 3, 232, 116, 0, 696, 772, 1, 0, 0, 0, 697, 698, 5, 392, 0, 0, + 698, 699, 5, 298, 0, 0, 699, 700, 5, 529, 0, 0, 700, 704, 3, 338, 169, + 0, 701, 705, 3, 164, 82, 0, 702, 705, 5, 89, 0, 0, 703, 705, 5, 33, 0, + 0, 704, 701, 1, 0, 0, 0, 704, 702, 1, 0, 0, 0, 704, 703, 1, 0, 0, 0, 705, + 772, 1, 0, 0, 0, 706, 707, 5, 21, 0, 0, 707, 708, 5, 298, 0, 0, 708, 709, + 5, 529, 0, 0, 709, 733, 3, 338, 169, 0, 710, 711, 5, 396, 0, 0, 711, 734, + 3, 464, 232, 0, 712, 718, 5, 392, 0, 0, 713, 719, 3, 182, 91, 0, 714, 719, + 3, 178, 89, 0, 715, 716, 3, 182, 91, 0, 716, 717, 3, 178, 89, 0, 717, 719, + 1, 0, 0, 0, 718, 713, 1, 0, 0, 0, 718, 714, 1, 0, 0, 0, 718, 715, 1, 0, + 0, 0, 719, 734, 1, 0, 0, 0, 720, 721, 5, 399, 0, 0, 721, 722, 5, 537, 0, + 0, 722, 723, 5, 298, 0, 0, 723, 724, 5, 529, 0, 0, 724, 726, 3, 464, 232, + 0, 725, 727, 3, 326, 163, 0, 726, 725, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, + 727, 734, 1, 0, 0, 0, 728, 729, 5, 439, 0, 0, 729, 730, 5, 2, 0, 0, 730, + 731, 3, 328, 164, 0, 731, 732, 5, 3, 0, 0, 732, 734, 1, 0, 0, 0, 733, 710, + 1, 0, 0, 0, 733, 712, 1, 0, 0, 0, 733, 720, 1, 0, 0, 0, 733, 728, 1, 0, + 0, 0, 734, 772, 1, 0, 0, 0, 735, 736, 5, 151, 0, 0, 736, 737, 5, 298, 0, + 0, 737, 740, 5, 529, 0, 0, 738, 739, 5, 228, 0, 0, 739, 741, 5, 175, 0, + 0, 740, 738, 1, 0, 0, 0, 740, 741, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, + 745, 3, 338, 169, 0, 743, 744, 5, 331, 0, 0, 744, 746, 3, 338, 169, 0, + 745, 743, 1, 0, 0, 0, 745, 746, 1, 0, 0, 0, 746, 772, 1, 0, 0, 0, 747, + 748, 5, 353, 0, 0, 748, 749, 5, 298, 0, 0, 749, 750, 5, 529, 0, 0, 750, + 751, 5, 254, 0, 0, 751, 752, 5, 331, 0, 0, 752, 772, 3, 338, 169, 0, 753, + 754, 5, 409, 0, 0, 754, 755, 5, 298, 0, 0, 755, 756, 5, 529, 0, 0, 756, + 757, 5, 254, 0, 0, 757, 758, 5, 331, 0, 0, 758, 772, 3, 338, 169, 0, 759, + 760, 5, 66, 0, 0, 760, 761, 5, 298, 0, 0, 761, 762, 5, 529, 0, 0, 762, + 763, 5, 478, 0, 0, 763, 764, 5, 575, 0, 0, 764, 765, 5, 331, 0, 0, 765, + 772, 3, 338, 169, 0, 766, 767, 5, 443, 0, 0, 767, 768, 5, 103, 0, 0, 768, + 769, 5, 298, 0, 0, 769, 770, 5, 529, 0, 0, 770, 772, 3, 338, 169, 0, 771, + 630, 1, 0, 0, 0, 771, 697, 1, 0, 0, 0, 771, 706, 1, 0, 0, 0, 771, 735, + 1, 0, 0, 0, 771, 747, 1, 0, 0, 0, 771, 753, 1, 0, 0, 0, 771, 759, 1, 0, + 0, 0, 771, 766, 1, 0, 0, 0, 772, 11, 1, 0, 0, 0, 773, 774, 5, 103, 0, 0, + 774, 775, 5, 254, 0, 0, 775, 777, 3, 338, 169, 0, 776, 778, 3, 326, 163, + 0, 777, 776, 1, 0, 0, 0, 777, 778, 1, 0, 0, 0, 778, 779, 1, 0, 0, 0, 779, + 803, 5, 331, 0, 0, 780, 804, 5, 462, 0, 0, 781, 801, 5, 428, 0, 0, 782, + 783, 5, 171, 0, 0, 783, 784, 5, 575, 0, 0, 784, 790, 3, 464, 232, 0, 785, + 788, 5, 456, 0, 0, 786, 789, 5, 569, 0, 0, 787, 789, 5, 112, 0, 0, 788, + 786, 1, 0, 0, 0, 788, 787, 1, 0, 0, 0, 789, 791, 1, 0, 0, 0, 790, 785, + 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 794, 1, 0, 0, 0, 792, 793, 5, 164, + 0, 0, 793, 795, 5, 569, 0, 0, 794, 792, 1, 0, 0, 0, 794, 795, 1, 0, 0, + 0, 795, 802, 1, 0, 0, 0, 796, 799, 5, 31, 0, 0, 797, 800, 5, 569, 0, 0, + 798, 800, 5, 112, 0, 0, 799, 797, 1, 0, 0, 0, 799, 798, 1, 0, 0, 0, 800, + 802, 1, 0, 0, 0, 801, 782, 1, 0, 0, 0, 801, 796, 1, 0, 0, 0, 802, 804, + 1, 0, 0, 0, 803, 780, 1, 0, 0, 0, 803, 781, 1, 0, 0, 0, 804, 806, 1, 0, + 0, 0, 805, 807, 3, 452, 226, 0, 806, 805, 1, 0, 0, 0, 806, 807, 1, 0, 0, + 0, 807, 808, 1, 0, 0, 0, 808, 809, 5, 148, 0, 0, 809, 810, 3, 18, 9, 0, + 810, 858, 1, 0, 0, 0, 811, 812, 5, 353, 0, 0, 812, 813, 5, 254, 0, 0, 813, + 814, 5, 535, 0, 0, 814, 815, 3, 464, 232, 0, 815, 816, 5, 543, 0, 0, 816, + 817, 5, 569, 0, 0, 817, 858, 1, 0, 0, 0, 818, 819, 5, 21, 0, 0, 819, 820, + 5, 254, 0, 0, 820, 826, 3, 338, 169, 0, 821, 827, 3, 326, 163, 0, 822, + 827, 3, 18, 9, 0, 823, 824, 3, 326, 163, 0, 824, 825, 3, 18, 9, 0, 825, + 827, 1, 0, 0, 0, 826, 821, 1, 0, 0, 0, 826, 822, 1, 0, 0, 0, 826, 823, + 1, 0, 0, 0, 827, 858, 1, 0, 0, 0, 828, 829, 5, 151, 0, 0, 829, 832, 5, + 254, 0, 0, 830, 831, 5, 228, 0, 0, 831, 833, 5, 175, 0, 0, 832, 830, 1, + 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 834, 1, 0, 0, 0, 834, 835, 5, 535, + 0, 0, 835, 836, 3, 464, 232, 0, 836, 837, 5, 543, 0, 0, 837, 838, 5, 569, + 0, 0, 838, 858, 1, 0, 0, 0, 839, 840, 5, 409, 0, 0, 840, 841, 5, 254, 0, + 0, 841, 842, 5, 535, 0, 0, 842, 843, 3, 464, 232, 0, 843, 844, 5, 543, + 0, 0, 844, 845, 5, 569, 0, 0, 845, 858, 1, 0, 0, 0, 846, 847, 5, 66, 0, + 0, 847, 848, 5, 478, 0, 0, 848, 849, 5, 535, 0, 0, 849, 850, 3, 464, 232, + 0, 850, 851, 5, 543, 0, 0, 851, 852, 5, 569, 0, 0, 852, 853, 5, 25, 0, + 0, 853, 854, 3, 464, 232, 0, 854, 855, 5, 543, 0, 0, 855, 856, 5, 575, + 0, 0, 856, 858, 1, 0, 0, 0, 857, 773, 1, 0, 0, 0, 857, 811, 1, 0, 0, 0, + 857, 818, 1, 0, 0, 0, 857, 828, 1, 0, 0, 0, 857, 839, 1, 0, 0, 0, 857, + 846, 1, 0, 0, 0, 858, 13, 1, 0, 0, 0, 859, 860, 5, 21, 0, 0, 860, 861, + 5, 472, 0, 0, 861, 862, 3, 338, 169, 0, 862, 863, 5, 14, 0, 0, 863, 864, + 5, 97, 0, 0, 864, 865, 3, 460, 230, 0, 865, 866, 3, 162, 81, 0, 866, 879, + 1, 0, 0, 0, 867, 868, 5, 21, 0, 0, 868, 869, 5, 472, 0, 0, 869, 870, 3, + 338, 169, 0, 870, 871, 5, 151, 0, 0, 871, 872, 5, 97, 0, 0, 872, 873, 3, + 460, 230, 0, 873, 879, 1, 0, 0, 0, 874, 875, 5, 443, 0, 0, 875, 876, 5, + 98, 0, 0, 876, 877, 5, 198, 0, 0, 877, 879, 3, 338, 169, 0, 878, 859, 1, + 0, 0, 0, 878, 867, 1, 0, 0, 0, 878, 874, 1, 0, 0, 0, 879, 15, 1, 0, 0, + 0, 880, 881, 5, 567, 0, 0, 881, 882, 5, 55, 0, 0, 882, 883, 5, 2, 0, 0, + 883, 884, 3, 464, 232, 0, 884, 885, 5, 3, 0, 0, 885, 17, 1, 0, 0, 0, 886, + 888, 3, 198, 99, 0, 887, 886, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 890, + 1, 0, 0, 0, 889, 891, 3, 242, 121, 0, 890, 889, 1, 0, 0, 0, 890, 891, 1, + 0, 0, 0, 891, 892, 1, 0, 0, 0, 892, 896, 5, 237, 0, 0, 893, 897, 5, 244, + 0, 0, 894, 895, 5, 342, 0, 0, 895, 897, 5, 472, 0, 0, 896, 893, 1, 0, 0, + 0, 896, 894, 1, 0, 0, 0, 897, 906, 1, 0, 0, 0, 898, 900, 3, 338, 169, 0, + 899, 901, 3, 16, 8, 0, 900, 899, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, + 907, 1, 0, 0, 0, 902, 903, 5, 149, 0, 0, 903, 904, 5, 2, 0, 0, 904, 905, + 5, 575, 0, 0, 905, 907, 5, 3, 0, 0, 906, 898, 1, 0, 0, 0, 906, 902, 1, + 0, 0, 0, 907, 909, 1, 0, 0, 0, 908, 910, 3, 164, 82, 0, 909, 908, 1, 0, + 0, 0, 909, 910, 1, 0, 0, 0, 910, 914, 1, 0, 0, 0, 911, 912, 5, 537, 0, + 0, 912, 913, 5, 262, 0, 0, 913, 915, 3, 464, 232, 0, 914, 911, 1, 0, 0, + 0, 914, 915, 1, 0, 0, 0, 915, 917, 1, 0, 0, 0, 916, 918, 3, 316, 158, 0, + 917, 916, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 923, 1, 0, 0, 0, 919, + 920, 5, 7, 0, 0, 920, 921, 3, 318, 159, 0, 921, 922, 5, 8, 0, 0, 922, 924, + 1, 0, 0, 0, 923, 919, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 925, 1, 0, + 0, 0, 925, 1065, 3, 232, 116, 0, 926, 928, 3, 198, 99, 0, 927, 926, 1, + 0, 0, 0, 927, 928, 1, 0, 0, 0, 928, 930, 1, 0, 0, 0, 929, 931, 3, 242, + 121, 0, 930, 929, 1, 0, 0, 0, 930, 931, 1, 0, 0, 0, 931, 932, 1, 0, 0, + 0, 932, 933, 5, 513, 0, 0, 933, 934, 3, 338, 169, 0, 934, 935, 3, 336, + 168, 0, 935, 936, 5, 439, 0, 0, 936, 938, 3, 298, 149, 0, 937, 939, 3, + 254, 127, 0, 938, 937, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 941, 1, 0, + 0, 0, 940, 942, 3, 252, 126, 0, 941, 940, 1, 0, 0, 0, 941, 942, 1, 0, 0, + 0, 942, 1065, 1, 0, 0, 0, 943, 945, 3, 198, 99, 0, 944, 943, 1, 0, 0, 0, + 944, 945, 1, 0, 0, 0, 945, 947, 1, 0, 0, 0, 946, 948, 3, 242, 121, 0, 947, + 946, 1, 0, 0, 0, 947, 948, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 950, + 5, 133, 0, 0, 950, 951, 5, 198, 0, 0, 951, 953, 3, 338, 169, 0, 952, 954, + 3, 164, 82, 0, 953, 952, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0, 954, 955, 1, + 0, 0, 0, 955, 958, 3, 336, 168, 0, 956, 957, 5, 517, 0, 0, 957, 959, 3, + 262, 131, 0, 958, 956, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 961, 1, 0, + 0, 0, 960, 962, 3, 252, 126, 0, 961, 960, 1, 0, 0, 0, 961, 962, 1, 0, 0, + 0, 962, 1065, 1, 0, 0, 0, 963, 965, 3, 198, 99, 0, 964, 963, 1, 0, 0, 0, + 964, 965, 1, 0, 0, 0, 965, 967, 1, 0, 0, 0, 966, 968, 3, 242, 121, 0, 967, + 966, 1, 0, 0, 0, 967, 968, 1, 0, 0, 0, 968, 969, 1, 0, 0, 0, 969, 970, + 5, 302, 0, 0, 970, 971, 5, 244, 0, 0, 971, 976, 3, 338, 169, 0, 972, 974, + 5, 29, 0, 0, 973, 972, 1, 0, 0, 0, 973, 974, 1, 0, 0, 0, 974, 975, 1, 0, + 0, 0, 975, 977, 3, 464, 232, 0, 976, 973, 1, 0, 0, 0, 976, 977, 1, 0, 0, + 0, 977, 978, 1, 0, 0, 0, 978, 979, 5, 517, 0, 0, 979, 980, 3, 322, 161, + 0, 980, 981, 5, 331, 0, 0, 981, 984, 3, 382, 191, 0, 982, 985, 3, 20, 10, + 0, 983, 985, 3, 22, 11, 0, 984, 982, 1, 0, 0, 0, 984, 983, 1, 0, 0, 0, + 985, 986, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 986, 987, 1, 0, 0, 0, 987, + 1065, 1, 0, 0, 0, 988, 989, 5, 278, 0, 0, 989, 990, 5, 262, 0, 0, 990, + 991, 3, 338, 169, 0, 991, 992, 5, 2, 0, 0, 992, 997, 3, 172, 86, 0, 993, + 994, 5, 4, 0, 0, 994, 996, 3, 172, 86, 0, 995, 993, 1, 0, 0, 0, 996, 999, + 1, 0, 0, 0, 997, 995, 1, 0, 0, 0, 997, 998, 1, 0, 0, 0, 998, 1000, 1, 0, + 0, 0, 999, 997, 1, 0, 0, 0, 1000, 1002, 5, 3, 0, 0, 1001, 1003, 3, 222, + 111, 0, 1002, 1001, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 1005, 1, + 0, 0, 0, 1004, 1006, 3, 326, 163, 0, 1005, 1004, 1, 0, 0, 0, 1005, 1006, + 1, 0, 0, 0, 1006, 1008, 1, 0, 0, 0, 1007, 1009, 3, 452, 226, 0, 1008, 1007, + 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1065, 1, 0, 0, 0, 1010, 1011, + 5, 178, 0, 0, 1011, 1012, 5, 472, 0, 0, 1012, 1015, 3, 338, 169, 0, 1013, + 1014, 5, 345, 0, 0, 1014, 1016, 3, 316, 158, 0, 1015, 1013, 1, 0, 0, 0, + 1015, 1016, 1, 0, 0, 0, 1016, 1018, 1, 0, 0, 0, 1017, 1019, 3, 252, 126, + 0, 1018, 1017, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 1020, 1, 0, 0, + 0, 1020, 1021, 5, 489, 0, 0, 1021, 1023, 5, 569, 0, 0, 1022, 1024, 3, 326, + 163, 0, 1023, 1022, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1026, 1, + 0, 0, 0, 1025, 1027, 3, 222, 111, 0, 1026, 1025, 1, 0, 0, 0, 1026, 1027, + 1, 0, 0, 0, 1027, 1065, 1, 0, 0, 0, 1028, 1065, 3, 204, 102, 0, 1029, 1030, + 5, 101, 0, 0, 1030, 1032, 5, 244, 0, 0, 1031, 1033, 3, 288, 144, 0, 1032, + 1031, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1034, 1, 0, 0, 0, 1034, + 1036, 3, 338, 169, 0, 1035, 1037, 3, 316, 158, 0, 1036, 1035, 1, 0, 0, + 0, 1036, 1037, 1, 0, 0, 0, 1037, 1038, 1, 0, 0, 0, 1038, 1050, 5, 198, + 0, 0, 1039, 1051, 3, 158, 79, 0, 1040, 1041, 5, 2, 0, 0, 1041, 1042, 5, + 433, 0, 0, 1042, 1043, 3, 250, 125, 0, 1043, 1044, 5, 198, 0, 0, 1044, + 1046, 3, 158, 79, 0, 1045, 1047, 3, 252, 126, 0, 1046, 1045, 1, 0, 0, 0, + 1046, 1047, 1, 0, 0, 0, 1047, 1048, 1, 0, 0, 0, 1048, 1049, 5, 3, 0, 0, + 1049, 1051, 1, 0, 0, 0, 1050, 1039, 1, 0, 0, 0, 1050, 1040, 1, 0, 0, 0, + 1051, 1053, 1, 0, 0, 0, 1052, 1054, 3, 326, 163, 0, 1053, 1052, 1, 0, 0, + 0, 1053, 1054, 1, 0, 0, 0, 1054, 1065, 1, 0, 0, 0, 1055, 1056, 5, 499, + 0, 0, 1056, 1057, 5, 472, 0, 0, 1057, 1059, 3, 338, 169, 0, 1058, 1060, + 3, 420, 210, 0, 1059, 1058, 1, 0, 0, 0, 1059, 1060, 1, 0, 0, 0, 1060, 1062, + 1, 0, 0, 0, 1061, 1063, 5, 195, 0, 0, 1062, 1061, 1, 0, 0, 0, 1062, 1063, + 1, 0, 0, 0, 1063, 1065, 1, 0, 0, 0, 1064, 887, 1, 0, 0, 0, 1064, 927, 1, + 0, 0, 0, 1064, 944, 1, 0, 0, 0, 1064, 964, 1, 0, 0, 0, 1064, 988, 1, 0, + 0, 0, 1064, 1010, 1, 0, 0, 0, 1064, 1028, 1, 0, 0, 0, 1064, 1029, 1, 0, + 0, 0, 1064, 1055, 1, 0, 0, 0, 1065, 19, 1, 0, 0, 0, 1066, 1067, 5, 534, + 0, 0, 1067, 1070, 5, 289, 0, 0, 1068, 1069, 5, 25, 0, 0, 1069, 1071, 3, + 382, 191, 0, 1070, 1068, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1072, + 1, 0, 0, 0, 1072, 1077, 5, 485, 0, 0, 1073, 1074, 5, 513, 0, 0, 1074, 1075, + 5, 439, 0, 0, 1075, 1078, 3, 298, 149, 0, 1076, 1078, 5, 133, 0, 0, 1077, + 1073, 1, 0, 0, 0, 1077, 1076, 1, 0, 0, 0, 1078, 21, 1, 0, 0, 0, 1079, 1080, + 5, 534, 0, 0, 1080, 1081, 5, 325, 0, 0, 1081, 1084, 5, 289, 0, 0, 1082, + 1083, 5, 25, 0, 0, 1083, 1085, 3, 382, 191, 0, 1084, 1082, 1, 0, 0, 0, + 1084, 1085, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, 1086, 1087, 5, 485, 0, + 0, 1087, 1089, 5, 237, 0, 0, 1088, 1090, 3, 316, 158, 0, 1089, 1088, 1, + 0, 0, 0, 1089, 1090, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1092, 5, + 519, 0, 0, 1092, 1093, 3, 390, 195, 0, 1093, 23, 1, 0, 0, 0, 1094, 1096, + 5, 103, 0, 0, 1095, 1097, 7, 4, 0, 0, 1096, 1095, 1, 0, 0, 0, 1096, 1097, + 1, 0, 0, 0, 1097, 1098, 1, 0, 0, 0, 1098, 1102, 5, 472, 0, 0, 1099, 1100, + 5, 228, 0, 0, 1100, 1101, 5, 325, 0, 0, 1101, 1103, 5, 175, 0, 0, 1102, + 1099, 1, 0, 0, 0, 1102, 1103, 1, 0, 0, 0, 1103, 1104, 1, 0, 0, 0, 1104, + 1119, 3, 338, 169, 0, 1105, 1107, 3, 316, 158, 0, 1106, 1105, 1, 0, 0, + 0, 1106, 1107, 1, 0, 0, 0, 1107, 1120, 1, 0, 0, 0, 1108, 1109, 5, 2, 0, + 0, 1109, 1112, 3, 344, 172, 0, 1110, 1111, 5, 4, 0, 0, 1111, 1113, 3, 348, + 174, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, + 0, 0, 0, 1114, 1116, 5, 4, 0, 0, 1115, 1114, 1, 0, 0, 0, 1115, 1116, 1, + 0, 0, 0, 1116, 1117, 1, 0, 0, 0, 1117, 1118, 5, 3, 0, 0, 1118, 1120, 1, + 0, 0, 0, 1119, 1106, 1, 0, 0, 0, 1119, 1108, 1, 0, 0, 0, 1120, 1124, 1, + 0, 0, 0, 1121, 1122, 5, 165, 0, 0, 1122, 1123, 5, 543, 0, 0, 1123, 1125, + 3, 464, 232, 0, 1124, 1121, 1, 0, 0, 0, 1124, 1125, 1, 0, 0, 0, 1125, 1134, + 1, 0, 0, 0, 1126, 1127, 7, 5, 0, 0, 1127, 1128, 5, 259, 0, 0, 1128, 1132, + 3, 316, 158, 0, 1129, 1130, 5, 77, 0, 0, 1130, 1131, 5, 62, 0, 0, 1131, + 1133, 3, 316, 158, 0, 1132, 1129, 1, 0, 0, 0, 1132, 1133, 1, 0, 0, 0, 1133, + 1135, 1, 0, 0, 0, 1134, 1126, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, + 1138, 1, 0, 0, 0, 1136, 1137, 5, 85, 0, 0, 1137, 1139, 5, 569, 0, 0, 1138, + 1136, 1, 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 1141, 1, 0, 0, 0, 1140, + 1142, 3, 166, 83, 0, 1141, 1140, 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, + 1157, 1, 0, 0, 0, 1143, 1144, 5, 145, 0, 0, 1144, 1148, 5, 62, 0, 0, 1145, + 1146, 5, 214, 0, 0, 1146, 1149, 3, 316, 158, 0, 1147, 1149, 5, 384, 0, + 0, 1148, 1145, 1, 0, 0, 0, 1148, 1147, 1, 0, 0, 0, 1149, 1155, 1, 0, 0, + 0, 1150, 1153, 5, 58, 0, 0, 1151, 1154, 5, 575, 0, 0, 1152, 1154, 5, 33, + 0, 0, 1153, 1151, 1, 0, 0, 0, 1153, 1152, 1, 0, 0, 0, 1154, 1156, 1, 0, + 0, 0, 1155, 1150, 1, 0, 0, 0, 1155, 1156, 1, 0, 0, 0, 1156, 1158, 1, 0, + 0, 0, 1157, 1143, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1164, 1, 0, + 0, 0, 1159, 1160, 5, 420, 0, 0, 1160, 1161, 5, 2, 0, 0, 1161, 1162, 3, + 368, 184, 0, 1162, 1163, 5, 3, 0, 0, 1163, 1165, 1, 0, 0, 0, 1164, 1159, + 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1167, 1, 0, 0, 0, 1166, 1168, + 3, 326, 163, 0, 1167, 1166, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1171, + 1, 0, 0, 0, 1169, 1170, 5, 57, 0, 0, 1170, 1172, 3, 326, 163, 0, 1171, + 1169, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1177, 1, 0, 0, 0, 1173, + 1175, 5, 29, 0, 0, 1174, 1173, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, + 1176, 1, 0, 0, 0, 1176, 1178, 3, 232, 116, 0, 1177, 1174, 1, 0, 0, 0, 1177, + 1178, 1, 0, 0, 0, 1178, 1602, 1, 0, 0, 0, 1179, 1182, 5, 103, 0, 0, 1180, + 1181, 5, 337, 0, 0, 1181, 1183, 5, 399, 0, 0, 1182, 1180, 1, 0, 0, 0, 1182, + 1183, 1, 0, 0, 0, 1183, 1184, 1, 0, 0, 0, 1184, 1188, 5, 529, 0, 0, 1185, + 1186, 5, 228, 0, 0, 1186, 1187, 5, 325, 0, 0, 1187, 1189, 5, 175, 0, 0, + 1188, 1185, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, + 1190, 1195, 3, 338, 169, 0, 1191, 1192, 5, 2, 0, 0, 1192, 1193, 3, 340, + 170, 0, 1193, 1194, 5, 3, 0, 0, 1194, 1196, 1, 0, 0, 0, 1195, 1191, 1, + 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1199, 1, 0, 0, 0, 1197, 1198, 5, + 85, 0, 0, 1198, 1200, 5, 569, 0, 0, 1199, 1197, 1, 0, 0, 0, 1199, 1200, + 1, 0, 0, 0, 1200, 1202, 1, 0, 0, 0, 1201, 1203, 5, 29, 0, 0, 1202, 1201, + 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 1204, 1, 0, 0, 0, 1204, 1205, + 3, 232, 116, 0, 1205, 1602, 1, 0, 0, 0, 1206, 1207, 5, 103, 0, 0, 1207, + 1208, 5, 187, 0, 0, 1208, 1211, 5, 569, 0, 0, 1209, 1210, 7, 6, 0, 0, 1210, + 1212, 3, 464, 232, 0, 1211, 1209, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, + 1213, 1, 0, 0, 0, 1213, 1602, 3, 326, 163, 0, 1214, 1216, 5, 103, 0, 0, + 1215, 1217, 7, 4, 0, 0, 1216, 1215, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, + 1217, 1218, 1, 0, 0, 0, 1218, 1222, 5, 472, 0, 0, 1219, 1220, 5, 228, 0, + 0, 1220, 1221, 5, 325, 0, 0, 1221, 1223, 5, 175, 0, 0, 1222, 1219, 1, 0, + 0, 0, 1222, 1223, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1225, 3, 338, + 169, 0, 1225, 1226, 5, 273, 0, 0, 1226, 1232, 3, 338, 169, 0, 1227, 1228, + 5, 537, 0, 0, 1228, 1230, 5, 420, 0, 0, 1229, 1231, 3, 316, 158, 0, 1230, + 1229, 1, 0, 0, 0, 1230, 1231, 1, 0, 0, 0, 1231, 1233, 1, 0, 0, 0, 1232, + 1227, 1, 0, 0, 0, 1232, 1233, 1, 0, 0, 0, 1233, 1602, 1, 0, 0, 0, 1234, + 1235, 5, 103, 0, 0, 1235, 1239, 5, 417, 0, 0, 1236, 1237, 5, 228, 0, 0, + 1237, 1238, 5, 325, 0, 0, 1238, 1240, 5, 175, 0, 0, 1239, 1236, 1, 0, 0, + 0, 1239, 1240, 1, 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1244, 3, 186, + 93, 0, 1242, 1243, 5, 85, 0, 0, 1243, 1245, 5, 569, 0, 0, 1244, 1242, 1, + 0, 0, 0, 1244, 1245, 1, 0, 0, 0, 1245, 1602, 1, 0, 0, 0, 1246, 1247, 5, + 103, 0, 0, 1247, 1248, 5, 539, 0, 0, 1248, 1252, 5, 210, 0, 0, 1249, 1250, + 5, 228, 0, 0, 1250, 1251, 5, 325, 0, 0, 1251, 1253, 5, 175, 0, 0, 1252, + 1249, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, + 1257, 3, 186, 93, 0, 1255, 1256, 5, 193, 0, 0, 1256, 1258, 3, 186, 93, + 0, 1257, 1255, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1260, 1, 0, 0, + 0, 1259, 1261, 3, 326, 163, 0, 1260, 1259, 1, 0, 0, 0, 1260, 1261, 1, 0, + 0, 0, 1261, 1602, 1, 0, 0, 0, 1262, 1263, 5, 103, 0, 0, 1263, 1267, 5, + 69, 0, 0, 1264, 1265, 5, 228, 0, 0, 1265, 1266, 5, 325, 0, 0, 1266, 1268, + 5, 175, 0, 0, 1267, 1264, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, + 1, 0, 0, 0, 1269, 1273, 3, 464, 232, 0, 1270, 1271, 5, 537, 0, 0, 1271, + 1272, 5, 405, 0, 0, 1272, 1274, 3, 464, 232, 0, 1273, 1270, 1, 0, 0, 0, + 1273, 1274, 1, 0, 0, 0, 1274, 1277, 1, 0, 0, 0, 1275, 1276, 5, 85, 0, 0, + 1276, 1278, 5, 569, 0, 0, 1277, 1275, 1, 0, 0, 0, 1277, 1278, 1, 0, 0, + 0, 1278, 1280, 1, 0, 0, 0, 1279, 1281, 3, 326, 163, 0, 1280, 1279, 1, 0, + 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, 1602, 1, 0, 0, 0, 1282, 1283, 5, 103, + 0, 0, 1283, 1284, 5, 424, 0, 0, 1284, 1288, 5, 366, 0, 0, 1285, 1286, 5, + 228, 0, 0, 1286, 1287, 5, 325, 0, 0, 1287, 1289, 5, 175, 0, 0, 1288, 1285, + 1, 0, 0, 0, 1288, 1289, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1291, + 3, 464, 232, 0, 1291, 1292, 5, 331, 0, 0, 1292, 1293, 3, 338, 169, 0, 1293, + 1294, 5, 29, 0, 0, 1294, 1295, 7, 7, 0, 0, 1295, 1299, 5, 489, 0, 0, 1296, + 1300, 3, 194, 97, 0, 1297, 1298, 5, 417, 0, 0, 1298, 1300, 3, 186, 93, + 0, 1299, 1296, 1, 0, 0, 0, 1299, 1297, 1, 0, 0, 0, 1300, 1301, 1, 0, 0, + 0, 1301, 1302, 5, 517, 0, 0, 1302, 1303, 5, 2, 0, 0, 1303, 1304, 3, 388, + 194, 0, 1304, 1305, 5, 3, 0, 0, 1305, 1602, 1, 0, 0, 0, 1306, 1307, 5, + 103, 0, 0, 1307, 1308, 5, 460, 0, 0, 1308, 1312, 5, 366, 0, 0, 1309, 1310, + 5, 228, 0, 0, 1310, 1311, 5, 325, 0, 0, 1311, 1313, 5, 175, 0, 0, 1312, + 1309, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, + 1316, 3, 464, 232, 0, 1315, 1317, 3, 326, 163, 0, 1316, 1315, 1, 0, 0, + 0, 1316, 1317, 1, 0, 0, 0, 1317, 1602, 1, 0, 0, 0, 1318, 1319, 5, 59, 0, + 0, 1319, 1321, 5, 233, 0, 0, 1320, 1322, 3, 464, 232, 0, 1321, 1320, 1, + 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 1324, 5, + 331, 0, 0, 1324, 1326, 3, 338, 169, 0, 1325, 1327, 3, 164, 82, 0, 1326, + 1325, 1, 0, 0, 0, 1326, 1327, 1, 0, 0, 0, 1327, 1602, 1, 0, 0, 0, 1328, + 1329, 5, 103, 0, 0, 1329, 1333, 5, 233, 0, 0, 1330, 1331, 5, 228, 0, 0, + 1331, 1332, 5, 325, 0, 0, 1332, 1334, 5, 175, 0, 0, 1333, 1330, 1, 0, 0, + 0, 1333, 1334, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1336, 3, 464, + 232, 0, 1336, 1337, 5, 331, 0, 0, 1337, 1338, 3, 338, 169, 0, 1338, 1341, + 3, 316, 158, 0, 1339, 1340, 5, 517, 0, 0, 1340, 1342, 7, 8, 0, 0, 1341, + 1339, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1344, 1, 0, 0, 0, 1343, + 1345, 3, 326, 163, 0, 1344, 1343, 1, 0, 0, 0, 1344, 1345, 1, 0, 0, 0, 1345, + 1348, 1, 0, 0, 0, 1346, 1347, 5, 85, 0, 0, 1347, 1349, 5, 569, 0, 0, 1348, + 1346, 1, 0, 0, 0, 1348, 1349, 1, 0, 0, 0, 1349, 1602, 1, 0, 0, 0, 1350, + 1351, 5, 103, 0, 0, 1351, 1352, 5, 539, 0, 0, 1352, 1356, 5, 366, 0, 0, + 1353, 1354, 5, 228, 0, 0, 1354, 1355, 5, 325, 0, 0, 1355, 1357, 5, 175, + 0, 0, 1356, 1353, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 1358, 1, 0, + 0, 0, 1358, 1364, 3, 186, 93, 0, 1359, 1360, 5, 92, 0, 0, 1360, 1361, 5, + 2, 0, 0, 1361, 1362, 3, 130, 65, 0, 1362, 1363, 5, 3, 0, 0, 1363, 1365, + 1, 0, 0, 0, 1364, 1359, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1371, + 1, 0, 0, 0, 1366, 1367, 5, 13, 0, 0, 1367, 1368, 5, 2, 0, 0, 1368, 1369, + 3, 126, 63, 0, 1369, 1370, 5, 3, 0, 0, 1370, 1372, 1, 0, 0, 0, 1371, 1366, + 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374, 1, 0, 0, 0, 1373, 1375, + 3, 326, 163, 0, 1374, 1373, 1, 0, 0, 0, 1374, 1375, 1, 0, 0, 0, 1375, 1602, + 1, 0, 0, 0, 1376, 1377, 5, 103, 0, 0, 1377, 1381, 5, 452, 0, 0, 1378, 1379, + 5, 228, 0, 0, 1379, 1380, 5, 325, 0, 0, 1380, 1382, 5, 175, 0, 0, 1381, + 1378, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, 1383, 1, 0, 0, 0, 1383, + 1385, 3, 464, 232, 0, 1384, 1386, 3, 326, 163, 0, 1385, 1384, 1, 0, 0, + 0, 1385, 1386, 1, 0, 0, 0, 1386, 1602, 1, 0, 0, 0, 1387, 1388, 5, 103, + 0, 0, 1388, 1392, 5, 161, 0, 0, 1389, 1390, 5, 228, 0, 0, 1390, 1391, 5, + 325, 0, 0, 1391, 1393, 5, 175, 0, 0, 1392, 1389, 1, 0, 0, 0, 1392, 1393, + 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 1395, 3, 338, 169, 0, 1395, 1396, + 5, 29, 0, 0, 1396, 1397, 5, 569, 0, 0, 1397, 1602, 1, 0, 0, 0, 1398, 1400, + 5, 103, 0, 0, 1399, 1401, 3, 174, 87, 0, 1400, 1399, 1, 0, 0, 0, 1400, + 1401, 1, 0, 0, 0, 1401, 1403, 1, 0, 0, 0, 1402, 1404, 7, 9, 0, 0, 1403, + 1402, 1, 0, 0, 0, 1403, 1404, 1, 0, 0, 0, 1404, 1405, 1, 0, 0, 0, 1405, + 1409, 5, 202, 0, 0, 1406, 1407, 5, 228, 0, 0, 1407, 1408, 5, 325, 0, 0, + 1408, 1410, 5, 175, 0, 0, 1409, 1406, 1, 0, 0, 0, 1409, 1410, 1, 0, 0, + 0, 1410, 1411, 1, 0, 0, 0, 1411, 1412, 3, 406, 203, 0, 1412, 1414, 5, 2, + 0, 0, 1413, 1415, 3, 138, 69, 0, 1414, 1413, 1, 0, 0, 0, 1414, 1415, 1, + 0, 0, 0, 1415, 1416, 1, 0, 0, 0, 1416, 1417, 5, 3, 0, 0, 1417, 1418, 5, + 412, 0, 0, 1418, 1421, 3, 436, 218, 0, 1419, 1420, 5, 241, 0, 0, 1420, + 1422, 3, 436, 218, 0, 1421, 1419, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, + 1424, 1, 0, 0, 0, 1423, 1425, 3, 326, 163, 0, 1424, 1423, 1, 0, 0, 0, 1424, + 1425, 1, 0, 0, 0, 1425, 1602, 1, 0, 0, 0, 1426, 1428, 5, 103, 0, 0, 1427, + 1429, 3, 174, 87, 0, 1428, 1427, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, + 1430, 1, 0, 0, 0, 1430, 1431, 5, 19, 0, 0, 1431, 1435, 5, 202, 0, 0, 1432, + 1433, 5, 228, 0, 0, 1433, 1434, 5, 325, 0, 0, 1434, 1436, 5, 175, 0, 0, + 1435, 1432, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1437, 1, 0, 0, 0, + 1437, 1438, 3, 406, 203, 0, 1438, 1440, 5, 2, 0, 0, 1439, 1441, 3, 138, + 69, 0, 1440, 1439, 1, 0, 0, 0, 1440, 1441, 1, 0, 0, 0, 1441, 1442, 1, 0, + 0, 0, 1442, 1443, 5, 3, 0, 0, 1443, 1444, 5, 537, 0, 0, 1444, 1445, 5, + 343, 0, 0, 1445, 1447, 5, 2, 0, 0, 1446, 1448, 3, 318, 159, 0, 1447, 1446, + 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, 1449, 1, 0, 0, 0, 1449, 1450, + 5, 3, 0, 0, 1450, 1451, 5, 29, 0, 0, 1451, 1452, 3, 382, 191, 0, 1452, + 1602, 1, 0, 0, 0, 1453, 1454, 5, 103, 0, 0, 1454, 1458, 5, 515, 0, 0, 1455, + 1456, 5, 228, 0, 0, 1456, 1457, 5, 325, 0, 0, 1457, 1459, 5, 175, 0, 0, + 1458, 1455, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1460, 1, 0, 0, 0, + 1460, 1465, 3, 196, 98, 0, 1461, 1466, 5, 468, 0, 0, 1462, 1463, 5, 131, + 0, 0, 1463, 1464, 5, 417, 0, 0, 1464, 1466, 5, 569, 0, 0, 1465, 1461, 1, + 0, 0, 0, 1465, 1462, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1467, 1, + 0, 0, 0, 1467, 1469, 3, 136, 68, 0, 1468, 1470, 3, 452, 226, 0, 1469, 1468, + 1, 0, 0, 0, 1469, 1470, 1, 0, 0, 0, 1470, 1602, 1, 0, 0, 0, 1471, 1472, + 5, 103, 0, 0, 1472, 1476, 7, 10, 0, 0, 1473, 1474, 5, 228, 0, 0, 1474, + 1475, 5, 325, 0, 0, 1475, 1477, 5, 175, 0, 0, 1476, 1473, 1, 0, 0, 0, 1476, + 1477, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1480, 3, 338, 169, 0, 1479, + 1481, 3, 326, 163, 0, 1480, 1479, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, + 1602, 1, 0, 0, 0, 1482, 1485, 5, 103, 0, 0, 1483, 1484, 5, 386, 0, 0, 1484, + 1486, 5, 333, 0, 0, 1485, 1483, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, + 1487, 1, 0, 0, 0, 1487, 1488, 5, 404, 0, 0, 1488, 1489, 3, 464, 232, 0, + 1489, 1490, 5, 537, 0, 0, 1490, 1491, 3, 134, 67, 0, 1491, 1602, 1, 0, + 0, 0, 1492, 1494, 5, 103, 0, 0, 1493, 1495, 5, 180, 0, 0, 1494, 1493, 1, + 0, 0, 0, 1494, 1495, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 1500, 5, + 405, 0, 0, 1497, 1498, 5, 228, 0, 0, 1498, 1499, 5, 325, 0, 0, 1499, 1501, + 5, 175, 0, 0, 1500, 1497, 1, 0, 0, 0, 1500, 1501, 1, 0, 0, 0, 1501, 1502, + 1, 0, 0, 0, 1502, 1504, 3, 186, 93, 0, 1503, 1505, 3, 326, 163, 0, 1504, + 1503, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1602, 1, 0, 0, 0, 1506, + 1507, 5, 103, 0, 0, 1507, 1511, 5, 140, 0, 0, 1508, 1509, 5, 228, 0, 0, + 1509, 1510, 5, 325, 0, 0, 1510, 1512, 5, 175, 0, 0, 1511, 1508, 1, 0, 0, + 0, 1511, 1512, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1514, 3, 338, + 169, 0, 1514, 1515, 5, 517, 0, 0, 1515, 1516, 3, 338, 169, 0, 1516, 1517, + 5, 2, 0, 0, 1517, 1518, 3, 26, 13, 0, 1518, 1519, 5, 3, 0, 0, 1519, 1520, + 5, 264, 0, 0, 1520, 1521, 5, 2, 0, 0, 1521, 1522, 3, 464, 232, 0, 1522, + 1524, 5, 3, 0, 0, 1523, 1525, 3, 326, 163, 0, 1524, 1523, 1, 0, 0, 0, 1524, + 1525, 1, 0, 0, 0, 1525, 1602, 1, 0, 0, 0, 1526, 1527, 5, 103, 0, 0, 1527, + 1531, 5, 453, 0, 0, 1528, 1529, 5, 228, 0, 0, 1529, 1530, 5, 325, 0, 0, + 1530, 1532, 5, 175, 0, 0, 1531, 1528, 1, 0, 0, 0, 1531, 1532, 1, 0, 0, + 0, 1532, 1533, 1, 0, 0, 0, 1533, 1535, 3, 464, 232, 0, 1534, 1536, 3, 326, + 163, 0, 1535, 1534, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1602, 1, + 0, 0, 0, 1537, 1538, 5, 103, 0, 0, 1538, 1539, 5, 460, 0, 0, 1539, 1543, + 5, 525, 0, 0, 1540, 1541, 5, 228, 0, 0, 1541, 1542, 5, 325, 0, 0, 1542, + 1544, 5, 175, 0, 0, 1543, 1540, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, + 1545, 1, 0, 0, 0, 1545, 1547, 3, 186, 93, 0, 1546, 1548, 3, 326, 163, 0, + 1547, 1546, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 1602, 1, 0, 0, 0, + 1549, 1550, 5, 103, 0, 0, 1550, 1551, 5, 245, 0, 0, 1551, 1552, 5, 233, + 0, 0, 1552, 1556, 5, 24, 0, 0, 1553, 1554, 5, 228, 0, 0, 1554, 1555, 5, + 325, 0, 0, 1555, 1557, 5, 175, 0, 0, 1556, 1553, 1, 0, 0, 0, 1556, 1557, + 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1560, 3, 464, 232, 0, 1559, 1561, + 3, 326, 163, 0, 1560, 1559, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1602, + 1, 0, 0, 0, 1562, 1563, 5, 103, 0, 0, 1563, 1564, 5, 245, 0, 0, 1564, 1565, + 5, 233, 0, 0, 1565, 1569, 5, 490, 0, 0, 1566, 1567, 5, 228, 0, 0, 1567, + 1568, 5, 325, 0, 0, 1568, 1570, 5, 175, 0, 0, 1569, 1566, 1, 0, 0, 0, 1569, + 1570, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1573, 3, 464, 232, 0, 1572, + 1574, 3, 326, 163, 0, 1573, 1572, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, + 1602, 1, 0, 0, 0, 1575, 1576, 5, 103, 0, 0, 1576, 1577, 5, 245, 0, 0, 1577, + 1578, 5, 233, 0, 0, 1578, 1582, 5, 491, 0, 0, 1579, 1580, 5, 228, 0, 0, + 1580, 1581, 5, 325, 0, 0, 1581, 1583, 5, 175, 0, 0, 1582, 1579, 1, 0, 0, + 0, 1582, 1583, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1586, 3, 464, + 232, 0, 1585, 1587, 3, 326, 163, 0, 1586, 1585, 1, 0, 0, 0, 1586, 1587, + 1, 0, 0, 0, 1587, 1602, 1, 0, 0, 0, 1588, 1589, 5, 103, 0, 0, 1589, 1590, + 5, 245, 0, 0, 1590, 1591, 5, 233, 0, 0, 1591, 1595, 5, 74, 0, 0, 1592, + 1593, 5, 228, 0, 0, 1593, 1594, 5, 325, 0, 0, 1594, 1596, 5, 175, 0, 0, + 1595, 1592, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, + 1597, 1599, 3, 464, 232, 0, 1598, 1600, 3, 326, 163, 0, 1599, 1598, 1, + 0, 0, 0, 1599, 1600, 1, 0, 0, 0, 1600, 1602, 1, 0, 0, 0, 1601, 1094, 1, + 0, 0, 0, 1601, 1179, 1, 0, 0, 0, 1601, 1206, 1, 0, 0, 0, 1601, 1214, 1, + 0, 0, 0, 1601, 1234, 1, 0, 0, 0, 1601, 1246, 1, 0, 0, 0, 1601, 1262, 1, + 0, 0, 0, 1601, 1282, 1, 0, 0, 0, 1601, 1306, 1, 0, 0, 0, 1601, 1318, 1, + 0, 0, 0, 1601, 1328, 1, 0, 0, 0, 1601, 1350, 1, 0, 0, 0, 1601, 1376, 1, + 0, 0, 0, 1601, 1387, 1, 0, 0, 0, 1601, 1398, 1, 0, 0, 0, 1601, 1426, 1, + 0, 0, 0, 1601, 1453, 1, 0, 0, 0, 1601, 1471, 1, 0, 0, 0, 1601, 1482, 1, + 0, 0, 0, 1601, 1492, 1, 0, 0, 0, 1601, 1506, 1, 0, 0, 0, 1601, 1526, 1, + 0, 0, 0, 1601, 1537, 1, 0, 0, 0, 1601, 1549, 1, 0, 0, 0, 1601, 1562, 1, + 0, 0, 0, 1601, 1575, 1, 0, 0, 0, 1601, 1588, 1, 0, 0, 0, 1602, 25, 1, 0, + 0, 0, 1603, 1608, 3, 28, 14, 0, 1604, 1605, 5, 4, 0, 0, 1605, 1607, 3, + 28, 14, 0, 1606, 1604, 1, 0, 0, 0, 1607, 1610, 1, 0, 0, 0, 1608, 1606, + 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 27, 1, 0, 0, 0, 1610, 1608, 1, + 0, 0, 0, 1611, 1612, 3, 464, 232, 0, 1612, 1613, 7, 11, 0, 0, 1613, 29, + 1, 0, 0, 0, 1614, 1615, 5, 21, 0, 0, 1615, 1616, 5, 471, 0, 0, 1616, 1861, + 3, 86, 43, 0, 1617, 1618, 5, 21, 0, 0, 1618, 1619, 5, 529, 0, 0, 1619, + 1634, 3, 338, 169, 0, 1620, 1621, 5, 311, 0, 0, 1621, 1635, 3, 452, 226, + 0, 1622, 1623, 5, 2, 0, 0, 1623, 1624, 3, 340, 170, 0, 1624, 1625, 5, 3, + 0, 0, 1625, 1627, 1, 0, 0, 0, 1626, 1622, 1, 0, 0, 0, 1626, 1627, 1, 0, + 0, 0, 1627, 1630, 1, 0, 0, 0, 1628, 1629, 5, 85, 0, 0, 1629, 1631, 5, 569, + 0, 0, 1630, 1628, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1632, 1, 0, + 0, 0, 1632, 1633, 5, 29, 0, 0, 1633, 1635, 3, 232, 116, 0, 1634, 1620, + 1, 0, 0, 0, 1634, 1626, 1, 0, 0, 0, 1635, 1861, 1, 0, 0, 0, 1636, 1637, + 5, 21, 0, 0, 1637, 1638, 5, 69, 0, 0, 1638, 1639, 3, 464, 232, 0, 1639, + 1640, 5, 396, 0, 0, 1640, 1641, 3, 464, 232, 0, 1641, 1861, 1, 0, 0, 0, + 1642, 1643, 5, 21, 0, 0, 1643, 1644, 5, 417, 0, 0, 1644, 1645, 3, 186, + 93, 0, 1645, 1646, 3, 452, 226, 0, 1646, 1861, 1, 0, 0, 0, 1647, 1648, + 5, 21, 0, 0, 1648, 1649, 5, 460, 0, 0, 1649, 1650, 5, 525, 0, 0, 1650, + 1651, 3, 338, 169, 0, 1651, 1652, 3, 326, 163, 0, 1652, 1861, 1, 0, 0, + 0, 1653, 1654, 5, 21, 0, 0, 1654, 1655, 5, 539, 0, 0, 1655, 1656, 5, 210, + 0, 0, 1656, 1659, 3, 186, 93, 0, 1657, 1658, 5, 193, 0, 0, 1658, 1660, + 3, 186, 93, 0, 1659, 1657, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 1662, + 1, 0, 0, 0, 1661, 1663, 3, 326, 163, 0, 1662, 1661, 1, 0, 0, 0, 1662, 1663, + 1, 0, 0, 0, 1663, 1861, 1, 0, 0, 0, 1664, 1665, 5, 21, 0, 0, 1665, 1666, + 5, 91, 0, 0, 1666, 1667, 5, 210, 0, 0, 1667, 1669, 3, 186, 93, 0, 1668, + 1670, 3, 326, 163, 0, 1669, 1668, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, + 1861, 1, 0, 0, 0, 1671, 1672, 5, 21, 0, 0, 1672, 1673, 5, 69, 0, 0, 1673, + 1674, 3, 464, 232, 0, 1674, 1675, 5, 439, 0, 0, 1675, 1676, 5, 375, 0, + 0, 1676, 1677, 5, 2, 0, 0, 1677, 1678, 3, 328, 164, 0, 1678, 1679, 5, 3, + 0, 0, 1679, 1861, 1, 0, 0, 0, 1680, 1681, 5, 21, 0, 0, 1681, 1682, 5, 539, + 0, 0, 1682, 1683, 5, 366, 0, 0, 1683, 1685, 3, 186, 93, 0, 1684, 1686, + 3, 326, 163, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1861, + 1, 0, 0, 0, 1687, 1688, 5, 21, 0, 0, 1688, 1689, 5, 452, 0, 0, 1689, 1691, + 3, 464, 232, 0, 1690, 1692, 3, 326, 163, 0, 1691, 1690, 1, 0, 0, 0, 1691, + 1692, 1, 0, 0, 0, 1692, 1861, 1, 0, 0, 0, 1693, 1694, 5, 21, 0, 0, 1694, + 1695, 5, 69, 0, 0, 1695, 1696, 3, 464, 232, 0, 1696, 1697, 5, 311, 0, 0, + 1697, 1698, 5, 85, 0, 0, 1698, 1699, 5, 569, 0, 0, 1699, 1861, 1, 0, 0, + 0, 1700, 1701, 5, 21, 0, 0, 1701, 1702, 5, 115, 0, 0, 1702, 1703, 3, 464, + 232, 0, 1703, 1704, 5, 396, 0, 0, 1704, 1705, 3, 464, 232, 0, 1705, 1861, + 1, 0, 0, 0, 1706, 1707, 5, 21, 0, 0, 1707, 1708, 5, 460, 0, 0, 1708, 1709, + 5, 366, 0, 0, 1709, 1710, 3, 186, 93, 0, 1710, 1711, 3, 326, 163, 0, 1711, + 1861, 1, 0, 0, 0, 1712, 1713, 5, 21, 0, 0, 1713, 1714, 5, 472, 0, 0, 1714, + 1715, 3, 338, 169, 0, 1715, 1720, 3, 92, 46, 0, 1716, 1717, 5, 4, 0, 0, + 1717, 1719, 3, 92, 46, 0, 1718, 1716, 1, 0, 0, 0, 1719, 1722, 1, 0, 0, + 0, 1720, 1718, 1, 0, 0, 0, 1720, 1721, 1, 0, 0, 0, 1721, 1861, 1, 0, 0, + 0, 1722, 1720, 1, 0, 0, 0, 1723, 1724, 5, 21, 0, 0, 1724, 1725, 5, 472, + 0, 0, 1725, 1726, 3, 338, 169, 0, 1726, 1727, 5, 174, 0, 0, 1727, 1728, + 3, 464, 232, 0, 1728, 1730, 5, 2, 0, 0, 1729, 1731, 3, 328, 164, 0, 1730, + 1729, 1, 0, 0, 0, 1730, 1731, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, + 1734, 5, 3, 0, 0, 1733, 1735, 3, 164, 82, 0, 1734, 1733, 1, 0, 0, 0, 1734, + 1735, 1, 0, 0, 0, 1735, 1738, 1, 0, 0, 0, 1736, 1737, 5, 535, 0, 0, 1737, + 1739, 3, 388, 194, 0, 1738, 1736, 1, 0, 0, 0, 1738, 1739, 1, 0, 0, 0, 1739, + 1861, 1, 0, 0, 0, 1740, 1741, 5, 21, 0, 0, 1741, 1742, 5, 472, 0, 0, 1742, + 1743, 3, 338, 169, 0, 1743, 1744, 5, 14, 0, 0, 1744, 1745, 5, 420, 0, 0, + 1745, 1750, 3, 90, 45, 0, 1746, 1747, 5, 4, 0, 0, 1747, 1749, 3, 90, 45, + 0, 1748, 1746, 1, 0, 0, 0, 1749, 1752, 1, 0, 0, 0, 1750, 1748, 1, 0, 0, + 0, 1750, 1751, 1, 0, 0, 0, 1751, 1861, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, + 0, 1753, 1754, 5, 21, 0, 0, 1754, 1755, 5, 472, 0, 0, 1755, 1756, 3, 338, + 169, 0, 1756, 1757, 5, 151, 0, 0, 1757, 1758, 5, 420, 0, 0, 1758, 1763, + 3, 88, 44, 0, 1759, 1760, 5, 4, 0, 0, 1760, 1762, 3, 88, 44, 0, 1761, 1759, + 1, 0, 0, 0, 1762, 1765, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1763, 1764, + 1, 0, 0, 0, 1764, 1861, 1, 0, 0, 0, 1765, 1763, 1, 0, 0, 0, 1766, 1767, + 5, 21, 0, 0, 1767, 1768, 5, 472, 0, 0, 1768, 1769, 3, 338, 169, 0, 1769, + 1770, 5, 439, 0, 0, 1770, 1771, 5, 2, 0, 0, 1771, 1772, 3, 328, 164, 0, + 1772, 1773, 5, 3, 0, 0, 1773, 1861, 1, 0, 0, 0, 1774, 1775, 5, 21, 0, 0, + 1775, 1776, 5, 115, 0, 0, 1776, 1777, 3, 464, 232, 0, 1777, 1778, 5, 439, + 0, 0, 1778, 1779, 7, 12, 0, 0, 1779, 1782, 5, 381, 0, 0, 1780, 1783, 3, + 464, 232, 0, 1781, 1783, 5, 575, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1781, + 1, 0, 0, 0, 1783, 1861, 1, 0, 0, 0, 1784, 1785, 5, 21, 0, 0, 1785, 1786, + 5, 115, 0, 0, 1786, 1787, 3, 464, 232, 0, 1787, 1788, 5, 439, 0, 0, 1788, + 1789, 5, 375, 0, 0, 1789, 1790, 5, 2, 0, 0, 1790, 1791, 3, 328, 164, 0, + 1791, 1792, 5, 3, 0, 0, 1792, 1861, 1, 0, 0, 0, 1793, 1794, 5, 21, 0, 0, + 1794, 1795, 5, 471, 0, 0, 1795, 1796, 5, 396, 0, 0, 1796, 1797, 5, 91, + 0, 0, 1797, 1798, 5, 210, 0, 0, 1798, 1799, 3, 464, 232, 0, 1799, 1800, + 3, 464, 232, 0, 1800, 1861, 1, 0, 0, 0, 1801, 1802, 5, 21, 0, 0, 1802, + 1803, 5, 405, 0, 0, 1803, 1805, 3, 186, 93, 0, 1804, 1806, 3, 326, 163, + 0, 1805, 1804, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1861, 1, 0, 0, + 0, 1807, 1808, 5, 21, 0, 0, 1808, 1809, 5, 404, 0, 0, 1809, 1811, 3, 464, + 232, 0, 1810, 1812, 3, 326, 163, 0, 1811, 1810, 1, 0, 0, 0, 1811, 1812, + 1, 0, 0, 0, 1812, 1861, 1, 0, 0, 0, 1813, 1814, 5, 21, 0, 0, 1814, 1815, + 5, 423, 0, 0, 1815, 1816, 5, 278, 0, 0, 1816, 1817, 5, 193, 0, 0, 1817, + 1826, 3, 338, 169, 0, 1818, 1823, 3, 50, 25, 0, 1819, 1820, 5, 4, 0, 0, + 1820, 1822, 3, 50, 25, 0, 1821, 1819, 1, 0, 0, 0, 1822, 1825, 1, 0, 0, + 0, 1823, 1821, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1827, 1, 0, 0, + 0, 1825, 1823, 1, 0, 0, 0, 1826, 1818, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, + 0, 1827, 1829, 1, 0, 0, 0, 1828, 1830, 3, 326, 163, 0, 1829, 1828, 1, 0, + 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1837, 1, 0, 0, 0, 1831, 1832, 5, 198, + 0, 0, 1832, 1833, 3, 464, 232, 0, 1833, 1834, 5, 2, 0, 0, 1834, 1835, 3, + 328, 164, 0, 1835, 1836, 5, 3, 0, 0, 1836, 1838, 1, 0, 0, 0, 1837, 1831, + 1, 0, 0, 0, 1837, 1838, 1, 0, 0, 0, 1838, 1861, 1, 0, 0, 0, 1839, 1840, + 5, 21, 0, 0, 1840, 1841, 5, 82, 0, 0, 1841, 1842, 5, 210, 0, 0, 1842, 1843, + 3, 338, 169, 0, 1843, 1844, 5, 439, 0, 0, 1844, 1845, 5, 2, 0, 0, 1845, + 1846, 3, 328, 164, 0, 1846, 1847, 5, 3, 0, 0, 1847, 1861, 1, 0, 0, 0, 1848, + 1849, 5, 21, 0, 0, 1849, 1852, 5, 515, 0, 0, 1850, 1851, 5, 228, 0, 0, + 1851, 1853, 5, 175, 0, 0, 1852, 1850, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, + 0, 1853, 1854, 1, 0, 0, 0, 1854, 1855, 3, 196, 98, 0, 1855, 1858, 3, 136, + 68, 0, 1856, 1857, 5, 85, 0, 0, 1857, 1859, 5, 569, 0, 0, 1858, 1856, 1, + 0, 0, 0, 1858, 1859, 1, 0, 0, 0, 1859, 1861, 1, 0, 0, 0, 1860, 1614, 1, + 0, 0, 0, 1860, 1617, 1, 0, 0, 0, 1860, 1636, 1, 0, 0, 0, 1860, 1642, 1, + 0, 0, 0, 1860, 1647, 1, 0, 0, 0, 1860, 1653, 1, 0, 0, 0, 1860, 1664, 1, + 0, 0, 0, 1860, 1671, 1, 0, 0, 0, 1860, 1680, 1, 0, 0, 0, 1860, 1687, 1, + 0, 0, 0, 1860, 1693, 1, 0, 0, 0, 1860, 1700, 1, 0, 0, 0, 1860, 1706, 1, + 0, 0, 0, 1860, 1712, 1, 0, 0, 0, 1860, 1723, 1, 0, 0, 0, 1860, 1740, 1, + 0, 0, 0, 1860, 1753, 1, 0, 0, 0, 1860, 1766, 1, 0, 0, 0, 1860, 1774, 1, + 0, 0, 0, 1860, 1784, 1, 0, 0, 0, 1860, 1793, 1, 0, 0, 0, 1860, 1801, 1, + 0, 0, 0, 1860, 1807, 1, 0, 0, 0, 1860, 1813, 1, 0, 0, 0, 1860, 1839, 1, + 0, 0, 0, 1860, 1848, 1, 0, 0, 0, 1861, 31, 1, 0, 0, 0, 1862, 1863, 5, 151, + 0, 0, 1863, 1864, 5, 69, 0, 0, 1864, 1865, 5, 391, 0, 0, 1865, 1866, 5, + 43, 0, 0, 1866, 1867, 5, 535, 0, 0, 1867, 1868, 5, 569, 0, 0, 1868, 1869, + 5, 543, 0, 0, 1869, 2076, 5, 575, 0, 0, 1870, 1871, 5, 151, 0, 0, 1871, + 1874, 5, 161, 0, 0, 1872, 1873, 5, 228, 0, 0, 1873, 1875, 5, 175, 0, 0, + 1874, 1872, 1, 0, 0, 0, 1874, 1875, 1, 0, 0, 0, 1875, 1876, 1, 0, 0, 0, + 1876, 2076, 3, 338, 169, 0, 1877, 1878, 5, 151, 0, 0, 1878, 1881, 5, 417, + 0, 0, 1879, 1880, 5, 228, 0, 0, 1880, 1882, 5, 175, 0, 0, 1881, 1879, 1, + 0, 0, 0, 1881, 1882, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 2076, 3, + 186, 93, 0, 1884, 1885, 5, 151, 0, 0, 1885, 1888, 5, 452, 0, 0, 1886, 1887, + 5, 228, 0, 0, 1887, 1889, 5, 175, 0, 0, 1888, 1886, 1, 0, 0, 0, 1888, 1889, + 1, 0, 0, 0, 1889, 1890, 1, 0, 0, 0, 1890, 2076, 3, 318, 159, 0, 1891, 1892, + 5, 151, 0, 0, 1892, 1895, 5, 515, 0, 0, 1893, 1894, 5, 228, 0, 0, 1894, + 1896, 5, 175, 0, 0, 1895, 1893, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, + 1897, 1, 0, 0, 0, 1897, 2076, 3, 194, 97, 0, 1898, 1899, 5, 151, 0, 0, + 1899, 1900, 5, 460, 0, 0, 1900, 1903, 5, 366, 0, 0, 1901, 1902, 5, 228, + 0, 0, 1902, 1904, 5, 175, 0, 0, 1903, 1901, 1, 0, 0, 0, 1903, 1904, 1, + 0, 0, 0, 1904, 1905, 1, 0, 0, 0, 1905, 2076, 3, 464, 232, 0, 1906, 1907, + 5, 151, 0, 0, 1907, 1908, 5, 539, 0, 0, 1908, 1911, 5, 210, 0, 0, 1909, + 1910, 5, 228, 0, 0, 1910, 1912, 5, 175, 0, 0, 1911, 1909, 1, 0, 0, 0, 1911, + 1912, 1, 0, 0, 0, 1912, 1913, 1, 0, 0, 0, 1913, 1916, 3, 186, 93, 0, 1914, + 1915, 5, 193, 0, 0, 1915, 1917, 3, 186, 93, 0, 1916, 1914, 1, 0, 0, 0, + 1916, 1917, 1, 0, 0, 0, 1917, 2076, 1, 0, 0, 0, 1918, 1919, 5, 151, 0, + 0, 1919, 1922, 5, 69, 0, 0, 1920, 1921, 5, 228, 0, 0, 1921, 1923, 5, 175, + 0, 0, 1922, 1920, 1, 0, 0, 0, 1922, 1923, 1, 0, 0, 0, 1923, 1924, 1, 0, + 0, 0, 1924, 2076, 3, 464, 232, 0, 1925, 1926, 5, 151, 0, 0, 1926, 1927, + 5, 187, 0, 0, 1927, 1930, 5, 569, 0, 0, 1928, 1929, 7, 6, 0, 0, 1929, 1931, + 3, 464, 232, 0, 1930, 1928, 1, 0, 0, 0, 1930, 1931, 1, 0, 0, 0, 1931, 1932, + 1, 0, 0, 0, 1932, 2076, 3, 326, 163, 0, 1933, 1934, 5, 151, 0, 0, 1934, + 1935, 5, 539, 0, 0, 1935, 1938, 5, 366, 0, 0, 1936, 1937, 5, 228, 0, 0, + 1937, 1939, 5, 175, 0, 0, 1938, 1936, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, + 0, 1939, 1940, 1, 0, 0, 0, 1940, 2076, 3, 186, 93, 0, 1941, 1942, 5, 151, + 0, 0, 1942, 1943, 5, 404, 0, 0, 1943, 2076, 3, 464, 232, 0, 1944, 1946, + 5, 151, 0, 0, 1945, 1947, 5, 481, 0, 0, 1946, 1945, 1, 0, 0, 0, 1946, 1947, + 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 1951, 5, 472, 0, 0, 1949, 1950, + 5, 228, 0, 0, 1950, 1952, 5, 175, 0, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1952, + 1, 0, 0, 0, 1952, 1953, 1, 0, 0, 0, 1953, 1955, 3, 338, 169, 0, 1954, 1956, + 5, 195, 0, 0, 1955, 1954, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 2076, + 1, 0, 0, 0, 1957, 1958, 5, 151, 0, 0, 1958, 1961, 7, 10, 0, 0, 1959, 1960, + 5, 228, 0, 0, 1960, 1962, 5, 175, 0, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1962, + 1, 0, 0, 0, 1962, 1963, 1, 0, 0, 0, 1963, 1965, 3, 338, 169, 0, 1964, 1966, + 5, 195, 0, 0, 1965, 1964, 1, 0, 0, 0, 1965, 1966, 1, 0, 0, 0, 1966, 2076, + 1, 0, 0, 0, 1967, 1969, 5, 151, 0, 0, 1968, 1970, 3, 174, 87, 0, 1969, + 1968, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 1971, 1, 0, 0, 0, 1971, + 1974, 5, 202, 0, 0, 1972, 1973, 5, 228, 0, 0, 1973, 1975, 5, 175, 0, 0, + 1974, 1972, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, + 1976, 1977, 3, 406, 203, 0, 1977, 1979, 5, 2, 0, 0, 1978, 1980, 3, 138, + 69, 0, 1979, 1978, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1981, 1, 0, + 0, 0, 1981, 1982, 5, 3, 0, 0, 1982, 2076, 1, 0, 0, 0, 1983, 1984, 5, 151, + 0, 0, 1984, 1987, 5, 233, 0, 0, 1985, 1986, 5, 228, 0, 0, 1986, 1988, 5, + 175, 0, 0, 1987, 1985, 1, 0, 0, 0, 1987, 1988, 1, 0, 0, 0, 1988, 1989, + 1, 0, 0, 0, 1989, 1990, 3, 464, 232, 0, 1990, 1991, 5, 331, 0, 0, 1991, + 1992, 3, 338, 169, 0, 1992, 2076, 1, 0, 0, 0, 1993, 1994, 5, 151, 0, 0, + 1994, 1997, 5, 405, 0, 0, 1995, 1996, 5, 228, 0, 0, 1996, 1998, 5, 175, + 0, 0, 1997, 1995, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 1999, 1, 0, + 0, 0, 1999, 2076, 3, 186, 93, 0, 2000, 2001, 5, 151, 0, 0, 2001, 2002, + 5, 424, 0, 0, 2002, 2005, 5, 366, 0, 0, 2003, 2004, 5, 228, 0, 0, 2004, + 2006, 5, 175, 0, 0, 2005, 2003, 1, 0, 0, 0, 2005, 2006, 1, 0, 0, 0, 2006, + 2007, 1, 0, 0, 0, 2007, 2008, 3, 464, 232, 0, 2008, 2009, 5, 331, 0, 0, + 2009, 2016, 3, 338, 169, 0, 2010, 2014, 5, 193, 0, 0, 2011, 2015, 3, 194, + 97, 0, 2012, 2013, 5, 417, 0, 0, 2013, 2015, 3, 464, 232, 0, 2014, 2011, + 1, 0, 0, 0, 2014, 2012, 1, 0, 0, 0, 2015, 2017, 1, 0, 0, 0, 2016, 2010, + 1, 0, 0, 0, 2016, 2017, 1, 0, 0, 0, 2017, 2076, 1, 0, 0, 0, 2018, 2019, + 5, 151, 0, 0, 2019, 2022, 5, 140, 0, 0, 2020, 2021, 5, 228, 0, 0, 2021, + 2023, 5, 175, 0, 0, 2022, 2020, 1, 0, 0, 0, 2022, 2023, 1, 0, 0, 0, 2023, + 2024, 1, 0, 0, 0, 2024, 2076, 3, 338, 169, 0, 2025, 2026, 5, 151, 0, 0, + 2026, 2029, 5, 453, 0, 0, 2027, 2028, 5, 228, 0, 0, 2028, 2030, 5, 175, + 0, 0, 2029, 2027, 1, 0, 0, 0, 2029, 2030, 1, 0, 0, 0, 2030, 2031, 1, 0, + 0, 0, 2031, 2076, 3, 464, 232, 0, 2032, 2033, 5, 151, 0, 0, 2033, 2036, + 5, 529, 0, 0, 2034, 2035, 5, 228, 0, 0, 2035, 2037, 5, 175, 0, 0, 2036, + 2034, 1, 0, 0, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, + 2076, 3, 338, 169, 0, 2039, 2040, 5, 151, 0, 0, 2040, 2041, 5, 245, 0, + 0, 2041, 2042, 5, 233, 0, 0, 2042, 2045, 5, 24, 0, 0, 2043, 2044, 5, 228, + 0, 0, 2044, 2046, 5, 175, 0, 0, 2045, 2043, 1, 0, 0, 0, 2045, 2046, 1, + 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2076, 3, 464, 232, 0, 2048, 2049, + 5, 151, 0, 0, 2049, 2050, 5, 245, 0, 0, 2050, 2051, 5, 233, 0, 0, 2051, + 2054, 5, 490, 0, 0, 2052, 2053, 5, 228, 0, 0, 2053, 2055, 5, 175, 0, 0, + 2054, 2052, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2056, 1, 0, 0, 0, + 2056, 2076, 3, 464, 232, 0, 2057, 2058, 5, 151, 0, 0, 2058, 2059, 5, 245, + 0, 0, 2059, 2060, 5, 233, 0, 0, 2060, 2063, 5, 491, 0, 0, 2061, 2062, 5, + 228, 0, 0, 2062, 2064, 5, 175, 0, 0, 2063, 2061, 1, 0, 0, 0, 2063, 2064, + 1, 0, 0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2076, 3, 464, 232, 0, 2066, 2067, + 5, 151, 0, 0, 2067, 2068, 5, 245, 0, 0, 2068, 2069, 5, 233, 0, 0, 2069, + 2072, 5, 74, 0, 0, 2070, 2071, 5, 228, 0, 0, 2071, 2073, 5, 175, 0, 0, + 2072, 2070, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, 0, 2073, 2074, 1, 0, 0, 0, + 2074, 2076, 3, 464, 232, 0, 2075, 1862, 1, 0, 0, 0, 2075, 1870, 1, 0, 0, + 0, 2075, 1877, 1, 0, 0, 0, 2075, 1884, 1, 0, 0, 0, 2075, 1891, 1, 0, 0, + 0, 2075, 1898, 1, 0, 0, 0, 2075, 1906, 1, 0, 0, 0, 2075, 1918, 1, 0, 0, + 0, 2075, 1925, 1, 0, 0, 0, 2075, 1933, 1, 0, 0, 0, 2075, 1941, 1, 0, 0, + 0, 2075, 1944, 1, 0, 0, 0, 2075, 1957, 1, 0, 0, 0, 2075, 1967, 1, 0, 0, + 0, 2075, 1983, 1, 0, 0, 0, 2075, 1993, 1, 0, 0, 0, 2075, 2000, 1, 0, 0, + 0, 2075, 2018, 1, 0, 0, 0, 2075, 2025, 1, 0, 0, 0, 2075, 2032, 1, 0, 0, + 0, 2075, 2039, 1, 0, 0, 0, 2075, 2048, 1, 0, 0, 0, 2075, 2057, 1, 0, 0, + 0, 2075, 2066, 1, 0, 0, 0, 2076, 33, 1, 0, 0, 0, 2077, 2079, 5, 443, 0, + 0, 2078, 2080, 3, 174, 87, 0, 2079, 2078, 1, 0, 0, 0, 2079, 2080, 1, 0, + 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2083, 5, 523, 0, 0, 2082, 2084, 3, + 76, 38, 0, 2083, 2082, 1, 0, 0, 0, 2083, 2084, 1, 0, 0, 0, 2084, 2781, + 1, 0, 0, 0, 2085, 2086, 5, 443, 0, 0, 2086, 2781, 5, 32, 0, 0, 2087, 2088, + 5, 443, 0, 0, 2088, 2089, 5, 21, 0, 0, 2089, 2094, 5, 472, 0, 0, 2090, + 2095, 5, 420, 0, 0, 2091, 2092, 5, 298, 0, 0, 2092, 2095, 5, 529, 0, 0, + 2093, 2095, 5, 83, 0, 0, 2094, 2090, 1, 0, 0, 0, 2094, 2091, 1, 0, 0, 0, + 2094, 2093, 1, 0, 0, 0, 2095, 2098, 1, 0, 0, 0, 2096, 2097, 7, 6, 0, 0, + 2097, 2099, 3, 338, 169, 0, 2098, 2096, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, + 0, 2099, 2101, 1, 0, 0, 0, 2100, 2102, 3, 76, 38, 0, 2101, 2100, 1, 0, + 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2104, 1, 0, 0, 0, 2103, 2105, 3, 304, + 152, 0, 2104, 2103, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2107, 1, + 0, 0, 0, 2106, 2108, 3, 308, 154, 0, 2107, 2106, 1, 0, 0, 0, 2107, 2108, + 1, 0, 0, 0, 2108, 2781, 1, 0, 0, 0, 2109, 2110, 5, 443, 0, 0, 2110, 2111, + 5, 103, 0, 0, 2111, 2112, 7, 10, 0, 0, 2112, 2781, 3, 338, 169, 0, 2113, + 2114, 5, 443, 0, 0, 2114, 2117, 5, 38, 0, 0, 2115, 2116, 7, 6, 0, 0, 2116, + 2118, 3, 464, 232, 0, 2117, 2115, 1, 0, 0, 0, 2117, 2118, 1, 0, 0, 0, 2118, + 2120, 1, 0, 0, 0, 2119, 2121, 3, 76, 38, 0, 2120, 2119, 1, 0, 0, 0, 2120, + 2121, 1, 0, 0, 0, 2121, 2781, 1, 0, 0, 0, 2122, 2123, 5, 443, 0, 0, 2123, + 2781, 5, 57, 0, 0, 2124, 2125, 5, 443, 0, 0, 2125, 2126, 5, 59, 0, 0, 2126, + 2129, 5, 233, 0, 0, 2127, 2128, 7, 6, 0, 0, 2128, 2130, 3, 464, 232, 0, + 2129, 2127, 1, 0, 0, 0, 2129, 2130, 1, 0, 0, 0, 2130, 2132, 1, 0, 0, 0, + 2131, 2133, 3, 76, 38, 0, 2132, 2131, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, + 0, 2133, 2135, 1, 0, 0, 0, 2134, 2136, 3, 304, 152, 0, 2135, 2134, 1, 0, + 0, 0, 2135, 2136, 1, 0, 0, 0, 2136, 2138, 1, 0, 0, 0, 2137, 2139, 3, 308, + 154, 0, 2138, 2137, 1, 0, 0, 0, 2138, 2139, 1, 0, 0, 0, 2139, 2781, 1, + 0, 0, 0, 2140, 2141, 5, 443, 0, 0, 2141, 2142, 5, 156, 0, 0, 2142, 2143, + 5, 345, 0, 0, 2143, 2146, 5, 473, 0, 0, 2144, 2145, 7, 6, 0, 0, 2145, 2147, + 3, 338, 169, 0, 2146, 2144, 1, 0, 0, 0, 2146, 2147, 1, 0, 0, 0, 2147, 2781, + 1, 0, 0, 0, 2148, 2149, 5, 443, 0, 0, 2149, 2152, 5, 170, 0, 0, 2150, 2151, + 7, 6, 0, 0, 2151, 2153, 3, 338, 169, 0, 2152, 2150, 1, 0, 0, 0, 2152, 2153, + 1, 0, 0, 0, 2153, 2155, 1, 0, 0, 0, 2154, 2156, 3, 76, 38, 0, 2155, 2154, + 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2781, 1, 0, 0, 0, 2157, 2158, + 5, 443, 0, 0, 2158, 2161, 5, 178, 0, 0, 2159, 2160, 7, 6, 0, 0, 2160, 2162, + 3, 338, 169, 0, 2161, 2159, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2164, + 1, 0, 0, 0, 2163, 2165, 3, 76, 38, 0, 2164, 2163, 1, 0, 0, 0, 2164, 2165, + 1, 0, 0, 0, 2165, 2167, 1, 0, 0, 0, 2166, 2168, 3, 304, 152, 0, 2167, 2166, + 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2170, 1, 0, 0, 0, 2169, 2171, + 3, 308, 154, 0, 2170, 2169, 1, 0, 0, 0, 2170, 2171, 1, 0, 0, 0, 2171, 2781, + 1, 0, 0, 0, 2172, 2173, 5, 443, 0, 0, 2173, 2174, 5, 265, 0, 0, 2174, 2781, + 5, 237, 0, 0, 2175, 2179, 5, 443, 0, 0, 2176, 2177, 5, 72, 0, 0, 2177, + 2180, 5, 439, 0, 0, 2178, 2180, 5, 73, 0, 0, 2179, 2176, 1, 0, 0, 0, 2179, + 2178, 1, 0, 0, 0, 2180, 2781, 1, 0, 0, 0, 2181, 2182, 5, 443, 0, 0, 2182, + 2185, 5, 133, 0, 0, 2183, 2184, 7, 6, 0, 0, 2184, 2186, 3, 338, 169, 0, + 2185, 2183, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2781, 1, 0, 0, 0, + 2187, 2188, 5, 443, 0, 0, 2188, 2190, 5, 103, 0, 0, 2189, 2191, 3, 174, + 87, 0, 2190, 2189, 1, 0, 0, 0, 2190, 2191, 1, 0, 0, 0, 2191, 2192, 1, 0, + 0, 0, 2192, 2193, 5, 202, 0, 0, 2193, 2194, 3, 406, 203, 0, 2194, 2196, + 5, 2, 0, 0, 2195, 2197, 3, 138, 69, 0, 2196, 2195, 1, 0, 0, 0, 2196, 2197, + 1, 0, 0, 0, 2197, 2198, 1, 0, 0, 0, 2198, 2201, 5, 3, 0, 0, 2199, 2200, + 7, 6, 0, 0, 2200, 2202, 3, 338, 169, 0, 2201, 2199, 1, 0, 0, 0, 2201, 2202, + 1, 0, 0, 0, 2202, 2781, 1, 0, 0, 0, 2203, 2205, 5, 443, 0, 0, 2204, 2206, + 5, 201, 0, 0, 2205, 2204, 1, 0, 0, 0, 2205, 2206, 1, 0, 0, 0, 2206, 2208, + 1, 0, 0, 0, 2207, 2209, 5, 60, 0, 0, 2208, 2207, 1, 0, 0, 0, 2208, 2209, + 1, 0, 0, 0, 2209, 2210, 1, 0, 0, 0, 2210, 2213, 5, 203, 0, 0, 2211, 2212, + 7, 6, 0, 0, 2212, 2214, 3, 338, 169, 0, 2213, 2211, 1, 0, 0, 0, 2213, 2214, + 1, 0, 0, 0, 2214, 2217, 1, 0, 0, 0, 2215, 2216, 5, 273, 0, 0, 2216, 2218, + 5, 569, 0, 0, 2217, 2215, 1, 0, 0, 0, 2217, 2218, 1, 0, 0, 0, 2218, 2781, + 1, 0, 0, 0, 2219, 2220, 5, 443, 0, 0, 2220, 2222, 5, 206, 0, 0, 2221, 2223, + 5, 201, 0, 0, 2222, 2221, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2224, + 1, 0, 0, 0, 2224, 2227, 5, 203, 0, 0, 2225, 2226, 5, 273, 0, 0, 2226, 2228, + 5, 569, 0, 0, 2227, 2225, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2781, + 1, 0, 0, 0, 2229, 2231, 5, 443, 0, 0, 2230, 2232, 5, 20, 0, 0, 2231, 2230, + 1, 0, 0, 0, 2231, 2232, 1, 0, 0, 0, 2232, 2233, 1, 0, 0, 0, 2233, 2781, + 5, 208, 0, 0, 2234, 2235, 5, 443, 0, 0, 2235, 2236, 5, 208, 0, 0, 2236, + 2237, 5, 193, 0, 0, 2237, 2781, 3, 194, 97, 0, 2238, 2239, 5, 443, 0, 0, + 2239, 2240, 5, 103, 0, 0, 2240, 2241, 5, 515, 0, 0, 2241, 2781, 3, 194, + 97, 0, 2242, 2243, 5, 443, 0, 0, 2243, 2244, 5, 447, 0, 0, 2244, 2245, + 5, 331, 0, 0, 2245, 2247, 3, 464, 232, 0, 2246, 2248, 3, 76, 38, 0, 2247, + 2246, 1, 0, 0, 0, 2247, 2248, 1, 0, 0, 0, 2248, 2781, 1, 0, 0, 0, 2249, + 2250, 5, 443, 0, 0, 2250, 2251, 5, 278, 0, 0, 2251, 2253, 5, 374, 0, 0, + 2252, 2254, 5, 569, 0, 0, 2253, 2252, 1, 0, 0, 0, 2253, 2254, 1, 0, 0, + 0, 2254, 2256, 1, 0, 0, 0, 2255, 2257, 3, 308, 154, 0, 2256, 2255, 1, 0, + 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 2781, 1, 0, 0, 0, 2258, 2259, 5, 443, + 0, 0, 2259, 2260, 5, 103, 0, 0, 2260, 2261, 5, 404, 0, 0, 2261, 2262, 5, + 193, 0, 0, 2262, 2781, 3, 464, 232, 0, 2263, 2264, 5, 443, 0, 0, 2264, + 2265, 5, 529, 0, 0, 2265, 2266, 7, 6, 0, 0, 2266, 2269, 3, 338, 169, 0, + 2267, 2268, 7, 6, 0, 0, 2268, 2270, 3, 464, 232, 0, 2269, 2267, 1, 0, 0, + 0, 2269, 2270, 1, 0, 0, 0, 2270, 2781, 1, 0, 0, 0, 2271, 2272, 5, 443, + 0, 0, 2272, 2781, 5, 365, 0, 0, 2273, 2274, 5, 443, 0, 0, 2274, 2275, 5, + 460, 0, 0, 2275, 2781, 7, 13, 0, 0, 2276, 2277, 5, 443, 0, 0, 2277, 2781, + 5, 403, 0, 0, 2278, 2279, 5, 443, 0, 0, 2279, 2282, 5, 162, 0, 0, 2280, + 2281, 7, 6, 0, 0, 2281, 2283, 3, 338, 169, 0, 2282, 2280, 1, 0, 0, 0, 2282, + 2283, 1, 0, 0, 0, 2283, 2286, 1, 0, 0, 0, 2284, 2285, 5, 273, 0, 0, 2285, + 2287, 5, 569, 0, 0, 2286, 2284, 1, 0, 0, 0, 2286, 2287, 1, 0, 0, 0, 2287, + 2781, 1, 0, 0, 0, 2288, 2290, 5, 443, 0, 0, 2289, 2291, 5, 56, 0, 0, 2290, + 2289, 1, 0, 0, 0, 2290, 2291, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, + 2293, 5, 103, 0, 0, 2293, 2294, 5, 472, 0, 0, 2294, 2781, 3, 338, 169, + 0, 2295, 2297, 5, 443, 0, 0, 2296, 2298, 5, 201, 0, 0, 2297, 2296, 1, 0, + 0, 0, 2297, 2298, 1, 0, 0, 0, 2298, 2299, 1, 0, 0, 0, 2299, 2781, 5, 373, + 0, 0, 2300, 2302, 5, 443, 0, 0, 2301, 2303, 5, 481, 0, 0, 2302, 2301, 1, + 0, 0, 0, 2302, 2303, 1, 0, 0, 0, 2303, 2304, 1, 0, 0, 0, 2304, 2305, 5, + 346, 0, 0, 2305, 2306, 5, 198, 0, 0, 2306, 2308, 3, 338, 169, 0, 2307, + 2309, 3, 76, 38, 0, 2308, 2307, 1, 0, 0, 0, 2308, 2309, 1, 0, 0, 0, 2309, + 2311, 1, 0, 0, 0, 2310, 2312, 3, 304, 152, 0, 2311, 2310, 1, 0, 0, 0, 2311, + 2312, 1, 0, 0, 0, 2312, 2314, 1, 0, 0, 0, 2313, 2315, 3, 308, 154, 0, 2314, + 2313, 1, 0, 0, 0, 2314, 2315, 1, 0, 0, 0, 2315, 2781, 1, 0, 0, 0, 2316, + 2318, 5, 443, 0, 0, 2317, 2319, 5, 56, 0, 0, 2318, 2317, 1, 0, 0, 0, 2318, + 2319, 1, 0, 0, 0, 2319, 2320, 1, 0, 0, 0, 2320, 2323, 5, 407, 0, 0, 2321, + 2322, 7, 6, 0, 0, 2322, 2324, 3, 464, 232, 0, 2323, 2321, 1, 0, 0, 0, 2323, + 2324, 1, 0, 0, 0, 2324, 2326, 1, 0, 0, 0, 2325, 2327, 3, 76, 38, 0, 2326, + 2325, 1, 0, 0, 0, 2326, 2327, 1, 0, 0, 0, 2327, 2781, 1, 0, 0, 0, 2328, + 2329, 5, 443, 0, 0, 2329, 2781, 5, 418, 0, 0, 2330, 2331, 5, 443, 0, 0, + 2331, 2332, 5, 345, 0, 0, 2332, 2781, 5, 575, 0, 0, 2333, 2334, 5, 443, + 0, 0, 2334, 2781, 5, 362, 0, 0, 2335, 2336, 5, 443, 0, 0, 2336, 2337, 5, + 371, 0, 0, 2337, 2781, 5, 569, 0, 0, 2338, 2339, 5, 443, 0, 0, 2339, 2342, + 5, 187, 0, 0, 2340, 2341, 7, 6, 0, 0, 2341, 2343, 3, 338, 169, 0, 2342, + 2340, 1, 0, 0, 0, 2342, 2343, 1, 0, 0, 0, 2343, 2781, 1, 0, 0, 0, 2344, + 2346, 5, 443, 0, 0, 2345, 2347, 5, 460, 0, 0, 2346, 2345, 1, 0, 0, 0, 2346, + 2347, 1, 0, 0, 0, 2347, 2348, 1, 0, 0, 0, 2348, 2781, 5, 166, 0, 0, 2349, + 2350, 5, 443, 0, 0, 2350, 2351, 5, 103, 0, 0, 2351, 2352, 5, 69, 0, 0, + 2352, 2781, 3, 464, 232, 0, 2353, 2354, 5, 443, 0, 0, 2354, 2355, 5, 69, + 0, 0, 2355, 2781, 3, 464, 232, 0, 2356, 2357, 5, 443, 0, 0, 2357, 2359, + 5, 70, 0, 0, 2358, 2360, 3, 76, 38, 0, 2359, 2358, 1, 0, 0, 0, 2359, 2360, + 1, 0, 0, 0, 2360, 2781, 1, 0, 0, 0, 2361, 2362, 5, 443, 0, 0, 2362, 2365, + 5, 376, 0, 0, 2363, 2364, 5, 193, 0, 0, 2364, 2366, 3, 186, 93, 0, 2365, + 2363, 1, 0, 0, 0, 2365, 2366, 1, 0, 0, 0, 2366, 2369, 1, 0, 0, 0, 2367, + 2368, 5, 273, 0, 0, 2368, 2370, 5, 569, 0, 0, 2369, 2367, 1, 0, 0, 0, 2369, + 2370, 1, 0, 0, 0, 2370, 2781, 1, 0, 0, 0, 2371, 2372, 5, 443, 0, 0, 2372, + 2373, 5, 20, 0, 0, 2373, 2376, 5, 375, 0, 0, 2374, 2375, 5, 273, 0, 0, + 2375, 2377, 5, 569, 0, 0, 2376, 2374, 1, 0, 0, 0, 2376, 2377, 1, 0, 0, + 0, 2377, 2781, 1, 0, 0, 0, 2378, 2379, 5, 443, 0, 0, 2379, 2381, 5, 80, + 0, 0, 2380, 2382, 3, 76, 38, 0, 2381, 2380, 1, 0, 0, 0, 2381, 2382, 1, + 0, 0, 0, 2382, 2781, 1, 0, 0, 0, 2383, 2384, 5, 443, 0, 0, 2384, 2385, + 5, 424, 0, 0, 2385, 2392, 5, 366, 0, 0, 2386, 2390, 5, 193, 0, 0, 2387, + 2391, 3, 194, 97, 0, 2388, 2389, 5, 417, 0, 0, 2389, 2391, 3, 464, 232, + 0, 2390, 2387, 1, 0, 0, 0, 2390, 2388, 1, 0, 0, 0, 2391, 2393, 1, 0, 0, + 0, 2392, 2386, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2781, 1, 0, 0, + 0, 2394, 2395, 5, 443, 0, 0, 2395, 2396, 5, 460, 0, 0, 2396, 2402, 5, 366, + 0, 0, 2397, 2400, 5, 517, 0, 0, 2398, 2399, 5, 193, 0, 0, 2399, 2401, 3, + 186, 93, 0, 2400, 2398, 1, 0, 0, 0, 2400, 2401, 1, 0, 0, 0, 2401, 2403, + 1, 0, 0, 0, 2402, 2397, 1, 0, 0, 0, 2402, 2403, 1, 0, 0, 0, 2403, 2781, + 1, 0, 0, 0, 2404, 2405, 5, 443, 0, 0, 2405, 2408, 5, 452, 0, 0, 2406, 2407, + 5, 193, 0, 0, 2407, 2409, 3, 464, 232, 0, 2408, 2406, 1, 0, 0, 0, 2408, + 2409, 1, 0, 0, 0, 2409, 2781, 1, 0, 0, 0, 2410, 2411, 5, 443, 0, 0, 2411, + 2412, 5, 103, 0, 0, 2412, 2413, 5, 529, 0, 0, 2413, 2781, 3, 338, 169, + 0, 2414, 2415, 5, 443, 0, 0, 2415, 2416, 5, 103, 0, 0, 2416, 2417, 5, 460, + 0, 0, 2417, 2418, 5, 525, 0, 0, 2418, 2781, 3, 464, 232, 0, 2419, 2420, + 5, 443, 0, 0, 2420, 2421, 5, 114, 0, 0, 2421, 2781, 5, 503, 0, 0, 2422, + 2423, 5, 443, 0, 0, 2423, 2425, 5, 114, 0, 0, 2424, 2426, 5, 20, 0, 0, + 2425, 2424, 1, 0, 0, 0, 2425, 2426, 1, 0, 0, 0, 2426, 2429, 1, 0, 0, 0, + 2427, 2428, 5, 198, 0, 0, 2428, 2430, 3, 338, 169, 0, 2429, 2427, 1, 0, + 0, 0, 2429, 2430, 1, 0, 0, 0, 2430, 2432, 1, 0, 0, 0, 2431, 2433, 3, 304, + 152, 0, 2432, 2431, 1, 0, 0, 0, 2432, 2433, 1, 0, 0, 0, 2433, 2435, 1, + 0, 0, 0, 2434, 2436, 3, 326, 163, 0, 2435, 2434, 1, 0, 0, 0, 2435, 2436, + 1, 0, 0, 0, 2436, 2781, 1, 0, 0, 0, 2437, 2438, 5, 443, 0, 0, 2438, 2439, + 5, 103, 0, 0, 2439, 2440, 5, 298, 0, 0, 2440, 2441, 5, 529, 0, 0, 2441, + 2442, 3, 464, 232, 0, 2442, 2443, 5, 331, 0, 0, 2443, 2444, 3, 338, 169, + 0, 2444, 2781, 1, 0, 0, 0, 2445, 2446, 5, 443, 0, 0, 2446, 2448, 7, 14, + 0, 0, 2447, 2449, 3, 308, 154, 0, 2448, 2447, 1, 0, 0, 0, 2448, 2449, 1, + 0, 0, 0, 2449, 2781, 1, 0, 0, 0, 2450, 2451, 5, 443, 0, 0, 2451, 2452, + 5, 102, 0, 0, 2452, 2453, 5, 2, 0, 0, 2453, 2454, 5, 552, 0, 0, 2454, 2455, + 5, 3, 0, 0, 2455, 2781, 7, 14, 0, 0, 2456, 2457, 5, 443, 0, 0, 2457, 2781, + 5, 37, 0, 0, 2458, 2459, 5, 443, 0, 0, 2459, 2781, 5, 454, 0, 0, 2460, + 2461, 5, 443, 0, 0, 2461, 2462, 5, 402, 0, 0, 2462, 2463, 5, 146, 0, 0, + 2463, 2464, 5, 198, 0, 0, 2464, 2781, 3, 74, 37, 0, 2465, 2466, 5, 443, + 0, 0, 2466, 2468, 5, 406, 0, 0, 2467, 2469, 3, 76, 38, 0, 2468, 2467, 1, + 0, 0, 0, 2468, 2469, 1, 0, 0, 0, 2469, 2471, 1, 0, 0, 0, 2470, 2472, 3, + 304, 152, 0, 2471, 2470, 1, 0, 0, 0, 2471, 2472, 1, 0, 0, 0, 2472, 2474, + 1, 0, 0, 0, 2473, 2475, 3, 308, 154, 0, 2474, 2473, 1, 0, 0, 0, 2474, 2475, + 1, 0, 0, 0, 2475, 2781, 1, 0, 0, 0, 2476, 2478, 5, 443, 0, 0, 2477, 2479, + 5, 461, 0, 0, 2478, 2477, 1, 0, 0, 0, 2478, 2479, 1, 0, 0, 0, 2479, 2480, + 1, 0, 0, 0, 2480, 2483, 5, 278, 0, 0, 2481, 2482, 7, 6, 0, 0, 2482, 2484, + 3, 464, 232, 0, 2483, 2481, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2486, + 1, 0, 0, 0, 2485, 2487, 3, 76, 38, 0, 2486, 2485, 1, 0, 0, 0, 2486, 2487, + 1, 0, 0, 0, 2487, 2489, 1, 0, 0, 0, 2488, 2490, 3, 304, 152, 0, 2489, 2488, + 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2492, 1, 0, 0, 0, 2491, 2493, + 3, 308, 154, 0, 2492, 2491, 1, 0, 0, 0, 2492, 2493, 1, 0, 0, 0, 2493, 2781, + 1, 0, 0, 0, 2494, 2495, 5, 443, 0, 0, 2495, 2496, 5, 278, 0, 0, 2496, 2509, + 5, 532, 0, 0, 2497, 2498, 7, 6, 0, 0, 2498, 2500, 3, 464, 232, 0, 2499, + 2497, 1, 0, 0, 0, 2499, 2500, 1, 0, 0, 0, 2500, 2502, 1, 0, 0, 0, 2501, + 2503, 3, 76, 38, 0, 2502, 2501, 1, 0, 0, 0, 2502, 2503, 1, 0, 0, 0, 2503, + 2505, 1, 0, 0, 0, 2504, 2506, 3, 308, 154, 0, 2505, 2504, 1, 0, 0, 0, 2505, + 2506, 1, 0, 0, 0, 2506, 2510, 1, 0, 0, 0, 2507, 2508, 5, 331, 0, 0, 2508, + 2510, 5, 569, 0, 0, 2509, 2499, 1, 0, 0, 0, 2509, 2507, 1, 0, 0, 0, 2510, + 2781, 1, 0, 0, 0, 2511, 2513, 5, 443, 0, 0, 2512, 2514, 5, 201, 0, 0, 2513, + 2512, 1, 0, 0, 0, 2513, 2514, 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, + 2518, 5, 496, 0, 0, 2516, 2517, 7, 6, 0, 0, 2517, 2519, 3, 338, 169, 0, + 2518, 2516, 1, 0, 0, 0, 2518, 2519, 1, 0, 0, 0, 2519, 2521, 1, 0, 0, 0, + 2520, 2522, 3, 76, 38, 0, 2521, 2520, 1, 0, 0, 0, 2521, 2522, 1, 0, 0, + 0, 2522, 2781, 1, 0, 0, 0, 2523, 2524, 5, 443, 0, 0, 2524, 2525, 5, 475, + 0, 0, 2525, 2526, 5, 138, 0, 0, 2526, 2781, 5, 575, 0, 0, 2527, 2528, 5, + 443, 0, 0, 2528, 2529, 5, 334, 0, 0, 2529, 2532, 5, 473, 0, 0, 2530, 2531, + 7, 6, 0, 0, 2531, 2533, 3, 338, 169, 0, 2532, 2530, 1, 0, 0, 0, 2532, 2533, + 1, 0, 0, 0, 2533, 2535, 1, 0, 0, 0, 2534, 2536, 3, 76, 38, 0, 2535, 2534, + 1, 0, 0, 0, 2535, 2536, 1, 0, 0, 0, 2536, 2781, 1, 0, 0, 0, 2537, 2538, + 5, 443, 0, 0, 2538, 2540, 5, 200, 0, 0, 2539, 2541, 3, 464, 232, 0, 2540, + 2539, 1, 0, 0, 0, 2540, 2541, 1, 0, 0, 0, 2541, 2781, 1, 0, 0, 0, 2542, + 2543, 5, 443, 0, 0, 2543, 2544, 5, 115, 0, 0, 2544, 2781, 5, 575, 0, 0, + 2545, 2547, 5, 443, 0, 0, 2546, 2548, 5, 201, 0, 0, 2547, 2546, 1, 0, 0, + 0, 2547, 2548, 1, 0, 0, 0, 2548, 2549, 1, 0, 0, 0, 2549, 2550, 7, 15, 0, + 0, 2550, 2551, 7, 6, 0, 0, 2551, 2554, 3, 338, 169, 0, 2552, 2553, 7, 6, + 0, 0, 2553, 2555, 3, 338, 169, 0, 2554, 2552, 1, 0, 0, 0, 2554, 2555, 1, + 0, 0, 0, 2555, 2557, 1, 0, 0, 0, 2556, 2558, 3, 76, 38, 0, 2557, 2556, + 1, 0, 0, 0, 2557, 2558, 1, 0, 0, 0, 2558, 2781, 1, 0, 0, 0, 2559, 2560, + 5, 443, 0, 0, 2560, 2561, 5, 472, 0, 0, 2561, 2781, 5, 575, 0, 0, 2562, + 2563, 5, 443, 0, 0, 2563, 2566, 5, 494, 0, 0, 2564, 2565, 5, 331, 0, 0, + 2565, 2567, 5, 569, 0, 0, 2566, 2564, 1, 0, 0, 0, 2566, 2567, 1, 0, 0, + 0, 2567, 2781, 1, 0, 0, 0, 2568, 2569, 5, 443, 0, 0, 2569, 2572, 5, 502, + 0, 0, 2570, 2571, 7, 6, 0, 0, 2571, 2573, 3, 464, 232, 0, 2572, 2570, 1, + 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2781, 1, 0, 0, 0, 2574, 2578, 5, + 443, 0, 0, 2575, 2579, 5, 78, 0, 0, 2576, 2577, 5, 91, 0, 0, 2577, 2579, + 5, 212, 0, 0, 2578, 2575, 1, 0, 0, 0, 2578, 2576, 1, 0, 0, 0, 2579, 2781, + 1, 0, 0, 0, 2580, 2582, 5, 443, 0, 0, 2581, 2583, 3, 174, 87, 0, 2582, + 2581, 1, 0, 0, 0, 2582, 2583, 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, + 2781, 5, 458, 0, 0, 2585, 2586, 5, 443, 0, 0, 2586, 2781, 5, 536, 0, 0, + 2587, 2588, 5, 443, 0, 0, 2588, 2589, 5, 476, 0, 0, 2589, 2590, 5, 40, + 0, 0, 2590, 2595, 5, 575, 0, 0, 2591, 2592, 5, 4, 0, 0, 2592, 2594, 5, + 575, 0, 0, 2593, 2591, 1, 0, 0, 0, 2594, 2597, 1, 0, 0, 0, 2595, 2593, + 1, 0, 0, 0, 2595, 2596, 1, 0, 0, 0, 2596, 2781, 1, 0, 0, 0, 2597, 2595, + 1, 0, 0, 0, 2598, 2599, 5, 443, 0, 0, 2599, 2600, 5, 114, 0, 0, 2600, 2601, + 5, 445, 0, 0, 2601, 2602, 5, 198, 0, 0, 2602, 2781, 3, 74, 37, 0, 2603, + 2604, 5, 443, 0, 0, 2604, 2605, 5, 472, 0, 0, 2605, 2608, 5, 104, 0, 0, + 2606, 2607, 7, 6, 0, 0, 2607, 2609, 3, 338, 169, 0, 2608, 2606, 1, 0, 0, + 0, 2608, 2609, 1, 0, 0, 0, 2609, 2612, 1, 0, 0, 0, 2610, 2611, 5, 273, + 0, 0, 2611, 2613, 5, 569, 0, 0, 2612, 2610, 1, 0, 0, 0, 2612, 2613, 1, + 0, 0, 0, 2613, 2781, 1, 0, 0, 0, 2614, 2615, 5, 443, 0, 0, 2615, 2616, + 5, 475, 0, 0, 2616, 2617, 5, 460, 0, 0, 2617, 2619, 5, 196, 0, 0, 2618, + 2620, 5, 527, 0, 0, 2619, 2618, 1, 0, 0, 0, 2619, 2620, 1, 0, 0, 0, 2620, + 2781, 1, 0, 0, 0, 2621, 2622, 5, 443, 0, 0, 2622, 2623, 5, 379, 0, 0, 2623, + 2625, 5, 374, 0, 0, 2624, 2626, 5, 569, 0, 0, 2625, 2624, 1, 0, 0, 0, 2625, + 2626, 1, 0, 0, 0, 2626, 2628, 1, 0, 0, 0, 2627, 2629, 3, 308, 154, 0, 2628, + 2627, 1, 0, 0, 0, 2628, 2629, 1, 0, 0, 0, 2629, 2781, 1, 0, 0, 0, 2630, + 2631, 5, 443, 0, 0, 2631, 2634, 5, 100, 0, 0, 2632, 2633, 7, 6, 0, 0, 2633, + 2635, 3, 338, 169, 0, 2634, 2632, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, + 2781, 1, 0, 0, 0, 2636, 2638, 5, 443, 0, 0, 2637, 2639, 5, 201, 0, 0, 2638, + 2637, 1, 0, 0, 0, 2638, 2639, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, + 2643, 5, 473, 0, 0, 2641, 2642, 7, 6, 0, 0, 2642, 2644, 3, 338, 169, 0, + 2643, 2641, 1, 0, 0, 0, 2643, 2644, 1, 0, 0, 0, 2644, 2646, 1, 0, 0, 0, + 2645, 2647, 3, 76, 38, 0, 2646, 2645, 1, 0, 0, 0, 2646, 2647, 1, 0, 0, + 0, 2647, 2781, 1, 0, 0, 0, 2648, 2650, 5, 443, 0, 0, 2649, 2651, 5, 201, + 0, 0, 2650, 2649, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2652, 1, 0, + 0, 0, 2652, 2655, 5, 530, 0, 0, 2653, 2654, 7, 6, 0, 0, 2654, 2656, 3, + 338, 169, 0, 2655, 2653, 1, 0, 0, 0, 2655, 2656, 1, 0, 0, 0, 2656, 2658, + 1, 0, 0, 0, 2657, 2659, 3, 76, 38, 0, 2658, 2657, 1, 0, 0, 0, 2658, 2659, + 1, 0, 0, 0, 2659, 2781, 1, 0, 0, 0, 2660, 2661, 5, 443, 0, 0, 2661, 2662, + 5, 472, 0, 0, 2662, 2665, 5, 458, 0, 0, 2663, 2664, 7, 6, 0, 0, 2664, 2666, + 3, 338, 169, 0, 2665, 2663, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2668, + 1, 0, 0, 0, 2667, 2669, 3, 76, 38, 0, 2668, 2667, 1, 0, 0, 0, 2668, 2669, + 1, 0, 0, 0, 2669, 2781, 1, 0, 0, 0, 2670, 2671, 5, 443, 0, 0, 2671, 2674, + 7, 16, 0, 0, 2672, 2673, 5, 198, 0, 0, 2673, 2675, 3, 464, 232, 0, 2674, + 2672, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 2677, 1, 0, 0, 0, 2676, + 2678, 3, 76, 38, 0, 2677, 2676, 1, 0, 0, 0, 2677, 2678, 1, 0, 0, 0, 2678, + 2781, 1, 0, 0, 0, 2679, 2680, 5, 443, 0, 0, 2680, 2681, 5, 476, 0, 0, 2681, + 2682, 5, 198, 0, 0, 2682, 2684, 3, 338, 169, 0, 2683, 2685, 3, 164, 82, + 0, 2684, 2683, 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 2687, 1, 0, 0, + 0, 2686, 2688, 3, 76, 38, 0, 2687, 2686, 1, 0, 0, 0, 2687, 2688, 1, 0, + 0, 0, 2688, 2690, 1, 0, 0, 0, 2689, 2691, 3, 304, 152, 0, 2690, 2689, 1, + 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691, 2693, 1, 0, 0, 0, 2692, 2694, 3, + 308, 154, 0, 2693, 2692, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 2781, + 1, 0, 0, 0, 2695, 2696, 5, 443, 0, 0, 2696, 2697, 5, 69, 0, 0, 2697, 2698, + 5, 391, 0, 0, 2698, 2701, 5, 43, 0, 0, 2699, 2700, 5, 535, 0, 0, 2700, + 2702, 3, 382, 191, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, + 2781, 1, 0, 0, 0, 2703, 2704, 5, 443, 0, 0, 2704, 2705, 5, 475, 0, 0, 2705, + 2781, 5, 575, 0, 0, 2706, 2707, 5, 443, 0, 0, 2707, 2709, 5, 139, 0, 0, + 2708, 2710, 3, 76, 38, 0, 2709, 2708, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, + 0, 2710, 2781, 1, 0, 0, 0, 2711, 2712, 5, 443, 0, 0, 2712, 2715, 5, 493, + 0, 0, 2713, 2714, 7, 6, 0, 0, 2714, 2716, 3, 338, 169, 0, 2715, 2713, 1, + 0, 0, 0, 2715, 2716, 1, 0, 0, 0, 2716, 2718, 1, 0, 0, 0, 2717, 2719, 3, + 76, 38, 0, 2718, 2717, 1, 0, 0, 0, 2718, 2719, 1, 0, 0, 0, 2719, 2781, + 1, 0, 0, 0, 2720, 2721, 5, 443, 0, 0, 2721, 2722, 5, 402, 0, 0, 2722, 2723, + 5, 458, 0, 0, 2723, 2724, 5, 198, 0, 0, 2724, 2726, 3, 74, 37, 0, 2725, + 2727, 3, 252, 126, 0, 2726, 2725, 1, 0, 0, 0, 2726, 2727, 1, 0, 0, 0, 2727, + 2781, 1, 0, 0, 0, 2728, 2729, 5, 443, 0, 0, 2729, 2730, 5, 539, 0, 0, 2730, + 2733, 5, 212, 0, 0, 2731, 2732, 5, 273, 0, 0, 2732, 2734, 5, 569, 0, 0, + 2733, 2731, 1, 0, 0, 0, 2733, 2734, 1, 0, 0, 0, 2734, 2781, 1, 0, 0, 0, + 2735, 2736, 5, 443, 0, 0, 2736, 2739, 5, 101, 0, 0, 2737, 2738, 7, 6, 0, + 0, 2738, 2740, 3, 464, 232, 0, 2739, 2737, 1, 0, 0, 0, 2739, 2740, 1, 0, + 0, 0, 2740, 2742, 1, 0, 0, 0, 2741, 2743, 3, 252, 126, 0, 2742, 2741, 1, + 0, 0, 0, 2742, 2743, 1, 0, 0, 0, 2743, 2745, 1, 0, 0, 0, 2744, 2746, 3, + 304, 152, 0, 2745, 2744, 1, 0, 0, 0, 2745, 2746, 1, 0, 0, 0, 2746, 2748, + 1, 0, 0, 0, 2747, 2749, 3, 308, 154, 0, 2748, 2747, 1, 0, 0, 0, 2748, 2749, + 1, 0, 0, 0, 2749, 2781, 1, 0, 0, 0, 2750, 2751, 5, 443, 0, 0, 2751, 2752, + 5, 379, 0, 0, 2752, 2763, 5, 457, 0, 0, 2753, 2754, 5, 193, 0, 0, 2754, + 2764, 3, 464, 232, 0, 2755, 2756, 5, 198, 0, 0, 2756, 2761, 3, 338, 169, + 0, 2757, 2759, 5, 20, 0, 0, 2758, 2760, 5, 527, 0, 0, 2759, 2758, 1, 0, + 0, 0, 2759, 2760, 1, 0, 0, 0, 2760, 2762, 1, 0, 0, 0, 2761, 2757, 1, 0, + 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2764, 1, 0, 0, 0, 2763, 2753, 1, 0, + 0, 0, 2763, 2755, 1, 0, 0, 0, 2763, 2764, 1, 0, 0, 0, 2764, 2781, 1, 0, + 0, 0, 2765, 2766, 5, 443, 0, 0, 2766, 2767, 7, 17, 0, 0, 2767, 2768, 7, + 6, 0, 0, 2768, 2771, 3, 338, 169, 0, 2769, 2770, 7, 6, 0, 0, 2770, 2772, + 3, 338, 169, 0, 2771, 2769, 1, 0, 0, 0, 2771, 2772, 1, 0, 0, 0, 2772, 2781, + 1, 0, 0, 0, 2773, 2774, 5, 443, 0, 0, 2774, 2775, 5, 531, 0, 0, 2775, 2776, + 5, 512, 0, 0, 2776, 2778, 5, 254, 0, 0, 2777, 2779, 3, 76, 38, 0, 2778, + 2777, 1, 0, 0, 0, 2778, 2779, 1, 0, 0, 0, 2779, 2781, 1, 0, 0, 0, 2780, + 2077, 1, 0, 0, 0, 2780, 2085, 1, 0, 0, 0, 2780, 2087, 1, 0, 0, 0, 2780, + 2109, 1, 0, 0, 0, 2780, 2113, 1, 0, 0, 0, 2780, 2122, 1, 0, 0, 0, 2780, + 2124, 1, 0, 0, 0, 2780, 2140, 1, 0, 0, 0, 2780, 2148, 1, 0, 0, 0, 2780, + 2157, 1, 0, 0, 0, 2780, 2172, 1, 0, 0, 0, 2780, 2175, 1, 0, 0, 0, 2780, + 2181, 1, 0, 0, 0, 2780, 2187, 1, 0, 0, 0, 2780, 2203, 1, 0, 0, 0, 2780, + 2219, 1, 0, 0, 0, 2780, 2229, 1, 0, 0, 0, 2780, 2234, 1, 0, 0, 0, 2780, + 2238, 1, 0, 0, 0, 2780, 2242, 1, 0, 0, 0, 2780, 2249, 1, 0, 0, 0, 2780, + 2258, 1, 0, 0, 0, 2780, 2263, 1, 0, 0, 0, 2780, 2271, 1, 0, 0, 0, 2780, + 2273, 1, 0, 0, 0, 2780, 2276, 1, 0, 0, 0, 2780, 2278, 1, 0, 0, 0, 2780, + 2288, 1, 0, 0, 0, 2780, 2295, 1, 0, 0, 0, 2780, 2300, 1, 0, 0, 0, 2780, + 2316, 1, 0, 0, 0, 2780, 2328, 1, 0, 0, 0, 2780, 2330, 1, 0, 0, 0, 2780, + 2333, 1, 0, 0, 0, 2780, 2335, 1, 0, 0, 0, 2780, 2338, 1, 0, 0, 0, 2780, + 2344, 1, 0, 0, 0, 2780, 2349, 1, 0, 0, 0, 2780, 2353, 1, 0, 0, 0, 2780, + 2356, 1, 0, 0, 0, 2780, 2361, 1, 0, 0, 0, 2780, 2371, 1, 0, 0, 0, 2780, + 2378, 1, 0, 0, 0, 2780, 2383, 1, 0, 0, 0, 2780, 2394, 1, 0, 0, 0, 2780, + 2404, 1, 0, 0, 0, 2780, 2410, 1, 0, 0, 0, 2780, 2414, 1, 0, 0, 0, 2780, + 2419, 1, 0, 0, 0, 2780, 2422, 1, 0, 0, 0, 2780, 2437, 1, 0, 0, 0, 2780, + 2445, 1, 0, 0, 0, 2780, 2450, 1, 0, 0, 0, 2780, 2456, 1, 0, 0, 0, 2780, + 2458, 1, 0, 0, 0, 2780, 2460, 1, 0, 0, 0, 2780, 2465, 1, 0, 0, 0, 2780, + 2476, 1, 0, 0, 0, 2780, 2494, 1, 0, 0, 0, 2780, 2511, 1, 0, 0, 0, 2780, + 2523, 1, 0, 0, 0, 2780, 2527, 1, 0, 0, 0, 2780, 2537, 1, 0, 0, 0, 2780, + 2542, 1, 0, 0, 0, 2780, 2545, 1, 0, 0, 0, 2780, 2559, 1, 0, 0, 0, 2780, + 2562, 1, 0, 0, 0, 2780, 2568, 1, 0, 0, 0, 2780, 2574, 1, 0, 0, 0, 2780, + 2580, 1, 0, 0, 0, 2780, 2585, 1, 0, 0, 0, 2780, 2587, 1, 0, 0, 0, 2780, + 2598, 1, 0, 0, 0, 2780, 2603, 1, 0, 0, 0, 2780, 2614, 1, 0, 0, 0, 2780, + 2621, 1, 0, 0, 0, 2780, 2630, 1, 0, 0, 0, 2780, 2636, 1, 0, 0, 0, 2780, + 2648, 1, 0, 0, 0, 2780, 2660, 1, 0, 0, 0, 2780, 2670, 1, 0, 0, 0, 2780, + 2679, 1, 0, 0, 0, 2780, 2695, 1, 0, 0, 0, 2780, 2703, 1, 0, 0, 0, 2780, + 2706, 1, 0, 0, 0, 2780, 2711, 1, 0, 0, 0, 2780, 2720, 1, 0, 0, 0, 2780, + 2728, 1, 0, 0, 0, 2780, 2735, 1, 0, 0, 0, 2780, 2750, 1, 0, 0, 0, 2780, + 2765, 1, 0, 0, 0, 2780, 2773, 1, 0, 0, 0, 2781, 35, 1, 0, 0, 0, 2782, 2875, + 5, 470, 0, 0, 2783, 2784, 5, 443, 0, 0, 2784, 2785, 5, 103, 0, 0, 2785, + 2786, 5, 278, 0, 0, 2786, 2787, 5, 193, 0, 0, 2787, 2875, 3, 338, 169, + 0, 2788, 2875, 3, 48, 24, 0, 2789, 2790, 5, 278, 0, 0, 2790, 2796, 3, 226, + 113, 0, 2791, 2792, 5, 375, 0, 0, 2792, 2793, 5, 2, 0, 0, 2793, 2794, 3, + 328, 164, 0, 2794, 2795, 5, 3, 0, 0, 2795, 2797, 1, 0, 0, 0, 2796, 2791, + 1, 0, 0, 0, 2796, 2797, 1, 0, 0, 0, 2797, 2799, 1, 0, 0, 0, 2798, 2800, + 3, 452, 226, 0, 2799, 2798, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 2875, + 1, 0, 0, 0, 2801, 2803, 5, 443, 0, 0, 2802, 2804, 5, 20, 0, 0, 2803, 2802, + 1, 0, 0, 0, 2803, 2804, 1, 0, 0, 0, 2804, 2805, 1, 0, 0, 0, 2805, 2806, + 5, 103, 0, 0, 2806, 2807, 5, 423, 0, 0, 2807, 2808, 5, 278, 0, 0, 2808, + 2809, 5, 193, 0, 0, 2809, 2875, 3, 338, 169, 0, 2810, 2811, 5, 353, 0, + 0, 2811, 2812, 5, 423, 0, 0, 2812, 2813, 5, 278, 0, 0, 2813, 2814, 5, 193, + 0, 0, 2814, 2875, 3, 338, 169, 0, 2815, 2816, 5, 353, 0, 0, 2816, 2817, + 5, 20, 0, 0, 2817, 2818, 5, 423, 0, 0, 2818, 2875, 5, 278, 0, 0, 2819, + 2820, 5, 409, 0, 0, 2820, 2821, 5, 423, 0, 0, 2821, 2822, 5, 278, 0, 0, + 2822, 2823, 5, 193, 0, 0, 2823, 2875, 3, 338, 169, 0, 2824, 2825, 5, 409, + 0, 0, 2825, 2826, 5, 20, 0, 0, 2826, 2827, 5, 423, 0, 0, 2827, 2875, 5, + 278, 0, 0, 2828, 2829, 5, 459, 0, 0, 2829, 2830, 5, 423, 0, 0, 2830, 2831, + 5, 278, 0, 0, 2831, 2832, 5, 193, 0, 0, 2832, 2875, 3, 338, 169, 0, 2833, + 2835, 5, 443, 0, 0, 2834, 2836, 5, 20, 0, 0, 2835, 2834, 1, 0, 0, 0, 2835, + 2836, 1, 0, 0, 0, 2836, 2837, 1, 0, 0, 0, 2837, 2838, 5, 423, 0, 0, 2838, + 2845, 5, 278, 0, 0, 2839, 2840, 5, 193, 0, 0, 2840, 2846, 3, 338, 169, + 0, 2841, 2842, 5, 273, 0, 0, 2842, 2844, 5, 569, 0, 0, 2843, 2841, 1, 0, + 0, 0, 2843, 2844, 1, 0, 0, 0, 2844, 2846, 1, 0, 0, 0, 2845, 2839, 1, 0, + 0, 0, 2845, 2843, 1, 0, 0, 0, 2846, 2875, 1, 0, 0, 0, 2847, 2848, 5, 443, + 0, 0, 2848, 2849, 5, 423, 0, 0, 2849, 2850, 5, 278, 0, 0, 2850, 2853, 5, + 478, 0, 0, 2851, 2852, 7, 6, 0, 0, 2852, 2854, 3, 464, 232, 0, 2853, 2851, + 1, 0, 0, 0, 2853, 2854, 1, 0, 0, 0, 2854, 2856, 1, 0, 0, 0, 2855, 2857, + 3, 76, 38, 0, 2856, 2855, 1, 0, 0, 0, 2856, 2857, 1, 0, 0, 0, 2857, 2875, + 1, 0, 0, 0, 2858, 2859, 5, 443, 0, 0, 2859, 2860, 5, 245, 0, 0, 2860, 2861, + 5, 233, 0, 0, 2861, 2875, 5, 24, 0, 0, 2862, 2863, 5, 443, 0, 0, 2863, + 2864, 5, 245, 0, 0, 2864, 2865, 5, 233, 0, 0, 2865, 2875, 5, 490, 0, 0, + 2866, 2867, 5, 443, 0, 0, 2867, 2868, 5, 245, 0, 0, 2868, 2869, 5, 233, + 0, 0, 2869, 2875, 5, 491, 0, 0, 2870, 2871, 5, 443, 0, 0, 2871, 2872, 5, + 245, 0, 0, 2872, 2873, 5, 233, 0, 0, 2873, 2875, 5, 74, 0, 0, 2874, 2782, + 1, 0, 0, 0, 2874, 2783, 1, 0, 0, 0, 2874, 2788, 1, 0, 0, 0, 2874, 2789, + 1, 0, 0, 0, 2874, 2801, 1, 0, 0, 0, 2874, 2810, 1, 0, 0, 0, 2874, 2815, + 1, 0, 0, 0, 2874, 2819, 1, 0, 0, 0, 2874, 2824, 1, 0, 0, 0, 2874, 2828, + 1, 0, 0, 0, 2874, 2833, 1, 0, 0, 0, 2874, 2847, 1, 0, 0, 0, 2874, 2858, + 1, 0, 0, 0, 2874, 2862, 1, 0, 0, 0, 2874, 2866, 1, 0, 0, 0, 2874, 2870, + 1, 0, 0, 0, 2875, 37, 1, 0, 0, 0, 2876, 2878, 5, 261, 0, 0, 2877, 2879, + 5, 94, 0, 0, 2878, 2877, 1, 0, 0, 0, 2878, 2879, 1, 0, 0, 0, 2879, 2880, + 1, 0, 0, 0, 2880, 2885, 5, 575, 0, 0, 2881, 2882, 5, 261, 0, 0, 2882, 2883, + 5, 379, 0, 0, 2883, 2885, 7, 18, 0, 0, 2884, 2876, 1, 0, 0, 0, 2884, 2881, + 1, 0, 0, 0, 2885, 39, 1, 0, 0, 0, 2886, 2887, 5, 218, 0, 0, 2887, 3007, + 3, 186, 93, 0, 2888, 2889, 5, 509, 0, 0, 2889, 3007, 5, 473, 0, 0, 2890, + 2891, 5, 238, 0, 0, 2891, 2892, 5, 364, 0, 0, 2892, 2893, 5, 198, 0, 0, + 2893, 2895, 3, 186, 93, 0, 2894, 2896, 3, 326, 163, 0, 2895, 2894, 1, 0, + 0, 0, 2895, 2896, 1, 0, 0, 0, 2896, 3007, 1, 0, 0, 0, 2897, 2898, 5, 506, + 0, 0, 2898, 2899, 5, 364, 0, 0, 2899, 3007, 3, 186, 93, 0, 2900, 2901, + 5, 283, 0, 0, 2901, 2910, 5, 473, 0, 0, 2902, 2907, 3, 46, 23, 0, 2903, + 2904, 5, 4, 0, 0, 2904, 2906, 3, 46, 23, 0, 2905, 2903, 1, 0, 0, 0, 2906, + 2909, 1, 0, 0, 0, 2907, 2905, 1, 0, 0, 0, 2907, 2908, 1, 0, 0, 0, 2908, + 2911, 1, 0, 0, 0, 2909, 2907, 1, 0, 0, 0, 2910, 2902, 1, 0, 0, 0, 2910, + 2911, 1, 0, 0, 0, 2911, 3007, 1, 0, 0, 0, 2912, 2913, 5, 407, 0, 0, 2913, + 2914, 5, 447, 0, 0, 2914, 2915, 3, 338, 169, 0, 2915, 2916, 5, 198, 0, + 0, 2916, 2929, 3, 464, 232, 0, 2917, 2918, 7, 19, 0, 0, 2918, 2919, 5, + 2, 0, 0, 2919, 2924, 3, 74, 37, 0, 2920, 2921, 5, 4, 0, 0, 2921, 2923, + 3, 74, 37, 0, 2922, 2920, 1, 0, 0, 0, 2923, 2926, 1, 0, 0, 0, 2924, 2922, + 1, 0, 0, 0, 2924, 2925, 1, 0, 0, 0, 2925, 2927, 1, 0, 0, 0, 2926, 2924, + 1, 0, 0, 0, 2927, 2928, 5, 3, 0, 0, 2928, 2930, 1, 0, 0, 0, 2929, 2917, + 1, 0, 0, 0, 2929, 2930, 1, 0, 0, 0, 2930, 2932, 1, 0, 0, 0, 2931, 2933, + 3, 326, 163, 0, 2932, 2931, 1, 0, 0, 0, 2932, 2933, 1, 0, 0, 0, 2933, 3007, + 1, 0, 0, 0, 2934, 2935, 5, 531, 0, 0, 2935, 2939, 5, 512, 0, 0, 2936, 2940, + 5, 77, 0, 0, 2937, 2938, 5, 91, 0, 0, 2938, 2940, 5, 210, 0, 0, 2939, 2936, + 1, 0, 0, 0, 2939, 2937, 1, 0, 0, 0, 2940, 2941, 1, 0, 0, 0, 2941, 2942, + 3, 464, 232, 0, 2942, 2957, 5, 537, 0, 0, 2943, 2947, 5, 77, 0, 0, 2944, + 2945, 5, 91, 0, 0, 2945, 2947, 5, 210, 0, 0, 2946, 2943, 1, 0, 0, 0, 2946, + 2944, 1, 0, 0, 0, 2947, 2948, 1, 0, 0, 0, 2948, 2958, 3, 464, 232, 0, 2949, + 2954, 3, 42, 21, 0, 2950, 2951, 5, 25, 0, 0, 2951, 2953, 3, 42, 21, 0, + 2952, 2950, 1, 0, 0, 0, 2953, 2956, 1, 0, 0, 0, 2954, 2952, 1, 0, 0, 0, + 2954, 2955, 1, 0, 0, 0, 2955, 2958, 1, 0, 0, 0, 2956, 2954, 1, 0, 0, 0, + 2957, 2946, 1, 0, 0, 0, 2957, 2949, 1, 0, 0, 0, 2958, 2960, 1, 0, 0, 0, + 2959, 2961, 5, 195, 0, 0, 2960, 2959, 1, 0, 0, 0, 2960, 2961, 1, 0, 0, + 0, 2961, 2963, 1, 0, 0, 0, 2962, 2964, 3, 326, 163, 0, 2963, 2962, 1, 0, + 0, 0, 2963, 2964, 1, 0, 0, 0, 2964, 3007, 1, 0, 0, 0, 2965, 2967, 3, 198, + 99, 0, 2966, 2965, 1, 0, 0, 0, 2966, 2967, 1, 0, 0, 0, 2967, 2968, 1, 0, + 0, 0, 2968, 2969, 5, 531, 0, 0, 2969, 2970, 5, 512, 0, 0, 2970, 2971, 5, + 433, 0, 0, 2971, 2972, 3, 380, 190, 0, 2972, 2973, 5, 198, 0, 0, 2973, + 2975, 3, 44, 22, 0, 2974, 2976, 3, 252, 126, 0, 2975, 2974, 1, 0, 0, 0, + 2975, 2976, 1, 0, 0, 0, 2976, 3007, 1, 0, 0, 0, 2977, 2978, 5, 38, 0, 0, + 2978, 2979, 5, 447, 0, 0, 2979, 2980, 3, 338, 169, 0, 2980, 2981, 5, 489, + 0, 0, 2981, 2994, 3, 464, 232, 0, 2982, 2983, 7, 19, 0, 0, 2983, 2984, + 5, 2, 0, 0, 2984, 2989, 3, 74, 37, 0, 2985, 2986, 5, 4, 0, 0, 2986, 2988, + 3, 74, 37, 0, 2987, 2985, 1, 0, 0, 0, 2988, 2991, 1, 0, 0, 0, 2989, 2987, + 1, 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 2992, 1, 0, 0, 0, 2991, 2989, + 1, 0, 0, 0, 2992, 2993, 5, 3, 0, 0, 2993, 2995, 1, 0, 0, 0, 2994, 2982, + 1, 0, 0, 0, 2994, 2995, 1, 0, 0, 0, 2995, 2997, 1, 0, 0, 0, 2996, 2998, + 3, 326, 163, 0, 2997, 2996, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, 3007, + 1, 0, 0, 0, 2999, 3000, 5, 455, 0, 0, 3000, 3004, 5, 493, 0, 0, 3001, 3002, + 5, 537, 0, 0, 3002, 3003, 5, 96, 0, 0, 3003, 3005, 5, 447, 0, 0, 3004, + 3001, 1, 0, 0, 0, 3004, 3005, 1, 0, 0, 0, 3005, 3007, 1, 0, 0, 0, 3006, + 2886, 1, 0, 0, 0, 3006, 2888, 1, 0, 0, 0, 3006, 2890, 1, 0, 0, 0, 3006, + 2897, 1, 0, 0, 0, 3006, 2900, 1, 0, 0, 0, 3006, 2912, 1, 0, 0, 0, 3006, + 2934, 1, 0, 0, 0, 3006, 2966, 1, 0, 0, 0, 3006, 2977, 1, 0, 0, 0, 3006, + 2999, 1, 0, 0, 0, 3007, 41, 1, 0, 0, 0, 3008, 3009, 5, 472, 0, 0, 3009, + 3012, 3, 338, 169, 0, 3010, 3011, 5, 345, 0, 0, 3011, 3013, 3, 464, 232, + 0, 3012, 3010, 1, 0, 0, 0, 3012, 3013, 1, 0, 0, 0, 3013, 43, 1, 0, 0, 0, + 3014, 3016, 3, 338, 169, 0, 3015, 3017, 3, 336, 168, 0, 3016, 3015, 1, + 0, 0, 0, 3016, 3017, 1, 0, 0, 0, 3017, 45, 1, 0, 0, 0, 3018, 3021, 3, 338, + 169, 0, 3019, 3020, 5, 29, 0, 0, 3020, 3022, 3, 186, 93, 0, 3021, 3019, + 1, 0, 0, 0, 3021, 3022, 1, 0, 0, 0, 3022, 3031, 1, 0, 0, 0, 3023, 3025, + 5, 386, 0, 0, 3024, 3026, 5, 279, 0, 0, 3025, 3024, 1, 0, 0, 0, 3025, 3026, + 1, 0, 0, 0, 3026, 3032, 1, 0, 0, 0, 3027, 3029, 5, 285, 0, 0, 3028, 3027, + 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, 3030, 1, 0, 0, 0, 3030, 3032, + 5, 540, 0, 0, 3031, 3023, 1, 0, 0, 0, 3031, 3028, 1, 0, 0, 0, 3032, 47, + 1, 0, 0, 0, 3033, 3034, 5, 103, 0, 0, 3034, 3035, 5, 423, 0, 0, 3035, 3036, + 5, 278, 0, 0, 3036, 3039, 3, 338, 169, 0, 3037, 3038, 5, 331, 0, 0, 3038, + 3040, 3, 464, 232, 0, 3039, 3037, 1, 0, 0, 0, 3039, 3040, 1, 0, 0, 0, 3040, + 3043, 1, 0, 0, 0, 3041, 3042, 5, 537, 0, 0, 3042, 3044, 7, 20, 0, 0, 3043, + 3041, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 3053, 1, 0, 0, 0, 3045, + 3050, 3, 50, 25, 0, 3046, 3047, 5, 4, 0, 0, 3047, 3049, 3, 50, 25, 0, 3048, + 3046, 1, 0, 0, 0, 3049, 3052, 1, 0, 0, 0, 3050, 3048, 1, 0, 0, 0, 3050, + 3051, 1, 0, 0, 0, 3051, 3054, 1, 0, 0, 0, 3052, 3050, 1, 0, 0, 0, 3053, + 3045, 1, 0, 0, 0, 3053, 3054, 1, 0, 0, 0, 3054, 3056, 1, 0, 0, 0, 3055, + 3057, 3, 326, 163, 0, 3056, 3055, 1, 0, 0, 0, 3056, 3057, 1, 0, 0, 0, 3057, + 3058, 1, 0, 0, 0, 3058, 3059, 5, 198, 0, 0, 3059, 3060, 3, 464, 232, 0, + 3060, 3061, 5, 2, 0, 0, 3061, 3062, 3, 328, 164, 0, 3062, 3064, 5, 3, 0, + 0, 3063, 3065, 3, 452, 226, 0, 3064, 3063, 1, 0, 0, 0, 3064, 3065, 1, 0, + 0, 0, 3065, 49, 1, 0, 0, 0, 3066, 3067, 5, 84, 0, 0, 3067, 3068, 5, 482, + 0, 0, 3068, 3069, 5, 62, 0, 0, 3069, 3077, 5, 569, 0, 0, 3070, 3077, 3, + 60, 30, 0, 3071, 3077, 3, 58, 29, 0, 3072, 3077, 3, 56, 28, 0, 3073, 3077, + 3, 54, 27, 0, 3074, 3077, 3, 52, 26, 0, 3075, 3077, 3, 164, 82, 0, 3076, + 3066, 1, 0, 0, 0, 3076, 3070, 1, 0, 0, 0, 3076, 3071, 1, 0, 0, 0, 3076, + 3072, 1, 0, 0, 0, 3076, 3073, 1, 0, 0, 0, 3076, 3074, 1, 0, 0, 0, 3076, + 3075, 1, 0, 0, 0, 3077, 51, 1, 0, 0, 0, 3078, 3079, 5, 338, 0, 0, 3079, + 3080, 5, 62, 0, 0, 3080, 3081, 3, 464, 232, 0, 3081, 53, 1, 0, 0, 0, 3082, + 3083, 5, 133, 0, 0, 3083, 3084, 5, 331, 0, 0, 3084, 3085, 3, 388, 194, + 0, 3085, 55, 1, 0, 0, 0, 3086, 3087, 5, 535, 0, 0, 3087, 3088, 3, 388, + 194, 0, 3088, 57, 1, 0, 0, 0, 3089, 3090, 5, 368, 0, 0, 3090, 3091, 5, + 188, 0, 0, 3091, 3092, 3, 388, 194, 0, 3092, 59, 1, 0, 0, 0, 3093, 3094, + 5, 84, 0, 0, 3094, 3095, 5, 2, 0, 0, 3095, 3100, 3, 62, 31, 0, 3096, 3097, + 5, 4, 0, 0, 3097, 3099, 3, 62, 31, 0, 3098, 3096, 1, 0, 0, 0, 3099, 3102, + 1, 0, 0, 0, 3100, 3098, 1, 0, 0, 0, 3100, 3101, 1, 0, 0, 0, 3101, 3103, + 1, 0, 0, 0, 3102, 3100, 1, 0, 0, 0, 3103, 3104, 5, 3, 0, 0, 3104, 61, 1, + 0, 0, 0, 3105, 3108, 3, 464, 232, 0, 3106, 3107, 5, 543, 0, 0, 3107, 3109, + 3, 388, 194, 0, 3108, 3106, 1, 0, 0, 0, 3108, 3109, 1, 0, 0, 0, 3109, 3119, + 1, 0, 0, 0, 3110, 3111, 5, 2, 0, 0, 3111, 3114, 3, 464, 232, 0, 3112, 3113, + 5, 543, 0, 0, 3113, 3115, 3, 388, 194, 0, 3114, 3112, 1, 0, 0, 0, 3114, + 3115, 1, 0, 0, 0, 3115, 3116, 1, 0, 0, 0, 3116, 3117, 5, 3, 0, 0, 3117, + 3119, 1, 0, 0, 0, 3118, 3105, 1, 0, 0, 0, 3118, 3110, 1, 0, 0, 0, 3119, + 63, 1, 0, 0, 0, 3120, 3121, 5, 392, 0, 0, 3121, 3122, 5, 69, 0, 0, 3122, + 3124, 3, 464, 232, 0, 3123, 3125, 3, 326, 163, 0, 3124, 3123, 1, 0, 0, + 0, 3124, 3125, 1, 0, 0, 0, 3125, 3146, 1, 0, 0, 0, 3126, 3127, 5, 392, + 0, 0, 3127, 3128, 5, 115, 0, 0, 3128, 3130, 3, 338, 169, 0, 3129, 3131, + 3, 326, 163, 0, 3130, 3129, 1, 0, 0, 0, 3130, 3131, 1, 0, 0, 0, 3131, 3146, + 1, 0, 0, 0, 3132, 3133, 5, 392, 0, 0, 3133, 3134, 5, 472, 0, 0, 3134, 3146, + 3, 338, 169, 0, 3135, 3136, 5, 392, 0, 0, 3136, 3137, 5, 140, 0, 0, 3137, + 3146, 3, 338, 169, 0, 3138, 3139, 5, 392, 0, 0, 3139, 3143, 5, 267, 0, + 0, 3140, 3144, 5, 20, 0, 0, 3141, 3142, 5, 193, 0, 0, 3142, 3144, 3, 186, + 93, 0, 3143, 3140, 1, 0, 0, 0, 3143, 3141, 1, 0, 0, 0, 3144, 3146, 1, 0, + 0, 0, 3145, 3120, 1, 0, 0, 0, 3145, 3126, 1, 0, 0, 0, 3145, 3132, 1, 0, + 0, 0, 3145, 3135, 1, 0, 0, 0, 3145, 3138, 1, 0, 0, 0, 3146, 65, 1, 0, 0, + 0, 3147, 3148, 5, 76, 0, 0, 3148, 3149, 5, 20, 0, 0, 3149, 3171, 5, 374, + 0, 0, 3150, 3151, 5, 76, 0, 0, 3151, 3153, 5, 262, 0, 0, 3152, 3154, 3, + 464, 232, 0, 3153, 3152, 1, 0, 0, 0, 3153, 3154, 1, 0, 0, 0, 3154, 3155, + 1, 0, 0, 0, 3155, 3156, 7, 6, 0, 0, 3156, 3171, 3, 464, 232, 0, 3157, 3158, + 5, 76, 0, 0, 3158, 3159, 5, 379, 0, 0, 3159, 3164, 5, 457, 0, 0, 3160, + 3161, 5, 193, 0, 0, 3161, 3165, 3, 464, 232, 0, 3162, 3163, 7, 6, 0, 0, + 3163, 3165, 3, 338, 169, 0, 3164, 3160, 1, 0, 0, 0, 3164, 3162, 1, 0, 0, + 0, 3165, 3171, 1, 0, 0, 0, 3166, 3167, 5, 76, 0, 0, 3167, 3168, 5, 20, + 0, 0, 3168, 3169, 5, 379, 0, 0, 3169, 3171, 5, 457, 0, 0, 3170, 3147, 1, + 0, 0, 0, 3170, 3150, 1, 0, 0, 0, 3170, 3157, 1, 0, 0, 0, 3170, 3166, 1, + 0, 0, 0, 3171, 67, 1, 0, 0, 0, 3172, 3173, 5, 66, 0, 0, 3173, 3176, 5, + 278, 0, 0, 3174, 3175, 7, 6, 0, 0, 3175, 3177, 3, 464, 232, 0, 3176, 3174, + 1, 0, 0, 0, 3176, 3177, 1, 0, 0, 0, 3177, 3179, 1, 0, 0, 0, 3178, 3180, + 3, 76, 38, 0, 3179, 3178, 1, 0, 0, 0, 3179, 3180, 1, 0, 0, 0, 3180, 3261, + 1, 0, 0, 0, 3181, 3182, 5, 66, 0, 0, 3182, 3185, 5, 178, 0, 0, 3183, 3184, + 7, 6, 0, 0, 3184, 3186, 3, 464, 232, 0, 3185, 3183, 1, 0, 0, 0, 3185, 3186, + 1, 0, 0, 0, 3186, 3188, 1, 0, 0, 0, 3187, 3189, 3, 76, 38, 0, 3188, 3187, + 1, 0, 0, 0, 3188, 3189, 1, 0, 0, 0, 3189, 3261, 1, 0, 0, 0, 3190, 3191, + 5, 66, 0, 0, 3191, 3192, 5, 531, 0, 0, 3192, 3193, 5, 512, 0, 0, 3193, + 3195, 5, 254, 0, 0, 3194, 3196, 3, 76, 38, 0, 3195, 3194, 1, 0, 0, 0, 3195, + 3196, 1, 0, 0, 0, 3196, 3261, 1, 0, 0, 0, 3197, 3198, 5, 66, 0, 0, 3198, + 3199, 5, 130, 0, 0, 3199, 3200, 5, 36, 0, 0, 3200, 3205, 5, 569, 0, 0, + 3201, 3202, 5, 4, 0, 0, 3202, 3204, 5, 569, 0, 0, 3203, 3201, 1, 0, 0, + 0, 3204, 3207, 1, 0, 0, 0, 3205, 3203, 1, 0, 0, 0, 3205, 3206, 1, 0, 0, + 0, 3206, 3261, 1, 0, 0, 0, 3207, 3205, 1, 0, 0, 0, 3208, 3209, 5, 66, 0, + 0, 3209, 3212, 5, 38, 0, 0, 3210, 3211, 7, 6, 0, 0, 3211, 3213, 3, 464, + 232, 0, 3212, 3210, 1, 0, 0, 0, 3212, 3213, 1, 0, 0, 0, 3213, 3261, 1, + 0, 0, 0, 3214, 3215, 5, 66, 0, 0, 3215, 3218, 5, 407, 0, 0, 3216, 3217, + 7, 6, 0, 0, 3217, 3219, 3, 464, 232, 0, 3218, 3216, 1, 0, 0, 0, 3218, 3219, + 1, 0, 0, 0, 3219, 3261, 1, 0, 0, 0, 3220, 3221, 5, 66, 0, 0, 3221, 3222, + 5, 59, 0, 0, 3222, 3223, 5, 233, 0, 0, 3223, 3224, 5, 331, 0, 0, 3224, + 3235, 3, 338, 169, 0, 3225, 3226, 5, 2, 0, 0, 3226, 3231, 5, 575, 0, 0, + 3227, 3228, 5, 4, 0, 0, 3228, 3230, 5, 575, 0, 0, 3229, 3227, 1, 0, 0, + 0, 3230, 3233, 1, 0, 0, 0, 3231, 3229, 1, 0, 0, 0, 3231, 3232, 1, 0, 0, + 0, 3232, 3234, 1, 0, 0, 0, 3233, 3231, 1, 0, 0, 0, 3234, 3236, 5, 3, 0, + 0, 3235, 3225, 1, 0, 0, 0, 3235, 3236, 1, 0, 0, 0, 3236, 3261, 1, 0, 0, + 0, 3237, 3238, 5, 66, 0, 0, 3238, 3239, 5, 21, 0, 0, 3239, 3244, 5, 472, + 0, 0, 3240, 3245, 5, 420, 0, 0, 3241, 3242, 5, 298, 0, 0, 3242, 3245, 5, + 529, 0, 0, 3243, 3245, 5, 83, 0, 0, 3244, 3240, 1, 0, 0, 0, 3244, 3241, + 1, 0, 0, 0, 3244, 3243, 1, 0, 0, 0, 3245, 3246, 1, 0, 0, 0, 3246, 3247, + 5, 198, 0, 0, 3247, 3258, 3, 338, 169, 0, 3248, 3249, 5, 2, 0, 0, 3249, + 3254, 5, 575, 0, 0, 3250, 3251, 5, 4, 0, 0, 3251, 3253, 5, 575, 0, 0, 3252, + 3250, 1, 0, 0, 0, 3253, 3256, 1, 0, 0, 0, 3254, 3252, 1, 0, 0, 0, 3254, + 3255, 1, 0, 0, 0, 3255, 3257, 1, 0, 0, 0, 3256, 3254, 1, 0, 0, 0, 3257, + 3259, 5, 3, 0, 0, 3258, 3248, 1, 0, 0, 0, 3258, 3259, 1, 0, 0, 0, 3259, + 3261, 1, 0, 0, 0, 3260, 3172, 1, 0, 0, 0, 3260, 3181, 1, 0, 0, 0, 3260, + 3190, 1, 0, 0, 0, 3260, 3197, 1, 0, 0, 0, 3260, 3208, 1, 0, 0, 0, 3260, + 3214, 1, 0, 0, 0, 3260, 3220, 1, 0, 0, 0, 3260, 3237, 1, 0, 0, 0, 3261, + 69, 1, 0, 0, 0, 3262, 3263, 5, 15, 0, 0, 3263, 3264, 5, 443, 0, 0, 3264, + 3265, 5, 402, 0, 0, 3265, 3266, 5, 146, 0, 0, 3266, 3267, 5, 198, 0, 0, + 3267, 3475, 3, 74, 37, 0, 3268, 3269, 5, 15, 0, 0, 3269, 3270, 5, 388, + 0, 0, 3270, 3282, 5, 141, 0, 0, 3271, 3272, 5, 331, 0, 0, 3272, 3273, 5, + 2, 0, 0, 3273, 3278, 5, 569, 0, 0, 3274, 3275, 5, 4, 0, 0, 3275, 3277, + 5, 569, 0, 0, 3276, 3274, 1, 0, 0, 0, 3277, 3280, 1, 0, 0, 0, 3278, 3276, + 1, 0, 0, 0, 3278, 3279, 1, 0, 0, 0, 3279, 3281, 1, 0, 0, 0, 3280, 3278, + 1, 0, 0, 0, 3281, 3283, 5, 3, 0, 0, 3282, 3271, 1, 0, 0, 0, 3282, 3283, + 1, 0, 0, 0, 3283, 3475, 1, 0, 0, 0, 3284, 3285, 5, 15, 0, 0, 3285, 3286, + 5, 66, 0, 0, 3286, 3287, 5, 388, 0, 0, 3287, 3299, 5, 141, 0, 0, 3288, + 3289, 5, 331, 0, 0, 3289, 3290, 5, 2, 0, 0, 3290, 3295, 5, 569, 0, 0, 3291, + 3292, 5, 4, 0, 0, 3292, 3294, 5, 569, 0, 0, 3293, 3291, 1, 0, 0, 0, 3294, + 3297, 1, 0, 0, 0, 3295, 3293, 1, 0, 0, 0, 3295, 3296, 1, 0, 0, 0, 3296, + 3298, 1, 0, 0, 0, 3297, 3295, 1, 0, 0, 0, 3298, 3300, 5, 3, 0, 0, 3299, + 3288, 1, 0, 0, 0, 3299, 3300, 1, 0, 0, 0, 3300, 3475, 1, 0, 0, 0, 3301, + 3302, 5, 15, 0, 0, 3302, 3303, 5, 137, 0, 0, 3303, 3304, 5, 475, 0, 0, + 3304, 3475, 5, 575, 0, 0, 3305, 3306, 5, 15, 0, 0, 3306, 3307, 5, 443, + 0, 0, 3307, 3308, 5, 402, 0, 0, 3308, 3309, 5, 458, 0, 0, 3309, 3310, 5, + 198, 0, 0, 3310, 3316, 3, 74, 37, 0, 3311, 3312, 5, 535, 0, 0, 3312, 3313, + 5, 458, 0, 0, 3313, 3317, 5, 543, 0, 0, 3314, 3315, 5, 545, 0, 0, 3315, + 3317, 5, 569, 0, 0, 3316, 3311, 1, 0, 0, 0, 3316, 3314, 1, 0, 0, 0, 3316, + 3317, 1, 0, 0, 0, 3317, 3475, 1, 0, 0, 0, 3318, 3319, 5, 15, 0, 0, 3319, + 3320, 5, 88, 0, 0, 3320, 3321, 5, 472, 0, 0, 3321, 3326, 3, 74, 37, 0, + 3322, 3323, 5, 535, 0, 0, 3323, 3324, 5, 501, 0, 0, 3324, 3325, 5, 543, + 0, 0, 3325, 3327, 5, 569, 0, 0, 3326, 3322, 1, 0, 0, 0, 3326, 3327, 1, + 0, 0, 0, 3327, 3475, 1, 0, 0, 0, 3328, 3329, 5, 15, 0, 0, 3329, 3330, 5, + 75, 0, 0, 3330, 3332, 3, 374, 187, 0, 3331, 3333, 3, 326, 163, 0, 3332, + 3331, 1, 0, 0, 0, 3332, 3333, 1, 0, 0, 0, 3333, 3475, 1, 0, 0, 0, 3334, + 3335, 5, 15, 0, 0, 3335, 3336, 5, 443, 0, 0, 3336, 3337, 5, 475, 0, 0, + 3337, 3338, 5, 460, 0, 0, 3338, 3340, 5, 196, 0, 0, 3339, 3341, 5, 527, + 0, 0, 3340, 3339, 1, 0, 0, 0, 3340, 3341, 1, 0, 0, 0, 3341, 3475, 1, 0, + 0, 0, 3342, 3343, 5, 15, 0, 0, 3343, 3347, 5, 439, 0, 0, 3344, 3348, 5, + 199, 0, 0, 3345, 3346, 5, 20, 0, 0, 3346, 3348, 5, 200, 0, 0, 3347, 3344, + 1, 0, 0, 0, 3347, 3345, 1, 0, 0, 0, 3348, 3349, 1, 0, 0, 0, 3349, 3354, + 5, 93, 0, 0, 3350, 3351, 5, 2, 0, 0, 3351, 3352, 3, 328, 164, 0, 3352, + 3353, 5, 3, 0, 0, 3353, 3355, 1, 0, 0, 0, 3354, 3350, 1, 0, 0, 0, 3354, + 3355, 1, 0, 0, 0, 3355, 3357, 1, 0, 0, 0, 3356, 3358, 5, 20, 0, 0, 3357, + 3356, 1, 0, 0, 0, 3357, 3358, 1, 0, 0, 0, 3358, 3475, 1, 0, 0, 0, 3359, + 3360, 5, 15, 0, 0, 3360, 3361, 5, 76, 0, 0, 3361, 3373, 5, 494, 0, 0, 3362, + 3363, 5, 331, 0, 0, 3363, 3364, 5, 2, 0, 0, 3364, 3369, 5, 569, 0, 0, 3365, + 3366, 5, 4, 0, 0, 3366, 3368, 5, 569, 0, 0, 3367, 3365, 1, 0, 0, 0, 3368, + 3371, 1, 0, 0, 0, 3369, 3367, 1, 0, 0, 0, 3369, 3370, 1, 0, 0, 0, 3370, + 3372, 1, 0, 0, 0, 3371, 3369, 1, 0, 0, 0, 3372, 3374, 5, 3, 0, 0, 3373, + 3362, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3475, 1, 0, 0, 0, 3375, + 3376, 5, 15, 0, 0, 3376, 3377, 5, 439, 0, 0, 3377, 3378, 5, 402, 0, 0, + 3378, 3379, 5, 528, 0, 0, 3379, 3380, 5, 375, 0, 0, 3380, 3381, 5, 2, 0, + 0, 3381, 3382, 3, 328, 164, 0, 3382, 3383, 5, 3, 0, 0, 3383, 3475, 1, 0, + 0, 0, 3384, 3385, 5, 15, 0, 0, 3385, 3386, 5, 439, 0, 0, 3386, 3387, 5, + 472, 0, 0, 3387, 3388, 3, 338, 169, 0, 3388, 3390, 5, 458, 0, 0, 3389, + 3391, 3, 326, 163, 0, 3390, 3389, 1, 0, 0, 0, 3390, 3391, 1, 0, 0, 0, 3391, + 3475, 1, 0, 0, 0, 3392, 3393, 5, 15, 0, 0, 3393, 3394, 5, 439, 0, 0, 3394, + 3395, 5, 402, 0, 0, 3395, 3396, 5, 458, 0, 0, 3396, 3397, 5, 375, 0, 0, + 3397, 3398, 5, 2, 0, 0, 3398, 3399, 3, 328, 164, 0, 3399, 3400, 5, 3, 0, + 0, 3400, 3475, 1, 0, 0, 0, 3401, 3402, 5, 15, 0, 0, 3402, 3403, 5, 397, + 0, 0, 3403, 3404, 5, 472, 0, 0, 3404, 3475, 3, 74, 37, 0, 3405, 3406, 5, + 15, 0, 0, 3406, 3407, 5, 66, 0, 0, 3407, 3408, 5, 397, 0, 0, 3408, 3409, + 5, 472, 0, 0, 3409, 3475, 3, 74, 37, 0, 3410, 3411, 5, 15, 0, 0, 3411, + 3412, 5, 101, 0, 0, 3412, 3413, 5, 475, 0, 0, 3413, 3415, 5, 575, 0, 0, + 3414, 3416, 3, 326, 163, 0, 3415, 3414, 1, 0, 0, 0, 3415, 3416, 1, 0, 0, + 0, 3416, 3475, 1, 0, 0, 0, 3417, 3418, 5, 15, 0, 0, 3418, 3419, 5, 439, + 0, 0, 3419, 3420, 5, 160, 0, 0, 3420, 3421, 5, 421, 0, 0, 3421, 3422, 5, + 259, 0, 0, 3422, 3423, 5, 375, 0, 0, 3423, 3424, 5, 2, 0, 0, 3424, 3425, + 3, 328, 164, 0, 3425, 3426, 5, 3, 0, 0, 3426, 3475, 1, 0, 0, 0, 3427, 3428, + 5, 15, 0, 0, 3428, 3429, 5, 439, 0, 0, 3429, 3430, 5, 472, 0, 0, 3430, + 3431, 3, 338, 169, 0, 3431, 3432, 5, 345, 0, 0, 3432, 3434, 5, 528, 0, + 0, 3433, 3435, 3, 326, 163, 0, 3434, 3433, 1, 0, 0, 0, 3434, 3435, 1, 0, + 0, 0, 3435, 3475, 1, 0, 0, 0, 3436, 3437, 5, 15, 0, 0, 3437, 3438, 5, 103, + 0, 0, 3438, 3439, 5, 77, 0, 0, 3439, 3441, 5, 447, 0, 0, 3440, 3442, 3, + 326, 163, 0, 3441, 3440, 1, 0, 0, 0, 3441, 3442, 1, 0, 0, 0, 3442, 3475, + 1, 0, 0, 0, 3443, 3444, 5, 15, 0, 0, 3444, 3445, 5, 439, 0, 0, 3445, 3446, + 5, 33, 0, 0, 3446, 3447, 5, 77, 0, 0, 3447, 3449, 5, 447, 0, 0, 3448, 3450, + 3, 326, 163, 0, 3449, 3448, 1, 0, 0, 0, 3449, 3450, 1, 0, 0, 0, 3450, 3475, + 1, 0, 0, 0, 3451, 3452, 5, 15, 0, 0, 3452, 3453, 5, 151, 0, 0, 3453, 3454, + 5, 77, 0, 0, 3454, 3455, 5, 447, 0, 0, 3455, 3456, 5, 535, 0, 0, 3456, + 3457, 3, 464, 232, 0, 3457, 3458, 5, 543, 0, 0, 3458, 3459, 5, 569, 0, + 0, 3459, 3475, 1, 0, 0, 0, 3460, 3461, 5, 15, 0, 0, 3461, 3462, 5, 439, + 0, 0, 3462, 3463, 5, 77, 0, 0, 3463, 3464, 5, 447, 0, 0, 3464, 3465, 5, + 185, 0, 0, 3465, 3475, 7, 21, 0, 0, 3466, 3467, 5, 15, 0, 0, 3467, 3468, + 5, 422, 0, 0, 3468, 3469, 5, 480, 0, 0, 3469, 3470, 5, 421, 0, 0, 3470, + 3472, 5, 259, 0, 0, 3471, 3473, 3, 326, 163, 0, 3472, 3471, 1, 0, 0, 0, + 3472, 3473, 1, 0, 0, 0, 3473, 3475, 1, 0, 0, 0, 3474, 3262, 1, 0, 0, 0, + 3474, 3268, 1, 0, 0, 0, 3474, 3284, 1, 0, 0, 0, 3474, 3301, 1, 0, 0, 0, + 3474, 3305, 1, 0, 0, 0, 3474, 3318, 1, 0, 0, 0, 3474, 3328, 1, 0, 0, 0, + 3474, 3334, 1, 0, 0, 0, 3474, 3342, 1, 0, 0, 0, 3474, 3359, 1, 0, 0, 0, + 3474, 3375, 1, 0, 0, 0, 3474, 3384, 1, 0, 0, 0, 3474, 3392, 1, 0, 0, 0, + 3474, 3401, 1, 0, 0, 0, 3474, 3405, 1, 0, 0, 0, 3474, 3410, 1, 0, 0, 0, + 3474, 3417, 1, 0, 0, 0, 3474, 3427, 1, 0, 0, 0, 3474, 3436, 1, 0, 0, 0, + 3474, 3443, 1, 0, 0, 0, 3474, 3451, 1, 0, 0, 0, 3474, 3460, 1, 0, 0, 0, + 3474, 3466, 1, 0, 0, 0, 3475, 71, 1, 0, 0, 0, 3476, 3477, 5, 390, 0, 0, + 3477, 3478, 5, 115, 0, 0, 3478, 3480, 3, 464, 232, 0, 3479, 3481, 5, 575, + 0, 0, 3480, 3479, 1, 0, 0, 0, 3480, 3481, 1, 0, 0, 0, 3481, 3484, 1, 0, + 0, 0, 3482, 3483, 5, 29, 0, 0, 3483, 3485, 3, 464, 232, 0, 3484, 3482, + 1, 0, 0, 0, 3484, 3485, 1, 0, 0, 0, 3485, 3510, 1, 0, 0, 0, 3486, 3487, + 5, 390, 0, 0, 3487, 3488, 5, 472, 0, 0, 3488, 3490, 3, 338, 169, 0, 3489, + 3491, 5, 575, 0, 0, 3490, 3489, 1, 0, 0, 0, 3490, 3491, 1, 0, 0, 0, 3491, + 3494, 1, 0, 0, 0, 3492, 3493, 5, 29, 0, 0, 3493, 3495, 3, 464, 232, 0, + 3494, 3492, 1, 0, 0, 0, 3494, 3495, 1, 0, 0, 0, 3495, 3510, 1, 0, 0, 0, + 3496, 3497, 5, 390, 0, 0, 3497, 3498, 5, 345, 0, 0, 3498, 3500, 3, 464, + 232, 0, 3499, 3501, 5, 575, 0, 0, 3500, 3499, 1, 0, 0, 0, 3500, 3501, 1, + 0, 0, 0, 3501, 3504, 1, 0, 0, 0, 3502, 3503, 5, 29, 0, 0, 3503, 3505, 3, + 464, 232, 0, 3504, 3502, 1, 0, 0, 0, 3504, 3505, 1, 0, 0, 0, 3505, 3506, + 1, 0, 0, 0, 3506, 3507, 5, 198, 0, 0, 3507, 3508, 3, 338, 169, 0, 3508, + 3510, 1, 0, 0, 0, 3509, 3476, 1, 0, 0, 0, 3509, 3486, 1, 0, 0, 0, 3509, + 3496, 1, 0, 0, 0, 3510, 73, 1, 0, 0, 0, 3511, 3513, 3, 338, 169, 0, 3512, + 3514, 3, 320, 160, 0, 3513, 3512, 1, 0, 0, 0, 3513, 3514, 1, 0, 0, 0, 3514, + 3516, 1, 0, 0, 0, 3515, 3517, 3, 458, 229, 0, 3516, 3515, 1, 0, 0, 0, 3516, + 3517, 1, 0, 0, 0, 3517, 3519, 1, 0, 0, 0, 3518, 3520, 3, 420, 210, 0, 3519, + 3518, 1, 0, 0, 0, 3519, 3520, 1, 0, 0, 0, 3520, 3522, 1, 0, 0, 0, 3521, + 3523, 3, 374, 187, 0, 3522, 3521, 1, 0, 0, 0, 3522, 3523, 1, 0, 0, 0, 3523, + 3524, 1, 0, 0, 0, 3524, 3526, 3, 336, 168, 0, 3525, 3527, 3, 454, 227, + 0, 3526, 3525, 1, 0, 0, 0, 3526, 3527, 1, 0, 0, 0, 3527, 3529, 1, 0, 0, + 0, 3528, 3530, 3, 274, 137, 0, 3529, 3528, 1, 0, 0, 0, 3529, 3530, 1, 0, + 0, 0, 3530, 75, 1, 0, 0, 0, 3531, 3532, 5, 273, 0, 0, 3532, 3536, 5, 569, + 0, 0, 3533, 3534, 5, 535, 0, 0, 3534, 3536, 3, 382, 191, 0, 3535, 3531, + 1, 0, 0, 0, 3535, 3533, 1, 0, 0, 0, 3536, 77, 1, 0, 0, 0, 3537, 3543, 5, + 39, 0, 0, 3538, 3539, 5, 537, 0, 0, 3539, 3541, 5, 262, 0, 0, 3540, 3542, + 3, 464, 232, 0, 3541, 3540, 1, 0, 0, 0, 3541, 3542, 1, 0, 0, 0, 3542, 3544, + 1, 0, 0, 0, 3543, 3538, 1, 0, 0, 0, 3543, 3544, 1, 0, 0, 0, 3544, 3580, + 1, 0, 0, 0, 3545, 3547, 5, 86, 0, 0, 3546, 3548, 5, 538, 0, 0, 3547, 3546, + 1, 0, 0, 0, 3547, 3548, 1, 0, 0, 0, 3548, 3554, 1, 0, 0, 0, 3549, 3551, + 5, 25, 0, 0, 3550, 3552, 5, 322, 0, 0, 3551, 3550, 1, 0, 0, 0, 3551, 3552, + 1, 0, 0, 0, 3552, 3553, 1, 0, 0, 0, 3553, 3555, 5, 71, 0, 0, 3554, 3549, + 1, 0, 0, 0, 3554, 3555, 1, 0, 0, 0, 3555, 3560, 1, 0, 0, 0, 3556, 3558, + 5, 322, 0, 0, 3557, 3556, 1, 0, 0, 0, 3557, 3558, 1, 0, 0, 0, 3558, 3559, + 1, 0, 0, 0, 3559, 3561, 5, 395, 0, 0, 3560, 3557, 1, 0, 0, 0, 3560, 3561, + 1, 0, 0, 0, 3561, 3580, 1, 0, 0, 0, 3562, 3564, 5, 419, 0, 0, 3563, 3565, + 5, 538, 0, 0, 3564, 3563, 1, 0, 0, 0, 3564, 3565, 1, 0, 0, 0, 3565, 3571, + 1, 0, 0, 0, 3566, 3568, 5, 25, 0, 0, 3567, 3569, 5, 322, 0, 0, 3568, 3567, + 1, 0, 0, 0, 3568, 3569, 1, 0, 0, 0, 3569, 3570, 1, 0, 0, 0, 3570, 3572, + 5, 71, 0, 0, 3571, 3566, 1, 0, 0, 0, 3571, 3572, 1, 0, 0, 0, 3572, 3577, + 1, 0, 0, 0, 3573, 3575, 5, 322, 0, 0, 3574, 3573, 1, 0, 0, 0, 3574, 3575, + 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, 3578, 5, 395, 0, 0, 3577, 3574, + 1, 0, 0, 0, 3577, 3578, 1, 0, 0, 0, 3578, 3580, 1, 0, 0, 0, 3579, 3537, + 1, 0, 0, 0, 3579, 3545, 1, 0, 0, 0, 3579, 3562, 1, 0, 0, 0, 3580, 79, 1, + 0, 0, 0, 3581, 3582, 5, 207, 0, 0, 3582, 3583, 3, 84, 42, 0, 3583, 3584, + 5, 331, 0, 0, 3584, 3585, 3, 190, 95, 0, 3585, 3589, 5, 489, 0, 0, 3586, + 3590, 3, 194, 97, 0, 3587, 3588, 5, 417, 0, 0, 3588, 3590, 3, 186, 93, + 0, 3589, 3586, 1, 0, 0, 0, 3589, 3587, 1, 0, 0, 0, 3590, 3668, 1, 0, 0, + 0, 3591, 3592, 5, 207, 0, 0, 3592, 3593, 3, 84, 42, 0, 3593, 3603, 5, 331, + 0, 0, 3594, 3604, 5, 405, 0, 0, 3595, 3604, 5, 77, 0, 0, 3596, 3597, 5, + 91, 0, 0, 3597, 3604, 5, 210, 0, 0, 3598, 3604, 5, 453, 0, 0, 3599, 3600, + 5, 460, 0, 0, 3600, 3604, 5, 525, 0, 0, 3601, 3602, 5, 539, 0, 0, 3602, + 3604, 5, 210, 0, 0, 3603, 3594, 1, 0, 0, 0, 3603, 3595, 1, 0, 0, 0, 3603, + 3596, 1, 0, 0, 0, 3603, 3598, 1, 0, 0, 0, 3603, 3599, 1, 0, 0, 0, 3603, + 3601, 1, 0, 0, 0, 3604, 3605, 1, 0, 0, 0, 3605, 3606, 3, 188, 94, 0, 3606, + 3610, 5, 489, 0, 0, 3607, 3611, 3, 194, 97, 0, 3608, 3609, 5, 417, 0, 0, + 3609, 3611, 3, 186, 93, 0, 3610, 3607, 1, 0, 0, 0, 3610, 3608, 1, 0, 0, + 0, 3611, 3668, 1, 0, 0, 0, 3612, 3613, 5, 207, 0, 0, 3613, 3618, 3, 186, + 93, 0, 3614, 3615, 5, 4, 0, 0, 3615, 3617, 3, 186, 93, 0, 3616, 3614, 1, + 0, 0, 0, 3617, 3620, 1, 0, 0, 0, 3618, 3616, 1, 0, 0, 0, 3618, 3619, 1, + 0, 0, 0, 3619, 3621, 1, 0, 0, 0, 3620, 3618, 1, 0, 0, 0, 3621, 3622, 5, + 489, 0, 0, 3622, 3623, 3, 194, 97, 0, 3623, 3668, 1, 0, 0, 0, 3624, 3625, + 5, 413, 0, 0, 3625, 3630, 3, 186, 93, 0, 3626, 3627, 5, 4, 0, 0, 3627, + 3629, 3, 186, 93, 0, 3628, 3626, 1, 0, 0, 0, 3629, 3632, 1, 0, 0, 0, 3630, + 3628, 1, 0, 0, 0, 3630, 3631, 1, 0, 0, 0, 3631, 3633, 1, 0, 0, 0, 3632, + 3630, 1, 0, 0, 0, 3633, 3634, 5, 198, 0, 0, 3634, 3635, 3, 194, 97, 0, + 3635, 3668, 1, 0, 0, 0, 3636, 3637, 5, 413, 0, 0, 3637, 3638, 3, 84, 42, + 0, 3638, 3648, 5, 331, 0, 0, 3639, 3649, 5, 405, 0, 0, 3640, 3649, 5, 77, + 0, 0, 3641, 3642, 5, 91, 0, 0, 3642, 3649, 5, 210, 0, 0, 3643, 3649, 5, + 453, 0, 0, 3644, 3645, 5, 460, 0, 0, 3645, 3649, 5, 525, 0, 0, 3646, 3647, + 5, 539, 0, 0, 3647, 3649, 5, 210, 0, 0, 3648, 3639, 1, 0, 0, 0, 3648, 3640, + 1, 0, 0, 0, 3648, 3641, 1, 0, 0, 0, 3648, 3643, 1, 0, 0, 0, 3648, 3644, + 1, 0, 0, 0, 3648, 3646, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 3651, + 3, 188, 94, 0, 3651, 3655, 5, 198, 0, 0, 3652, 3656, 3, 194, 97, 0, 3653, + 3654, 5, 417, 0, 0, 3654, 3656, 3, 186, 93, 0, 3655, 3652, 1, 0, 0, 0, + 3655, 3653, 1, 0, 0, 0, 3656, 3668, 1, 0, 0, 0, 3657, 3658, 5, 413, 0, + 0, 3658, 3659, 3, 84, 42, 0, 3659, 3660, 5, 331, 0, 0, 3660, 3661, 3, 190, + 95, 0, 3661, 3665, 5, 198, 0, 0, 3662, 3666, 3, 194, 97, 0, 3663, 3664, + 5, 417, 0, 0, 3664, 3666, 3, 186, 93, 0, 3665, 3662, 1, 0, 0, 0, 3665, + 3663, 1, 0, 0, 0, 3666, 3668, 1, 0, 0, 0, 3667, 3581, 1, 0, 0, 0, 3667, + 3591, 1, 0, 0, 0, 3667, 3612, 1, 0, 0, 0, 3667, 3624, 1, 0, 0, 0, 3667, + 3636, 1, 0, 0, 0, 3667, 3657, 1, 0, 0, 0, 3668, 81, 1, 0, 0, 0, 3669, 3671, + 3, 464, 232, 0, 3670, 3672, 3, 316, 158, 0, 3671, 3670, 1, 0, 0, 0, 3671, + 3672, 1, 0, 0, 0, 3672, 3675, 1, 0, 0, 0, 3673, 3675, 5, 20, 0, 0, 3674, + 3669, 1, 0, 0, 0, 3674, 3673, 1, 0, 0, 0, 3675, 83, 1, 0, 0, 0, 3676, 3681, + 3, 82, 41, 0, 3677, 3678, 5, 4, 0, 0, 3678, 3680, 3, 82, 41, 0, 3679, 3677, + 1, 0, 0, 0, 3680, 3683, 1, 0, 0, 0, 3681, 3679, 1, 0, 0, 0, 3681, 3682, + 1, 0, 0, 0, 3682, 85, 1, 0, 0, 0, 3683, 3681, 1, 0, 0, 0, 3684, 3685, 5, + 14, 0, 0, 3685, 3686, 5, 36, 0, 0, 3686, 3691, 5, 569, 0, 0, 3687, 3688, + 5, 4, 0, 0, 3688, 3690, 5, 569, 0, 0, 3689, 3687, 1, 0, 0, 0, 3690, 3693, + 1, 0, 0, 0, 3691, 3689, 1, 0, 0, 0, 3691, 3692, 1, 0, 0, 0, 3692, 3695, + 1, 0, 0, 0, 3693, 3691, 1, 0, 0, 0, 3694, 3696, 3, 326, 163, 0, 3695, 3694, + 1, 0, 0, 0, 3695, 3696, 1, 0, 0, 0, 3696, 3783, 1, 0, 0, 0, 3697, 3698, + 7, 22, 0, 0, 3698, 3699, 5, 36, 0, 0, 3699, 3704, 5, 569, 0, 0, 3700, 3701, + 5, 4, 0, 0, 3701, 3703, 5, 569, 0, 0, 3702, 3700, 1, 0, 0, 0, 3703, 3706, + 1, 0, 0, 0, 3704, 3702, 1, 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 3783, + 1, 0, 0, 0, 3706, 3704, 1, 0, 0, 0, 3707, 3708, 5, 130, 0, 0, 3708, 3709, + 5, 36, 0, 0, 3709, 3714, 5, 569, 0, 0, 3710, 3711, 5, 4, 0, 0, 3711, 3713, + 5, 569, 0, 0, 3712, 3710, 1, 0, 0, 0, 3713, 3716, 1, 0, 0, 0, 3714, 3712, + 1, 0, 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3783, 1, 0, 0, 0, 3716, 3714, + 1, 0, 0, 0, 3717, 3718, 5, 14, 0, 0, 3718, 3719, 5, 328, 0, 0, 3719, 3783, + 5, 569, 0, 0, 3720, 3721, 5, 151, 0, 0, 3721, 3722, 5, 328, 0, 0, 3722, + 3783, 5, 569, 0, 0, 3723, 3724, 5, 14, 0, 0, 3724, 3725, 5, 191, 0, 0, + 3725, 3783, 5, 569, 0, 0, 3726, 3727, 5, 151, 0, 0, 3727, 3728, 5, 191, + 0, 0, 3728, 3783, 5, 569, 0, 0, 3729, 3730, 5, 14, 0, 0, 3730, 3731, 5, + 57, 0, 0, 3731, 3732, 3, 186, 93, 0, 3732, 3737, 5, 569, 0, 0, 3733, 3734, + 5, 4, 0, 0, 3734, 3736, 5, 569, 0, 0, 3735, 3733, 1, 0, 0, 0, 3736, 3739, + 1, 0, 0, 0, 3737, 3735, 1, 0, 0, 0, 3737, 3738, 1, 0, 0, 0, 3738, 3783, + 1, 0, 0, 0, 3739, 3737, 1, 0, 0, 0, 3740, 3741, 5, 151, 0, 0, 3741, 3742, + 5, 57, 0, 0, 3742, 3743, 3, 186, 93, 0, 3743, 3748, 5, 569, 0, 0, 3744, + 3745, 5, 4, 0, 0, 3745, 3747, 5, 569, 0, 0, 3746, 3744, 1, 0, 0, 0, 3747, + 3750, 1, 0, 0, 0, 3748, 3746, 1, 0, 0, 0, 3748, 3749, 1, 0, 0, 0, 3749, + 3783, 1, 0, 0, 0, 3750, 3748, 1, 0, 0, 0, 3751, 3752, 5, 151, 0, 0, 3752, + 3753, 5, 20, 0, 0, 3753, 3754, 5, 57, 0, 0, 3754, 3783, 3, 186, 93, 0, + 3755, 3756, 5, 439, 0, 0, 3756, 3757, 5, 278, 0, 0, 3757, 3758, 5, 168, + 0, 0, 3758, 3760, 5, 226, 0, 0, 3759, 3761, 3, 326, 163, 0, 3760, 3759, + 1, 0, 0, 0, 3760, 3761, 1, 0, 0, 0, 3761, 3783, 1, 0, 0, 0, 3762, 3763, + 5, 311, 0, 0, 3763, 3764, 5, 36, 0, 0, 3764, 3769, 5, 569, 0, 0, 3765, + 3766, 5, 4, 0, 0, 3766, 3768, 5, 569, 0, 0, 3767, 3765, 1, 0, 0, 0, 3768, + 3771, 1, 0, 0, 0, 3769, 3767, 1, 0, 0, 0, 3769, 3770, 1, 0, 0, 0, 3770, + 3772, 1, 0, 0, 0, 3771, 3769, 1, 0, 0, 0, 3772, 3773, 5, 439, 0, 0, 3773, + 3774, 5, 2, 0, 0, 3774, 3775, 3, 328, 164, 0, 3775, 3776, 5, 3, 0, 0, 3776, + 3783, 1, 0, 0, 0, 3777, 3778, 5, 311, 0, 0, 3778, 3779, 7, 2, 0, 0, 3779, + 3780, 5, 569, 0, 0, 3780, 3781, 5, 222, 0, 0, 3781, 3783, 5, 569, 0, 0, + 3782, 3684, 1, 0, 0, 0, 3782, 3697, 1, 0, 0, 0, 3782, 3707, 1, 0, 0, 0, + 3782, 3717, 1, 0, 0, 0, 3782, 3720, 1, 0, 0, 0, 3782, 3723, 1, 0, 0, 0, + 3782, 3726, 1, 0, 0, 0, 3782, 3729, 1, 0, 0, 0, 3782, 3740, 1, 0, 0, 0, + 3782, 3751, 1, 0, 0, 0, 3782, 3755, 1, 0, 0, 0, 3782, 3762, 1, 0, 0, 0, + 3782, 3777, 1, 0, 0, 0, 3783, 87, 1, 0, 0, 0, 3784, 3786, 3, 464, 232, + 0, 3785, 3787, 3, 326, 163, 0, 3786, 3785, 1, 0, 0, 0, 3786, 3787, 1, 0, + 0, 0, 3787, 89, 1, 0, 0, 0, 3788, 3789, 3, 464, 232, 0, 3789, 3793, 3, + 316, 158, 0, 3790, 3791, 5, 155, 0, 0, 3791, 3792, 5, 259, 0, 0, 3792, + 3794, 3, 316, 158, 0, 3793, 3790, 1, 0, 0, 0, 3793, 3794, 1, 0, 0, 0, 3794, + 3796, 1, 0, 0, 0, 3795, 3797, 3, 120, 60, 0, 3796, 3795, 1, 0, 0, 0, 3796, + 3797, 1, 0, 0, 0, 3797, 3799, 1, 0, 0, 0, 3798, 3800, 3, 326, 163, 0, 3799, + 3798, 1, 0, 0, 0, 3799, 3800, 1, 0, 0, 0, 3800, 91, 1, 0, 0, 0, 3801, 3802, + 5, 14, 0, 0, 3802, 3803, 5, 83, 0, 0, 3803, 3805, 3, 346, 173, 0, 3804, + 3806, 3, 116, 58, 0, 3805, 3804, 1, 0, 0, 0, 3805, 3806, 1, 0, 0, 0, 3806, + 3808, 1, 0, 0, 0, 3807, 3809, 3, 118, 59, 0, 3808, 3807, 1, 0, 0, 0, 3808, + 3809, 1, 0, 0, 0, 3809, 3811, 1, 0, 0, 0, 3810, 3812, 3, 326, 163, 0, 3811, + 3810, 1, 0, 0, 0, 3811, 3812, 1, 0, 0, 0, 3812, 4054, 1, 0, 0, 0, 3813, + 3814, 5, 14, 0, 0, 3814, 3815, 5, 83, 0, 0, 3815, 3816, 5, 2, 0, 0, 3816, + 3817, 3, 344, 172, 0, 3817, 3819, 5, 3, 0, 0, 3818, 3820, 3, 118, 59, 0, + 3819, 3818, 1, 0, 0, 0, 3819, 3820, 1, 0, 0, 0, 3820, 3822, 1, 0, 0, 0, + 3821, 3823, 3, 326, 163, 0, 3822, 3821, 1, 0, 0, 0, 3822, 3823, 1, 0, 0, + 0, 3823, 4054, 1, 0, 0, 0, 3824, 3825, 5, 151, 0, 0, 3825, 3826, 5, 83, + 0, 0, 3826, 3828, 3, 464, 232, 0, 3827, 3829, 3, 120, 60, 0, 3828, 3827, + 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3831, 1, 0, 0, 0, 3830, 3832, + 3, 326, 163, 0, 3831, 3830, 1, 0, 0, 0, 3831, 3832, 1, 0, 0, 0, 3832, 4054, + 1, 0, 0, 0, 3833, 3834, 5, 311, 0, 0, 3834, 3835, 5, 83, 0, 0, 3835, 3837, + 3, 346, 173, 0, 3836, 3838, 3, 116, 58, 0, 3837, 3836, 1, 0, 0, 0, 3837, + 3838, 1, 0, 0, 0, 3838, 3840, 1, 0, 0, 0, 3839, 3841, 3, 120, 60, 0, 3840, + 3839, 1, 0, 0, 0, 3840, 3841, 1, 0, 0, 0, 3841, 3843, 1, 0, 0, 0, 3842, + 3844, 3, 326, 163, 0, 3843, 3842, 1, 0, 0, 0, 3843, 3844, 1, 0, 0, 0, 3844, + 4054, 1, 0, 0, 0, 3845, 3846, 5, 338, 0, 0, 3846, 3847, 5, 62, 0, 0, 3847, + 3849, 3, 316, 158, 0, 3848, 3850, 3, 120, 60, 0, 3849, 3848, 1, 0, 0, 0, + 3849, 3850, 1, 0, 0, 0, 3850, 3852, 1, 0, 0, 0, 3851, 3853, 3, 326, 163, + 0, 3852, 3851, 1, 0, 0, 0, 3852, 3853, 1, 0, 0, 0, 3853, 4054, 1, 0, 0, + 0, 3854, 3856, 5, 14, 0, 0, 3855, 3857, 5, 481, 0, 0, 3856, 3855, 1, 0, + 0, 0, 3856, 3857, 1, 0, 0, 0, 3857, 3858, 1, 0, 0, 0, 3858, 3873, 3, 354, + 177, 0, 3859, 3860, 5, 145, 0, 0, 3860, 3864, 5, 62, 0, 0, 3861, 3862, + 5, 214, 0, 0, 3862, 3865, 3, 316, 158, 0, 3863, 3865, 5, 384, 0, 0, 3864, + 3861, 1, 0, 0, 0, 3864, 3863, 1, 0, 0, 0, 3865, 3871, 1, 0, 0, 0, 3866, + 3869, 5, 58, 0, 0, 3867, 3870, 5, 575, 0, 0, 3868, 3870, 5, 33, 0, 0, 3869, + 3867, 1, 0, 0, 0, 3869, 3868, 1, 0, 0, 0, 3870, 3872, 1, 0, 0, 0, 3871, + 3866, 1, 0, 0, 0, 3871, 3872, 1, 0, 0, 0, 3872, 3874, 1, 0, 0, 0, 3873, + 3859, 1, 0, 0, 0, 3873, 3874, 1, 0, 0, 0, 3874, 3876, 1, 0, 0, 0, 3875, + 3877, 3, 326, 163, 0, 3876, 3875, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, + 4054, 1, 0, 0, 0, 3878, 3880, 5, 151, 0, 0, 3879, 3881, 5, 481, 0, 0, 3880, + 3879, 1, 0, 0, 0, 3880, 3881, 1, 0, 0, 0, 3881, 3882, 1, 0, 0, 0, 3882, + 3885, 5, 345, 0, 0, 3883, 3884, 5, 228, 0, 0, 3884, 3886, 5, 175, 0, 0, + 3885, 3883, 1, 0, 0, 0, 3885, 3886, 1, 0, 0, 0, 3886, 3887, 1, 0, 0, 0, + 3887, 3889, 3, 464, 232, 0, 3888, 3890, 5, 195, 0, 0, 3889, 3888, 1, 0, + 0, 0, 3889, 3890, 1, 0, 0, 0, 3890, 3894, 1, 0, 0, 0, 3891, 3892, 5, 198, + 0, 0, 3892, 3893, 5, 233, 0, 0, 3893, 3895, 3, 464, 232, 0, 3894, 3891, + 1, 0, 0, 0, 3894, 3895, 1, 0, 0, 0, 3895, 4054, 1, 0, 0, 0, 3896, 3898, + 5, 311, 0, 0, 3897, 3899, 5, 481, 0, 0, 3898, 3897, 1, 0, 0, 0, 3898, 3899, + 1, 0, 0, 0, 3899, 3900, 1, 0, 0, 0, 3900, 3906, 5, 345, 0, 0, 3901, 3907, + 3, 464, 232, 0, 3902, 3907, 3, 316, 158, 0, 3903, 3904, 5, 2, 0, 0, 3904, + 3905, 5, 552, 0, 0, 3905, 3907, 5, 3, 0, 0, 3906, 3901, 1, 0, 0, 0, 3906, + 3902, 1, 0, 0, 0, 3906, 3903, 1, 0, 0, 0, 3907, 3908, 1, 0, 0, 0, 3908, + 3909, 5, 439, 0, 0, 3909, 3910, 5, 2, 0, 0, 3910, 3911, 3, 328, 164, 0, + 3911, 3912, 5, 3, 0, 0, 3912, 4054, 1, 0, 0, 0, 3913, 3915, 5, 399, 0, + 0, 3914, 3916, 3, 164, 82, 0, 3915, 3914, 1, 0, 0, 0, 3915, 3916, 1, 0, + 0, 0, 3916, 3917, 1, 0, 0, 0, 3917, 3919, 5, 537, 0, 0, 3918, 3920, 3, + 164, 82, 0, 3919, 3918, 1, 0, 0, 0, 3919, 3920, 1, 0, 0, 0, 3920, 3922, + 1, 0, 0, 0, 3921, 3923, 5, 195, 0, 0, 3922, 3921, 1, 0, 0, 0, 3922, 3923, + 1, 0, 0, 0, 3923, 3925, 1, 0, 0, 0, 3924, 3926, 3, 326, 163, 0, 3925, 3924, + 1, 0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 4054, 1, 0, 0, 0, 3927, 3928, + 5, 399, 0, 0, 3928, 3929, 5, 537, 0, 0, 3929, 3930, 5, 472, 0, 0, 3930, + 3932, 3, 464, 232, 0, 3931, 3933, 3, 326, 163, 0, 3932, 3931, 1, 0, 0, + 0, 3932, 3933, 1, 0, 0, 0, 3933, 3935, 1, 0, 0, 0, 3934, 3936, 5, 195, + 0, 0, 3935, 3934, 1, 0, 0, 0, 3935, 3936, 1, 0, 0, 0, 3936, 4054, 1, 0, + 0, 0, 3937, 3938, 5, 396, 0, 0, 3938, 4054, 3, 464, 232, 0, 3939, 3940, + 5, 396, 0, 0, 3940, 3941, 5, 420, 0, 0, 3941, 3942, 3, 464, 232, 0, 3942, + 3943, 3, 464, 232, 0, 3943, 4054, 1, 0, 0, 0, 3944, 3945, 5, 396, 0, 0, + 3945, 3946, 5, 345, 0, 0, 3946, 3947, 3, 464, 232, 0, 3947, 3948, 3, 464, + 232, 0, 3948, 4054, 1, 0, 0, 0, 3949, 3950, 5, 396, 0, 0, 3950, 3951, 5, + 83, 0, 0, 3951, 3952, 3, 464, 232, 0, 3952, 3953, 3, 464, 232, 0, 3953, + 4054, 1, 0, 0, 0, 3954, 3955, 5, 14, 0, 0, 3955, 4054, 3, 350, 175, 0, + 3956, 3957, 5, 151, 0, 0, 3957, 3960, 5, 233, 0, 0, 3958, 3959, 5, 228, + 0, 0, 3959, 3961, 5, 175, 0, 0, 3960, 3958, 1, 0, 0, 0, 3960, 3961, 1, + 0, 0, 0, 3961, 3962, 1, 0, 0, 0, 3962, 4054, 3, 464, 232, 0, 3963, 3964, + 5, 159, 0, 0, 3964, 3965, 5, 185, 0, 0, 3965, 3968, 5, 569, 0, 0, 3966, + 3967, 5, 537, 0, 0, 3967, 3969, 3, 326, 163, 0, 3968, 3966, 1, 0, 0, 0, + 3968, 3969, 1, 0, 0, 0, 3969, 4054, 1, 0, 0, 0, 3970, 3971, 5, 311, 0, + 0, 3971, 3986, 5, 146, 0, 0, 3972, 3973, 5, 145, 0, 0, 3973, 3977, 5, 62, + 0, 0, 3974, 3975, 5, 214, 0, 0, 3975, 3978, 3, 316, 158, 0, 3976, 3978, + 5, 384, 0, 0, 3977, 3974, 1, 0, 0, 0, 3977, 3976, 1, 0, 0, 0, 3978, 3984, + 1, 0, 0, 0, 3979, 3982, 5, 58, 0, 0, 3980, 3983, 5, 575, 0, 0, 3981, 3983, + 5, 33, 0, 0, 3982, 3980, 1, 0, 0, 0, 3982, 3981, 1, 0, 0, 0, 3983, 3985, + 1, 0, 0, 0, 3984, 3979, 1, 0, 0, 0, 3984, 3985, 1, 0, 0, 0, 3985, 3987, + 1, 0, 0, 0, 3986, 3972, 1, 0, 0, 0, 3986, 3987, 1, 0, 0, 0, 3987, 4054, + 1, 0, 0, 0, 3988, 3989, 5, 311, 0, 0, 3989, 3990, 5, 85, 0, 0, 3990, 4054, + 5, 569, 0, 0, 3991, 3992, 5, 311, 0, 0, 3992, 3993, 5, 83, 0, 0, 3993, + 3994, 3, 464, 232, 0, 3994, 3995, 5, 85, 0, 0, 3995, 3996, 5, 569, 0, 0, + 3996, 4054, 1, 0, 0, 0, 3997, 3998, 5, 311, 0, 0, 3998, 3999, 5, 165, 0, + 0, 3999, 4000, 5, 489, 0, 0, 4000, 4002, 3, 464, 232, 0, 4001, 4003, 3, + 326, 163, 0, 4002, 4001, 1, 0, 0, 0, 4002, 4003, 1, 0, 0, 0, 4003, 4054, + 1, 0, 0, 0, 4004, 4006, 5, 14, 0, 0, 4005, 4007, 5, 481, 0, 0, 4006, 4005, + 1, 0, 0, 0, 4006, 4007, 1, 0, 0, 0, 4007, 4008, 1, 0, 0, 0, 4008, 4009, + 5, 346, 0, 0, 4009, 4010, 5, 198, 0, 0, 4010, 4011, 3, 364, 182, 0, 4011, + 4012, 5, 489, 0, 0, 4012, 4013, 3, 364, 182, 0, 4013, 4014, 5, 243, 0, + 0, 4014, 4016, 5, 575, 0, 0, 4015, 4017, 3, 464, 232, 0, 4016, 4015, 1, + 0, 0, 0, 4016, 4017, 1, 0, 0, 0, 4017, 4019, 1, 0, 0, 0, 4018, 4020, 3, + 326, 163, 0, 4019, 4018, 1, 0, 0, 0, 4019, 4020, 1, 0, 0, 0, 4020, 4054, + 1, 0, 0, 0, 4021, 4054, 3, 94, 47, 0, 4022, 4054, 3, 96, 48, 0, 4023, 4054, + 3, 110, 55, 0, 4024, 4054, 3, 112, 56, 0, 4025, 4026, 5, 14, 0, 0, 4026, + 4027, 5, 345, 0, 0, 4027, 4028, 5, 259, 0, 0, 4028, 4031, 3, 114, 57, 0, + 4029, 4030, 5, 29, 0, 0, 4030, 4032, 3, 464, 232, 0, 4031, 4029, 1, 0, + 0, 0, 4031, 4032, 1, 0, 0, 0, 4032, 4054, 1, 0, 0, 0, 4033, 4034, 5, 151, + 0, 0, 4034, 4035, 5, 345, 0, 0, 4035, 4038, 5, 259, 0, 0, 4036, 4039, 3, + 464, 232, 0, 4037, 4039, 3, 114, 57, 0, 4038, 4036, 1, 0, 0, 0, 4038, 4037, + 1, 0, 0, 0, 4039, 4054, 1, 0, 0, 0, 4040, 4041, 5, 399, 0, 0, 4041, 4042, + 5, 345, 0, 0, 4042, 4045, 5, 259, 0, 0, 4043, 4046, 3, 464, 232, 0, 4044, + 4046, 3, 114, 57, 0, 4045, 4043, 1, 0, 0, 0, 4045, 4044, 1, 0, 0, 0, 4046, + 4047, 1, 0, 0, 0, 4047, 4048, 5, 537, 0, 0, 4048, 4051, 3, 114, 57, 0, + 4049, 4050, 5, 29, 0, 0, 4050, 4052, 3, 464, 232, 0, 4051, 4049, 1, 0, + 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4054, 1, 0, 0, 0, 4053, 3801, 1, 0, + 0, 0, 4053, 3813, 1, 0, 0, 0, 4053, 3824, 1, 0, 0, 0, 4053, 3833, 1, 0, + 0, 0, 4053, 3845, 1, 0, 0, 0, 4053, 3854, 1, 0, 0, 0, 4053, 3878, 1, 0, + 0, 0, 4053, 3896, 1, 0, 0, 0, 4053, 3913, 1, 0, 0, 0, 4053, 3927, 1, 0, + 0, 0, 4053, 3937, 1, 0, 0, 0, 4053, 3939, 1, 0, 0, 0, 4053, 3944, 1, 0, + 0, 0, 4053, 3949, 1, 0, 0, 0, 4053, 3954, 1, 0, 0, 0, 4053, 3956, 1, 0, + 0, 0, 4053, 3963, 1, 0, 0, 0, 4053, 3970, 1, 0, 0, 0, 4053, 3988, 1, 0, + 0, 0, 4053, 3991, 1, 0, 0, 0, 4053, 3997, 1, 0, 0, 0, 4053, 4004, 1, 0, + 0, 0, 4053, 4021, 1, 0, 0, 0, 4053, 4022, 1, 0, 0, 0, 4053, 4023, 1, 0, + 0, 0, 4053, 4024, 1, 0, 0, 0, 4053, 4025, 1, 0, 0, 0, 4053, 4033, 1, 0, + 0, 0, 4053, 4040, 1, 0, 0, 0, 4054, 93, 1, 0, 0, 0, 4055, 4056, 5, 103, + 0, 0, 4056, 4060, 5, 477, 0, 0, 4057, 4058, 5, 228, 0, 0, 4058, 4059, 5, + 325, 0, 0, 4059, 4061, 5, 175, 0, 0, 4060, 4057, 1, 0, 0, 0, 4060, 4061, + 1, 0, 0, 0, 4061, 4062, 1, 0, 0, 0, 4062, 4063, 3, 464, 232, 0, 4063, 4064, + 3, 98, 49, 0, 4064, 4075, 1, 0, 0, 0, 4065, 4066, 5, 103, 0, 0, 4066, 4068, + 5, 337, 0, 0, 4067, 4065, 1, 0, 0, 0, 4067, 4068, 1, 0, 0, 0, 4068, 4069, + 1, 0, 0, 0, 4069, 4070, 5, 399, 0, 0, 4070, 4071, 5, 477, 0, 0, 4071, 4072, + 3, 464, 232, 0, 4072, 4073, 3, 98, 49, 0, 4073, 4075, 1, 0, 0, 0, 4074, + 4055, 1, 0, 0, 0, 4074, 4067, 1, 0, 0, 0, 4075, 95, 1, 0, 0, 0, 4076, 4077, + 5, 103, 0, 0, 4077, 4081, 5, 55, 0, 0, 4078, 4079, 5, 228, 0, 0, 4079, + 4080, 5, 325, 0, 0, 4080, 4082, 5, 175, 0, 0, 4081, 4078, 1, 0, 0, 0, 4081, + 4082, 1, 0, 0, 0, 4082, 4083, 1, 0, 0, 0, 4083, 4084, 3, 464, 232, 0, 4084, + 4085, 3, 100, 50, 0, 4085, 4096, 1, 0, 0, 0, 4086, 4087, 5, 103, 0, 0, + 4087, 4089, 5, 337, 0, 0, 4088, 4086, 1, 0, 0, 0, 4088, 4089, 1, 0, 0, + 0, 4089, 4090, 1, 0, 0, 0, 4090, 4091, 5, 399, 0, 0, 4091, 4092, 5, 55, + 0, 0, 4092, 4093, 3, 464, 232, 0, 4093, 4094, 3, 100, 50, 0, 4094, 4096, + 1, 0, 0, 0, 4095, 4076, 1, 0, 0, 0, 4095, 4088, 1, 0, 0, 0, 4096, 97, 1, + 0, 0, 0, 4097, 4098, 5, 29, 0, 0, 4098, 4099, 5, 329, 0, 0, 4099, 4100, + 5, 528, 0, 0, 4100, 4102, 5, 575, 0, 0, 4101, 4097, 1, 0, 0, 0, 4101, 4102, + 1, 0, 0, 0, 4102, 4104, 1, 0, 0, 0, 4103, 4105, 3, 102, 51, 0, 4104, 4103, + 1, 0, 0, 0, 4104, 4105, 1, 0, 0, 0, 4105, 99, 1, 0, 0, 0, 4106, 4107, 5, + 29, 0, 0, 4107, 4108, 5, 329, 0, 0, 4108, 4109, 5, 528, 0, 0, 4109, 4111, + 5, 575, 0, 0, 4110, 4106, 1, 0, 0, 0, 4110, 4111, 1, 0, 0, 0, 4111, 4113, + 1, 0, 0, 0, 4112, 4114, 3, 102, 51, 0, 4113, 4112, 1, 0, 0, 0, 4113, 4114, + 1, 0, 0, 0, 4114, 4116, 1, 0, 0, 0, 4115, 4117, 3, 104, 52, 0, 4116, 4115, + 1, 0, 0, 0, 4116, 4117, 1, 0, 0, 0, 4117, 101, 1, 0, 0, 0, 4118, 4119, + 5, 410, 0, 0, 4119, 4120, 3, 108, 54, 0, 4120, 103, 1, 0, 0, 0, 4121, 4122, + 5, 537, 0, 0, 4122, 4123, 5, 447, 0, 0, 4123, 4124, 5, 411, 0, 0, 4124, + 4136, 3, 106, 53, 0, 4125, 4126, 5, 537, 0, 0, 4126, 4127, 5, 447, 0, 0, + 4127, 4128, 5, 411, 0, 0, 4128, 4136, 3, 108, 54, 0, 4129, 4130, 5, 537, + 0, 0, 4130, 4131, 5, 447, 0, 0, 4131, 4132, 5, 411, 0, 0, 4132, 4133, 3, + 106, 53, 0, 4133, 4134, 3, 108, 54, 0, 4134, 4136, 1, 0, 0, 0, 4135, 4121, + 1, 0, 0, 0, 4135, 4125, 1, 0, 0, 0, 4135, 4129, 1, 0, 0, 0, 4136, 105, + 1, 0, 0, 0, 4137, 4138, 5, 575, 0, 0, 4138, 4139, 5, 448, 0, 0, 4139, 107, + 1, 0, 0, 0, 4140, 4141, 5, 575, 0, 0, 4141, 4142, 7, 23, 0, 0, 4142, 109, + 1, 0, 0, 0, 4143, 4144, 5, 151, 0, 0, 4144, 4147, 5, 55, 0, 0, 4145, 4146, + 5, 228, 0, 0, 4146, 4148, 5, 175, 0, 0, 4147, 4145, 1, 0, 0, 0, 4147, 4148, + 1, 0, 0, 0, 4148, 4149, 1, 0, 0, 0, 4149, 4150, 3, 464, 232, 0, 4150, 111, + 1, 0, 0, 0, 4151, 4152, 5, 151, 0, 0, 4152, 4155, 5, 477, 0, 0, 4153, 4154, + 5, 228, 0, 0, 4154, 4156, 5, 175, 0, 0, 4155, 4153, 1, 0, 0, 0, 4155, 4156, + 1, 0, 0, 0, 4156, 4157, 1, 0, 0, 0, 4157, 4158, 3, 464, 232, 0, 4158, 113, + 1, 0, 0, 0, 4159, 4160, 3, 464, 232, 0, 4160, 4161, 5, 2, 0, 0, 4161, 4162, + 5, 575, 0, 0, 4162, 4163, 5, 4, 0, 0, 4163, 4164, 3, 464, 232, 0, 4164, + 4165, 5, 3, 0, 0, 4165, 4173, 1, 0, 0, 0, 4166, 4167, 3, 464, 232, 0, 4167, + 4168, 5, 2, 0, 0, 4168, 4169, 3, 464, 232, 0, 4169, 4170, 5, 3, 0, 0, 4170, + 4173, 1, 0, 0, 0, 4171, 4173, 3, 464, 232, 0, 4172, 4159, 1, 0, 0, 0, 4172, + 4166, 1, 0, 0, 0, 4172, 4171, 1, 0, 0, 0, 4173, 115, 1, 0, 0, 0, 4174, + 4178, 5, 189, 0, 0, 4175, 4176, 5, 16, 0, 0, 4176, 4178, 3, 464, 232, 0, + 4177, 4174, 1, 0, 0, 0, 4177, 4175, 1, 0, 0, 0, 4178, 117, 1, 0, 0, 0, + 4179, 4180, 7, 24, 0, 0, 4180, 4181, 3, 464, 232, 0, 4181, 119, 1, 0, 0, + 0, 4182, 4183, 5, 198, 0, 0, 4183, 4184, 3, 464, 232, 0, 4184, 121, 1, + 0, 0, 0, 4185, 4187, 5, 443, 0, 0, 4186, 4188, 5, 33, 0, 0, 4187, 4186, + 1, 0, 0, 0, 4187, 4188, 1, 0, 0, 0, 4188, 4189, 1, 0, 0, 0, 4189, 4192, + 5, 22, 0, 0, 4190, 4193, 5, 575, 0, 0, 4191, 4193, 3, 338, 169, 0, 4192, + 4190, 1, 0, 0, 0, 4192, 4191, 1, 0, 0, 0, 4192, 4193, 1, 0, 0, 0, 4193, + 4199, 1, 0, 0, 0, 4194, 4195, 5, 535, 0, 0, 4195, 4196, 3, 464, 232, 0, + 4196, 4197, 5, 543, 0, 0, 4197, 4198, 5, 569, 0, 0, 4198, 4200, 1, 0, 0, + 0, 4199, 4194, 1, 0, 0, 0, 4199, 4200, 1, 0, 0, 0, 4200, 4344, 1, 0, 0, + 0, 4201, 4202, 5, 443, 0, 0, 4202, 4203, 5, 380, 0, 0, 4203, 4204, 5, 22, + 0, 0, 4204, 4206, 5, 255, 0, 0, 4205, 4207, 3, 338, 169, 0, 4206, 4205, + 1, 0, 0, 0, 4206, 4207, 1, 0, 0, 0, 4207, 4213, 1, 0, 0, 0, 4208, 4209, + 5, 535, 0, 0, 4209, 4210, 3, 464, 232, 0, 4210, 4211, 5, 543, 0, 0, 4211, + 4212, 5, 569, 0, 0, 4212, 4214, 1, 0, 0, 0, 4213, 4208, 1, 0, 0, 0, 4213, + 4214, 1, 0, 0, 0, 4214, 4344, 1, 0, 0, 0, 4215, 4216, 5, 443, 0, 0, 4216, + 4217, 5, 83, 0, 0, 4217, 4218, 5, 219, 0, 0, 4218, 4219, 3, 338, 169, 0, + 4219, 4220, 3, 316, 158, 0, 4220, 4344, 1, 0, 0, 0, 4221, 4222, 5, 443, + 0, 0, 4222, 4224, 5, 83, 0, 0, 4223, 4225, 5, 64, 0, 0, 4224, 4223, 1, + 0, 0, 0, 4224, 4225, 1, 0, 0, 0, 4225, 4226, 1, 0, 0, 0, 4226, 4227, 5, + 457, 0, 0, 4227, 4229, 3, 338, 169, 0, 4228, 4230, 3, 316, 158, 0, 4229, + 4228, 1, 0, 0, 0, 4229, 4230, 1, 0, 0, 0, 4230, 4232, 1, 0, 0, 0, 4231, + 4233, 3, 164, 82, 0, 4232, 4231, 1, 0, 0, 0, 4232, 4233, 1, 0, 0, 0, 4233, + 4344, 1, 0, 0, 0, 4234, 4235, 5, 443, 0, 0, 4235, 4236, 5, 22, 0, 0, 4236, + 4237, 5, 478, 0, 0, 4237, 4238, 5, 458, 0, 0, 4238, 4344, 5, 575, 0, 0, + 4239, 4240, 5, 22, 0, 0, 4240, 4241, 5, 115, 0, 0, 4241, 4246, 3, 338, + 169, 0, 4242, 4243, 5, 537, 0, 0, 4243, 4245, 3, 124, 62, 0, 4244, 4242, + 1, 0, 0, 0, 4245, 4248, 1, 0, 0, 0, 4246, 4244, 1, 0, 0, 0, 4246, 4247, + 1, 0, 0, 0, 4247, 4250, 1, 0, 0, 0, 4248, 4246, 1, 0, 0, 0, 4249, 4251, + 3, 326, 163, 0, 4250, 4249, 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 4344, + 1, 0, 0, 0, 4252, 4253, 5, 22, 0, 0, 4253, 4254, 5, 472, 0, 0, 4254, 4256, + 3, 338, 169, 0, 4255, 4257, 3, 164, 82, 0, 4256, 4255, 1, 0, 0, 0, 4256, + 4257, 1, 0, 0, 0, 4257, 4259, 1, 0, 0, 0, 4258, 4260, 3, 316, 158, 0, 4259, + 4258, 1, 0, 0, 0, 4259, 4260, 1, 0, 0, 0, 4260, 4265, 1, 0, 0, 0, 4261, + 4262, 5, 537, 0, 0, 4262, 4264, 3, 124, 62, 0, 4263, 4261, 1, 0, 0, 0, + 4264, 4267, 1, 0, 0, 0, 4265, 4263, 1, 0, 0, 0, 4265, 4266, 1, 0, 0, 0, + 4266, 4269, 1, 0, 0, 0, 4267, 4265, 1, 0, 0, 0, 4268, 4270, 3, 326, 163, + 0, 4269, 4268, 1, 0, 0, 0, 4269, 4270, 1, 0, 0, 0, 4270, 4344, 1, 0, 0, + 0, 4271, 4272, 5, 21, 0, 0, 4272, 4273, 5, 472, 0, 0, 4273, 4274, 3, 338, + 169, 0, 4274, 4275, 5, 439, 0, 0, 4275, 4276, 5, 457, 0, 0, 4276, 4277, + 5, 2, 0, 0, 4277, 4278, 3, 328, 164, 0, 4278, 4280, 5, 3, 0, 0, 4279, 4281, + 3, 164, 82, 0, 4280, 4279, 1, 0, 0, 0, 4280, 4281, 1, 0, 0, 0, 4281, 4344, + 1, 0, 0, 0, 4282, 4283, 5, 21, 0, 0, 4283, 4284, 5, 472, 0, 0, 4284, 4287, + 3, 338, 169, 0, 4285, 4286, 5, 233, 0, 0, 4286, 4288, 3, 464, 232, 0, 4287, + 4285, 1, 0, 0, 0, 4287, 4288, 1, 0, 0, 0, 4288, 4289, 1, 0, 0, 0, 4289, + 4290, 5, 311, 0, 0, 4290, 4291, 5, 83, 0, 0, 4291, 4292, 3, 464, 232, 0, + 4292, 4293, 5, 439, 0, 0, 4293, 4294, 5, 457, 0, 0, 4294, 4295, 5, 2, 0, + 0, 4295, 4296, 3, 328, 164, 0, 4296, 4298, 5, 3, 0, 0, 4297, 4299, 3, 164, + 82, 0, 4298, 4297, 1, 0, 0, 0, 4298, 4299, 1, 0, 0, 0, 4299, 4344, 1, 0, + 0, 0, 4300, 4301, 5, 443, 0, 0, 4301, 4302, 5, 233, 0, 0, 4302, 4303, 5, + 457, 0, 0, 4303, 4304, 3, 338, 169, 0, 4304, 4305, 3, 464, 232, 0, 4305, + 4344, 1, 0, 0, 0, 4306, 4307, 5, 151, 0, 0, 4307, 4308, 5, 457, 0, 0, 4308, + 4310, 3, 338, 169, 0, 4309, 4311, 3, 316, 158, 0, 4310, 4309, 1, 0, 0, + 0, 4310, 4311, 1, 0, 0, 0, 4311, 4313, 1, 0, 0, 0, 4312, 4314, 3, 164, + 82, 0, 4313, 4312, 1, 0, 0, 0, 4313, 4314, 1, 0, 0, 0, 4314, 4344, 1, 0, + 0, 0, 4315, 4316, 5, 151, 0, 0, 4316, 4317, 5, 64, 0, 0, 4317, 4318, 5, + 457, 0, 0, 4318, 4344, 3, 338, 169, 0, 4319, 4320, 5, 151, 0, 0, 4320, + 4321, 5, 176, 0, 0, 4321, 4344, 5, 457, 0, 0, 4322, 4323, 5, 261, 0, 0, + 4323, 4324, 5, 22, 0, 0, 4324, 4344, 5, 575, 0, 0, 4325, 4326, 5, 151, + 0, 0, 4326, 4327, 5, 22, 0, 0, 4327, 4328, 5, 254, 0, 0, 4328, 4344, 5, + 575, 0, 0, 4329, 4330, 5, 443, 0, 0, 4330, 4331, 5, 472, 0, 0, 4331, 4332, + 5, 457, 0, 0, 4332, 4334, 3, 338, 169, 0, 4333, 4335, 3, 164, 82, 0, 4334, + 4333, 1, 0, 0, 0, 4334, 4335, 1, 0, 0, 0, 4335, 4337, 1, 0, 0, 0, 4336, + 4338, 3, 316, 158, 0, 4337, 4336, 1, 0, 0, 0, 4337, 4338, 1, 0, 0, 0, 4338, + 4344, 1, 0, 0, 0, 4339, 4340, 5, 443, 0, 0, 4340, 4341, 5, 472, 0, 0, 4341, + 4342, 5, 457, 0, 0, 4342, 4344, 5, 575, 0, 0, 4343, 4185, 1, 0, 0, 0, 4343, + 4201, 1, 0, 0, 0, 4343, 4215, 1, 0, 0, 0, 4343, 4221, 1, 0, 0, 0, 4343, + 4234, 1, 0, 0, 0, 4343, 4239, 1, 0, 0, 0, 4343, 4252, 1, 0, 0, 0, 4343, + 4271, 1, 0, 0, 0, 4343, 4282, 1, 0, 0, 0, 4343, 4300, 1, 0, 0, 0, 4343, + 4306, 1, 0, 0, 0, 4343, 4315, 1, 0, 0, 0, 4343, 4319, 1, 0, 0, 0, 4343, + 4322, 1, 0, 0, 0, 4343, 4325, 1, 0, 0, 0, 4343, 4329, 1, 0, 0, 0, 4343, + 4339, 1, 0, 0, 0, 4344, 123, 1, 0, 0, 0, 4345, 4364, 5, 470, 0, 0, 4346, + 4364, 5, 232, 0, 0, 4347, 4364, 5, 201, 0, 0, 4348, 4364, 5, 451, 0, 0, + 4349, 4364, 5, 219, 0, 0, 4350, 4355, 5, 427, 0, 0, 4351, 4352, 5, 425, + 0, 0, 4352, 4356, 5, 575, 0, 0, 4353, 4354, 5, 354, 0, 0, 4354, 4356, 5, + 575, 0, 0, 4355, 4351, 1, 0, 0, 0, 4355, 4353, 1, 0, 0, 0, 4356, 4364, + 1, 0, 0, 0, 4357, 4358, 5, 58, 0, 0, 4358, 4364, 5, 575, 0, 0, 4359, 4360, + 5, 355, 0, 0, 4360, 4364, 5, 575, 0, 0, 4361, 4362, 5, 105, 0, 0, 4362, + 4364, 5, 569, 0, 0, 4363, 4345, 1, 0, 0, 0, 4363, 4346, 1, 0, 0, 0, 4363, + 4347, 1, 0, 0, 0, 4363, 4348, 1, 0, 0, 0, 4363, 4349, 1, 0, 0, 0, 4363, + 4350, 1, 0, 0, 0, 4363, 4357, 1, 0, 0, 0, 4363, 4359, 1, 0, 0, 0, 4363, + 4361, 1, 0, 0, 0, 4364, 125, 1, 0, 0, 0, 4365, 4370, 3, 128, 64, 0, 4366, + 4367, 5, 4, 0, 0, 4367, 4369, 3, 128, 64, 0, 4368, 4366, 1, 0, 0, 0, 4369, + 4372, 1, 0, 0, 0, 4370, 4368, 1, 0, 0, 0, 4370, 4371, 1, 0, 0, 0, 4371, + 127, 1, 0, 0, 0, 4372, 4370, 1, 0, 0, 0, 4373, 4374, 5, 441, 0, 0, 4374, + 4380, 5, 569, 0, 0, 4375, 4377, 3, 464, 232, 0, 4376, 4378, 5, 569, 0, + 0, 4377, 4376, 1, 0, 0, 0, 4377, 4378, 1, 0, 0, 0, 4378, 4380, 1, 0, 0, + 0, 4379, 4373, 1, 0, 0, 0, 4379, 4375, 1, 0, 0, 0, 4380, 129, 1, 0, 0, + 0, 4381, 4386, 3, 132, 66, 0, 4382, 4383, 5, 4, 0, 0, 4383, 4385, 3, 132, + 66, 0, 4384, 4382, 1, 0, 0, 0, 4385, 4388, 1, 0, 0, 0, 4386, 4384, 1, 0, + 0, 0, 4386, 4387, 1, 0, 0, 0, 4387, 131, 1, 0, 0, 0, 4388, 4386, 1, 0, + 0, 0, 4389, 4390, 3, 464, 232, 0, 4390, 4393, 3, 424, 212, 0, 4391, 4394, + 3, 470, 235, 0, 4392, 4394, 5, 569, 0, 0, 4393, 4391, 1, 0, 0, 0, 4393, + 4392, 1, 0, 0, 0, 4394, 133, 1, 0, 0, 0, 4395, 4397, 7, 25, 0, 0, 4396, + 4398, 3, 464, 232, 0, 4397, 4396, 1, 0, 0, 0, 4397, 4398, 1, 0, 0, 0, 4398, + 4399, 1, 0, 0, 0, 4399, 4400, 5, 331, 0, 0, 4400, 4401, 5, 282, 0, 0, 4401, + 4403, 5, 569, 0, 0, 4402, 4404, 3, 326, 163, 0, 4403, 4402, 1, 0, 0, 0, + 4403, 4404, 1, 0, 0, 0, 4404, 135, 1, 0, 0, 0, 4405, 4408, 5, 349, 0, 0, + 4406, 4409, 5, 131, 0, 0, 4407, 4409, 5, 575, 0, 0, 4408, 4406, 1, 0, 0, + 0, 4408, 4407, 1, 0, 0, 0, 4409, 4411, 1, 0, 0, 0, 4410, 4405, 1, 0, 0, + 0, 4410, 4411, 1, 0, 0, 0, 4411, 4420, 1, 0, 0, 0, 4412, 4418, 5, 348, + 0, 0, 4413, 4419, 5, 131, 0, 0, 4414, 4419, 5, 318, 0, 0, 4415, 4416, 5, + 243, 0, 0, 4416, 4417, 5, 575, 0, 0, 4417, 4419, 7, 26, 0, 0, 4418, 4413, + 1, 0, 0, 0, 4418, 4414, 1, 0, 0, 0, 4418, 4415, 1, 0, 0, 0, 4419, 4421, + 1, 0, 0, 0, 4420, 4412, 1, 0, 0, 0, 4420, 4421, 1, 0, 0, 0, 4421, 4429, + 1, 0, 0, 0, 4422, 4423, 5, 351, 0, 0, 4423, 4427, 5, 243, 0, 0, 4424, 4428, + 5, 131, 0, 0, 4425, 4426, 5, 575, 0, 0, 4426, 4428, 5, 123, 0, 0, 4427, + 4424, 1, 0, 0, 0, 4427, 4425, 1, 0, 0, 0, 4428, 4430, 1, 0, 0, 0, 4429, + 4422, 1, 0, 0, 0, 4429, 4430, 1, 0, 0, 0, 4430, 4433, 1, 0, 0, 0, 4431, + 4432, 5, 182, 0, 0, 4432, 4434, 5, 575, 0, 0, 4433, 4431, 1, 0, 0, 0, 4433, + 4434, 1, 0, 0, 0, 4434, 4441, 1, 0, 0, 0, 4435, 4439, 5, 350, 0, 0, 4436, + 4440, 5, 504, 0, 0, 4437, 4438, 5, 575, 0, 0, 4438, 4440, 7, 26, 0, 0, + 4439, 4436, 1, 0, 0, 0, 4439, 4437, 1, 0, 0, 0, 4440, 4442, 1, 0, 0, 0, + 4441, 4435, 1, 0, 0, 0, 4441, 4442, 1, 0, 0, 0, 4442, 4444, 1, 0, 0, 0, + 4443, 4445, 7, 27, 0, 0, 4444, 4443, 1, 0, 0, 0, 4444, 4445, 1, 0, 0, 0, + 4445, 137, 1, 0, 0, 0, 4446, 4453, 5, 6, 0, 0, 4447, 4453, 3, 140, 70, + 0, 4448, 4449, 3, 140, 70, 0, 4449, 4450, 5, 4, 0, 0, 4450, 4451, 5, 6, + 0, 0, 4451, 4453, 1, 0, 0, 0, 4452, 4446, 1, 0, 0, 0, 4452, 4447, 1, 0, + 0, 0, 4452, 4448, 1, 0, 0, 0, 4453, 139, 1, 0, 0, 0, 4454, 4459, 3, 436, + 218, 0, 4455, 4456, 5, 4, 0, 0, 4456, 4458, 3, 436, 218, 0, 4457, 4455, + 1, 0, 0, 0, 4458, 4461, 1, 0, 0, 0, 4459, 4457, 1, 0, 0, 0, 4459, 4460, + 1, 0, 0, 0, 4460, 141, 1, 0, 0, 0, 4461, 4459, 1, 0, 0, 0, 4462, 4465, + 5, 439, 0, 0, 4463, 4466, 3, 144, 72, 0, 4464, 4466, 3, 146, 73, 0, 4465, + 4463, 1, 0, 0, 0, 4465, 4464, 1, 0, 0, 0, 4466, 4474, 1, 0, 0, 0, 4467, + 4470, 5, 4, 0, 0, 4468, 4471, 3, 144, 72, 0, 4469, 4471, 3, 146, 73, 0, + 4470, 4468, 1, 0, 0, 0, 4470, 4469, 1, 0, 0, 0, 4471, 4473, 1, 0, 0, 0, + 4472, 4467, 1, 0, 0, 0, 4473, 4476, 1, 0, 0, 0, 4474, 4472, 1, 0, 0, 0, + 4474, 4475, 1, 0, 0, 0, 4475, 4509, 1, 0, 0, 0, 4476, 4474, 1, 0, 0, 0, + 4477, 4478, 5, 439, 0, 0, 4478, 4479, 3, 464, 232, 0, 4479, 4480, 5, 29, + 0, 0, 4480, 4481, 5, 131, 0, 0, 4481, 4482, 5, 460, 0, 0, 4482, 4483, 5, + 525, 0, 0, 4483, 4509, 1, 0, 0, 0, 4484, 4485, 5, 439, 0, 0, 4485, 4488, + 5, 376, 0, 0, 4486, 4487, 5, 193, 0, 0, 4487, 4489, 3, 186, 93, 0, 4488, + 4486, 1, 0, 0, 0, 4488, 4489, 1, 0, 0, 0, 4489, 4490, 1, 0, 0, 0, 4490, + 4509, 3, 328, 164, 0, 4491, 4493, 5, 439, 0, 0, 4492, 4494, 3, 174, 87, + 0, 4493, 4492, 1, 0, 0, 0, 4493, 4494, 1, 0, 0, 0, 4494, 4495, 1, 0, 0, + 0, 4495, 4506, 5, 493, 0, 0, 4496, 4507, 3, 150, 75, 0, 4497, 4507, 3, + 152, 76, 0, 4498, 4499, 3, 150, 75, 0, 4499, 4500, 5, 4, 0, 0, 4500, 4501, + 3, 152, 76, 0, 4501, 4507, 1, 0, 0, 0, 4502, 4503, 3, 152, 76, 0, 4503, + 4504, 5, 4, 0, 0, 4504, 4505, 3, 150, 75, 0, 4505, 4507, 1, 0, 0, 0, 4506, + 4496, 1, 0, 0, 0, 4506, 4497, 1, 0, 0, 0, 4506, 4498, 1, 0, 0, 0, 4506, + 4502, 1, 0, 0, 0, 4507, 4509, 1, 0, 0, 0, 4508, 4462, 1, 0, 0, 0, 4508, + 4477, 1, 0, 0, 0, 4508, 4484, 1, 0, 0, 0, 4508, 4491, 1, 0, 0, 0, 4509, + 143, 1, 0, 0, 0, 4510, 4511, 3, 174, 87, 0, 4511, 4512, 3, 464, 232, 0, + 4512, 4517, 5, 543, 0, 0, 4513, 4518, 3, 382, 191, 0, 4514, 4518, 5, 131, + 0, 0, 4515, 4518, 5, 331, 0, 0, 4516, 4518, 5, 20, 0, 0, 4517, 4513, 1, + 0, 0, 0, 4517, 4514, 1, 0, 0, 0, 4517, 4515, 1, 0, 0, 0, 4517, 4516, 1, + 0, 0, 0, 4518, 145, 1, 0, 0, 0, 4519, 4520, 5, 315, 0, 0, 4520, 4521, 5, + 543, 0, 0, 4521, 4565, 3, 382, 191, 0, 4522, 4523, 5, 72, 0, 0, 4523, 4526, + 5, 439, 0, 0, 4524, 4526, 5, 73, 0, 0, 4525, 4522, 1, 0, 0, 0, 4525, 4524, + 1, 0, 0, 0, 4526, 4529, 1, 0, 0, 0, 4527, 4530, 3, 186, 93, 0, 4528, 4530, + 5, 131, 0, 0, 4529, 4527, 1, 0, 0, 0, 4529, 4528, 1, 0, 0, 0, 4530, 4565, + 1, 0, 0, 0, 4531, 4534, 5, 315, 0, 0, 4532, 4535, 3, 186, 93, 0, 4533, + 4535, 5, 131, 0, 0, 4534, 4532, 1, 0, 0, 0, 4534, 4533, 1, 0, 0, 0, 4535, + 4539, 1, 0, 0, 0, 4536, 4537, 5, 79, 0, 0, 4537, 4540, 3, 186, 93, 0, 4538, + 4540, 5, 131, 0, 0, 4539, 4536, 1, 0, 0, 0, 4539, 4538, 1, 0, 0, 0, 4539, + 4540, 1, 0, 0, 0, 4540, 4565, 1, 0, 0, 0, 4541, 4544, 5, 347, 0, 0, 4542, + 4543, 5, 193, 0, 0, 4543, 4545, 3, 194, 97, 0, 4544, 4542, 1, 0, 0, 0, + 4544, 4545, 1, 0, 0, 0, 4545, 4546, 1, 0, 0, 0, 4546, 4552, 5, 543, 0, + 0, 4547, 4553, 5, 569, 0, 0, 4548, 4549, 5, 347, 0, 0, 4549, 4550, 5, 2, + 0, 0, 4550, 4551, 5, 569, 0, 0, 4551, 4553, 5, 3, 0, 0, 4552, 4547, 1, + 0, 0, 0, 4552, 4548, 1, 0, 0, 0, 4553, 4565, 1, 0, 0, 0, 4554, 4555, 5, + 268, 0, 0, 4555, 4561, 5, 543, 0, 0, 4556, 4562, 5, 569, 0, 0, 4557, 4558, + 5, 347, 0, 0, 4558, 4559, 5, 2, 0, 0, 4559, 4560, 5, 569, 0, 0, 4560, 4562, + 5, 3, 0, 0, 4561, 4556, 1, 0, 0, 0, 4561, 4557, 1, 0, 0, 0, 4562, 4565, + 1, 0, 0, 0, 4563, 4565, 3, 148, 74, 0, 4564, 4519, 1, 0, 0, 0, 4564, 4525, + 1, 0, 0, 0, 4564, 4531, 1, 0, 0, 0, 4564, 4541, 1, 0, 0, 0, 4564, 4554, + 1, 0, 0, 0, 4564, 4563, 1, 0, 0, 0, 4565, 147, 1, 0, 0, 0, 4566, 4570, + 5, 568, 0, 0, 4567, 4568, 3, 174, 87, 0, 4568, 4569, 5, 5, 0, 0, 4569, + 4571, 1, 0, 0, 0, 4570, 4567, 1, 0, 0, 0, 4570, 4571, 1, 0, 0, 0, 4571, + 4573, 1, 0, 0, 0, 4572, 4566, 1, 0, 0, 0, 4572, 4573, 1, 0, 0, 0, 4573, + 4574, 1, 0, 0, 0, 4574, 4575, 3, 464, 232, 0, 4575, 4580, 5, 543, 0, 0, + 4576, 4581, 3, 382, 191, 0, 4577, 4581, 5, 131, 0, 0, 4578, 4581, 5, 331, + 0, 0, 4579, 4581, 5, 20, 0, 0, 4580, 4576, 1, 0, 0, 0, 4580, 4577, 1, 0, + 0, 0, 4580, 4578, 1, 0, 0, 0, 4580, 4579, 1, 0, 0, 0, 4581, 4588, 1, 0, + 0, 0, 4582, 4583, 5, 567, 0, 0, 4583, 4584, 3, 464, 232, 0, 4584, 4585, + 5, 543, 0, 0, 4585, 4586, 3, 382, 191, 0, 4586, 4588, 1, 0, 0, 0, 4587, + 4572, 1, 0, 0, 0, 4587, 4582, 1, 0, 0, 0, 4588, 149, 1, 0, 0, 0, 4589, + 4590, 5, 386, 0, 0, 4590, 4591, 7, 28, 0, 0, 4591, 151, 1, 0, 0, 0, 4592, + 4593, 5, 253, 0, 0, 4593, 4601, 5, 272, 0, 0, 4594, 4595, 5, 386, 0, 0, + 4595, 4602, 5, 505, 0, 0, 4596, 4597, 5, 386, 0, 0, 4597, 4602, 5, 87, + 0, 0, 4598, 4599, 5, 398, 0, 0, 4599, 4602, 5, 386, 0, 0, 4600, 4602, 5, + 436, 0, 0, 4601, 4594, 1, 0, 0, 0, 4601, 4596, 1, 0, 0, 0, 4601, 4598, + 1, 0, 0, 0, 4601, 4600, 1, 0, 0, 0, 4602, 153, 1, 0, 0, 0, 4603, 4605, + 5, 510, 0, 0, 4604, 4606, 3, 174, 87, 0, 4605, 4604, 1, 0, 0, 0, 4605, + 4606, 1, 0, 0, 0, 4606, 4607, 1, 0, 0, 0, 4607, 4610, 5, 522, 0, 0, 4608, + 4611, 5, 20, 0, 0, 4609, 4611, 3, 464, 232, 0, 4610, 4608, 1, 0, 0, 0, + 4610, 4609, 1, 0, 0, 0, 4611, 4617, 1, 0, 0, 0, 4612, 4613, 5, 510, 0, + 0, 4613, 4614, 5, 131, 0, 0, 4614, 4615, 5, 460, 0, 0, 4615, 4617, 5, 525, + 0, 0, 4616, 4603, 1, 0, 0, 0, 4616, 4612, 1, 0, 0, 0, 4617, 155, 1, 0, + 0, 0, 4618, 4619, 5, 469, 0, 0, 4619, 4639, 3, 464, 232, 0, 4620, 4624, + 5, 514, 0, 0, 4621, 4622, 3, 464, 232, 0, 4622, 4623, 5, 5, 0, 0, 4623, + 4625, 1, 0, 0, 0, 4624, 4621, 1, 0, 0, 0, 4624, 4625, 1, 0, 0, 0, 4625, + 4626, 1, 0, 0, 0, 4626, 4639, 3, 464, 232, 0, 4627, 4634, 5, 514, 0, 0, + 4628, 4629, 3, 464, 232, 0, 4629, 4630, 5, 5, 0, 0, 4630, 4632, 1, 0, 0, + 0, 4631, 4628, 1, 0, 0, 0, 4631, 4632, 1, 0, 0, 0, 4632, 4633, 1, 0, 0, + 0, 4633, 4635, 3, 464, 232, 0, 4634, 4631, 1, 0, 0, 0, 4634, 4635, 1, 0, + 0, 0, 4635, 4636, 1, 0, 0, 0, 4636, 4637, 5, 567, 0, 0, 4637, 4639, 3, + 464, 232, 0, 4638, 4618, 1, 0, 0, 0, 4638, 4620, 1, 0, 0, 0, 4638, 4627, + 1, 0, 0, 0, 4639, 157, 1, 0, 0, 0, 4640, 4643, 5, 567, 0, 0, 4641, 4644, + 3, 464, 232, 0, 4642, 4644, 5, 555, 0, 0, 4643, 4641, 1, 0, 0, 0, 4643, + 4642, 1, 0, 0, 0, 4644, 4648, 1, 0, 0, 0, 4645, 4646, 5, 2, 0, 0, 4646, + 4647, 5, 569, 0, 0, 4647, 4649, 5, 3, 0, 0, 4648, 4645, 1, 0, 0, 0, 4648, + 4649, 1, 0, 0, 0, 4649, 159, 1, 0, 0, 0, 4650, 4651, 3, 200, 100, 0, 4651, + 4652, 5, 202, 0, 0, 4652, 4653, 3, 464, 232, 0, 4653, 4655, 5, 2, 0, 0, + 4654, 4656, 3, 328, 164, 0, 4655, 4654, 1, 0, 0, 0, 4655, 4656, 1, 0, 0, + 0, 4656, 4657, 1, 0, 0, 0, 4657, 4658, 5, 3, 0, 0, 4658, 4659, 3, 336, + 168, 0, 4659, 4674, 1, 0, 0, 0, 4660, 4661, 3, 200, 100, 0, 4661, 4662, + 3, 338, 169, 0, 4662, 4663, 5, 20, 0, 0, 4663, 4674, 1, 0, 0, 0, 4664, + 4665, 3, 200, 100, 0, 4665, 4667, 3, 338, 169, 0, 4666, 4668, 3, 420, 210, + 0, 4667, 4666, 1, 0, 0, 0, 4667, 4668, 1, 0, 0, 0, 4668, 4674, 1, 0, 0, + 0, 4669, 4670, 3, 200, 100, 0, 4670, 4671, 5, 140, 0, 0, 4671, 4672, 3, + 338, 169, 0, 4672, 4674, 1, 0, 0, 0, 4673, 4650, 1, 0, 0, 0, 4673, 4660, + 1, 0, 0, 0, 4673, 4664, 1, 0, 0, 0, 4673, 4669, 1, 0, 0, 0, 4674, 161, + 1, 0, 0, 0, 4675, 4676, 5, 370, 0, 0, 4676, 4677, 5, 259, 0, 0, 4677, 4688, + 3, 316, 158, 0, 4678, 4679, 5, 508, 0, 0, 4679, 4688, 3, 316, 158, 0, 4680, + 4681, 5, 194, 0, 0, 4681, 4682, 5, 259, 0, 0, 4682, 4683, 3, 316, 158, + 0, 4683, 4684, 5, 393, 0, 0, 4684, 4685, 3, 338, 169, 0, 4685, 4686, 3, + 316, 158, 0, 4686, 4688, 1, 0, 0, 0, 4687, 4675, 1, 0, 0, 0, 4687, 4678, + 1, 0, 0, 0, 4687, 4680, 1, 0, 0, 0, 4688, 163, 1, 0, 0, 0, 4689, 4691, + 5, 481, 0, 0, 4690, 4689, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4692, + 1, 0, 0, 0, 4692, 4693, 7, 29, 0, 0, 4693, 4704, 3, 316, 158, 0, 4694, + 4696, 5, 481, 0, 0, 4695, 4694, 1, 0, 0, 0, 4695, 4696, 1, 0, 0, 0, 4696, + 4697, 1, 0, 0, 0, 4697, 4698, 5, 345, 0, 0, 4698, 4704, 3, 460, 230, 0, + 4699, 4700, 7, 29, 0, 0, 4700, 4701, 5, 2, 0, 0, 4701, 4702, 5, 552, 0, + 0, 4702, 4704, 5, 3, 0, 0, 4703, 4690, 1, 0, 0, 0, 4703, 4695, 1, 0, 0, + 0, 4703, 4699, 1, 0, 0, 0, 4704, 165, 1, 0, 0, 0, 4705, 4707, 5, 33, 0, + 0, 4706, 4705, 1, 0, 0, 0, 4706, 4707, 1, 0, 0, 0, 4707, 4708, 1, 0, 0, + 0, 4708, 4709, 5, 345, 0, 0, 4709, 4711, 5, 62, 0, 0, 4710, 4712, 7, 30, + 0, 0, 4711, 4710, 1, 0, 0, 0, 4711, 4712, 1, 0, 0, 0, 4712, 4713, 1, 0, + 0, 0, 4713, 4714, 3, 168, 84, 0, 4714, 4716, 5, 2, 0, 0, 4715, 4717, 3, + 352, 176, 0, 4716, 4715, 1, 0, 0, 0, 4716, 4717, 1, 0, 0, 0, 4717, 4718, + 1, 0, 0, 0, 4718, 4719, 5, 3, 0, 0, 4719, 167, 1, 0, 0, 0, 4720, 4721, + 5, 2, 0, 0, 4721, 4726, 3, 170, 85, 0, 4722, 4723, 5, 4, 0, 0, 4723, 4725, + 3, 170, 85, 0, 4724, 4722, 1, 0, 0, 0, 4725, 4728, 1, 0, 0, 0, 4726, 4724, + 1, 0, 0, 0, 4726, 4727, 1, 0, 0, 0, 4727, 4729, 1, 0, 0, 0, 4728, 4726, + 1, 0, 0, 0, 4729, 4730, 5, 3, 0, 0, 4730, 169, 1, 0, 0, 0, 4731, 4734, + 3, 464, 232, 0, 4732, 4734, 3, 404, 202, 0, 4733, 4731, 1, 0, 0, 0, 4733, + 4732, 1, 0, 0, 0, 4734, 171, 1, 0, 0, 0, 4735, 4737, 5, 537, 0, 0, 4736, + 4735, 1, 0, 0, 0, 4736, 4737, 1, 0, 0, 0, 4737, 4738, 1, 0, 0, 0, 4738, + 4740, 3, 208, 104, 0, 4739, 4736, 1, 0, 0, 0, 4739, 4740, 1, 0, 0, 0, 4740, + 4741, 1, 0, 0, 0, 4741, 4742, 5, 114, 0, 0, 4742, 4743, 5, 235, 0, 0, 4743, + 4744, 5, 2, 0, 0, 4744, 4749, 5, 569, 0, 0, 4745, 4746, 5, 4, 0, 0, 4746, + 4748, 5, 569, 0, 0, 4747, 4745, 1, 0, 0, 0, 4748, 4751, 1, 0, 0, 0, 4749, + 4747, 1, 0, 0, 0, 4749, 4750, 1, 0, 0, 0, 4750, 4752, 1, 0, 0, 0, 4751, + 4749, 1, 0, 0, 0, 4752, 4754, 5, 3, 0, 0, 4753, 4755, 5, 317, 0, 0, 4754, + 4753, 1, 0, 0, 0, 4754, 4755, 1, 0, 0, 0, 4755, 4756, 1, 0, 0, 0, 4756, + 4757, 5, 244, 0, 0, 4757, 4758, 5, 472, 0, 0, 4758, 4760, 3, 464, 232, + 0, 4759, 4761, 3, 164, 82, 0, 4760, 4759, 1, 0, 0, 0, 4760, 4761, 1, 0, + 0, 0, 4761, 4766, 1, 0, 0, 0, 4762, 4763, 5, 84, 0, 0, 4763, 4764, 5, 482, + 0, 0, 4764, 4765, 5, 62, 0, 0, 4765, 4767, 5, 569, 0, 0, 4766, 4762, 1, + 0, 0, 0, 4766, 4767, 1, 0, 0, 0, 4767, 4772, 1, 0, 0, 0, 4768, 4769, 5, + 275, 0, 0, 4769, 4770, 5, 482, 0, 0, 4770, 4771, 5, 62, 0, 0, 4771, 4773, + 5, 569, 0, 0, 4772, 4768, 1, 0, 0, 0, 4772, 4773, 1, 0, 0, 0, 4773, 4777, + 1, 0, 0, 0, 4774, 4775, 5, 196, 0, 0, 4775, 4776, 5, 29, 0, 0, 4776, 4778, + 3, 186, 93, 0, 4777, 4774, 1, 0, 0, 0, 4777, 4778, 1, 0, 0, 0, 4778, 4782, + 1, 0, 0, 0, 4779, 4780, 5, 90, 0, 0, 4780, 4781, 5, 29, 0, 0, 4781, 4783, + 3, 186, 93, 0, 4782, 4779, 1, 0, 0, 0, 4782, 4783, 1, 0, 0, 0, 4783, 4785, + 1, 0, 0, 0, 4784, 4786, 3, 316, 158, 0, 4785, 4784, 1, 0, 0, 0, 4785, 4786, + 1, 0, 0, 0, 4786, 4788, 1, 0, 0, 0, 4787, 4789, 3, 216, 108, 0, 4788, 4787, + 1, 0, 0, 0, 4788, 4789, 1, 0, 0, 0, 4789, 4791, 1, 0, 0, 0, 4790, 4792, + 3, 218, 109, 0, 4791, 4790, 1, 0, 0, 0, 4791, 4792, 1, 0, 0, 0, 4792, 4794, + 1, 0, 0, 0, 4793, 4795, 3, 210, 105, 0, 4794, 4793, 1, 0, 0, 0, 4794, 4795, + 1, 0, 0, 0, 4795, 4797, 1, 0, 0, 0, 4796, 4798, 3, 252, 126, 0, 4797, 4796, + 1, 0, 0, 0, 4797, 4798, 1, 0, 0, 0, 4798, 4800, 1, 0, 0, 0, 4799, 4801, + 3, 212, 106, 0, 4800, 4799, 1, 0, 0, 0, 4800, 4801, 1, 0, 0, 0, 4801, 4803, + 1, 0, 0, 0, 4802, 4804, 3, 214, 107, 0, 4803, 4802, 1, 0, 0, 0, 4803, 4804, + 1, 0, 0, 0, 4804, 4806, 1, 0, 0, 0, 4805, 4807, 3, 326, 163, 0, 4806, 4805, + 1, 0, 0, 0, 4806, 4807, 1, 0, 0, 0, 4807, 4841, 1, 0, 0, 0, 4808, 4810, + 5, 537, 0, 0, 4809, 4808, 1, 0, 0, 0, 4809, 4810, 1, 0, 0, 0, 4810, 4811, + 1, 0, 0, 0, 4811, 4813, 3, 208, 104, 0, 4812, 4809, 1, 0, 0, 0, 4812, 4813, + 1, 0, 0, 0, 4813, 4814, 1, 0, 0, 0, 4814, 4815, 5, 114, 0, 0, 4815, 4816, + 5, 198, 0, 0, 4816, 4817, 5, 472, 0, 0, 4817, 4819, 3, 464, 232, 0, 4818, + 4820, 5, 317, 0, 0, 4819, 4818, 1, 0, 0, 0, 4819, 4820, 1, 0, 0, 0, 4820, + 4821, 1, 0, 0, 0, 4821, 4822, 5, 244, 0, 0, 4822, 4823, 5, 472, 0, 0, 4823, + 4826, 3, 464, 232, 0, 4824, 4825, 5, 345, 0, 0, 4825, 4827, 3, 316, 158, + 0, 4826, 4824, 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, 4829, 1, 0, 0, + 0, 4828, 4830, 3, 218, 109, 0, 4829, 4828, 1, 0, 0, 0, 4829, 4830, 1, 0, + 0, 0, 4830, 4832, 1, 0, 0, 0, 4831, 4833, 3, 252, 126, 0, 4832, 4831, 1, + 0, 0, 0, 4832, 4833, 1, 0, 0, 0, 4833, 4835, 1, 0, 0, 0, 4834, 4836, 3, + 212, 106, 0, 4835, 4834, 1, 0, 0, 0, 4835, 4836, 1, 0, 0, 0, 4836, 4838, + 1, 0, 0, 0, 4837, 4839, 3, 326, 163, 0, 4838, 4837, 1, 0, 0, 0, 4838, 4839, + 1, 0, 0, 0, 4839, 4841, 1, 0, 0, 0, 4840, 4739, 1, 0, 0, 0, 4840, 4812, + 1, 0, 0, 0, 4841, 173, 1, 0, 0, 0, 4842, 4843, 7, 31, 0, 0, 4843, 175, + 1, 0, 0, 0, 4844, 4845, 5, 59, 0, 0, 4845, 4846, 7, 32, 0, 0, 4846, 177, + 1, 0, 0, 0, 4847, 4848, 5, 331, 0, 0, 4848, 4855, 5, 286, 0, 0, 4849, 4850, + 5, 331, 0, 0, 4850, 4851, 5, 428, 0, 0, 4851, 4855, 3, 180, 90, 0, 4852, + 4853, 5, 331, 0, 0, 4853, 4855, 5, 86, 0, 0, 4854, 4847, 1, 0, 0, 0, 4854, + 4849, 1, 0, 0, 0, 4854, 4852, 1, 0, 0, 0, 4855, 179, 1, 0, 0, 0, 4856, + 4857, 5, 171, 0, 0, 4857, 4858, 5, 575, 0, 0, 4858, 4861, 3, 464, 232, + 0, 4859, 4860, 5, 456, 0, 0, 4860, 4862, 5, 569, 0, 0, 4861, 4859, 1, 0, + 0, 0, 4861, 4862, 1, 0, 0, 0, 4862, 181, 1, 0, 0, 0, 4863, 4864, 7, 33, + 0, 0, 4864, 183, 1, 0, 0, 0, 4865, 4868, 3, 464, 232, 0, 4866, 4868, 3, + 404, 202, 0, 4867, 4865, 1, 0, 0, 0, 4867, 4866, 1, 0, 0, 0, 4868, 185, + 1, 0, 0, 0, 4869, 4872, 3, 464, 232, 0, 4870, 4872, 5, 569, 0, 0, 4871, + 4869, 1, 0, 0, 0, 4871, 4870, 1, 0, 0, 0, 4872, 187, 1, 0, 0, 0, 4873, + 4877, 3, 464, 232, 0, 4874, 4877, 5, 569, 0, 0, 4875, 4877, 5, 552, 0, + 0, 4876, 4873, 1, 0, 0, 0, 4876, 4874, 1, 0, 0, 0, 4876, 4875, 1, 0, 0, + 0, 4877, 189, 1, 0, 0, 0, 4878, 4883, 3, 192, 96, 0, 4879, 4880, 5, 5, + 0, 0, 4880, 4882, 3, 192, 96, 0, 4881, 4879, 1, 0, 0, 0, 4882, 4885, 1, + 0, 0, 0, 4883, 4881, 1, 0, 0, 0, 4883, 4884, 1, 0, 0, 0, 4884, 191, 1, + 0, 0, 0, 4885, 4883, 1, 0, 0, 0, 4886, 4889, 3, 186, 93, 0, 4887, 4889, + 5, 552, 0, 0, 4888, 4886, 1, 0, 0, 0, 4888, 4887, 1, 0, 0, 0, 4889, 193, + 1, 0, 0, 0, 4890, 4899, 3, 186, 93, 0, 4891, 4897, 5, 567, 0, 0, 4892, + 4898, 3, 186, 93, 0, 4893, 4894, 5, 2, 0, 0, 4894, 4895, 3, 186, 93, 0, + 4895, 4896, 5, 3, 0, 0, 4896, 4898, 1, 0, 0, 0, 4897, 4892, 1, 0, 0, 0, + 4897, 4893, 1, 0, 0, 0, 4898, 4900, 1, 0, 0, 0, 4899, 4891, 1, 0, 0, 0, + 4899, 4900, 1, 0, 0, 0, 4900, 195, 1, 0, 0, 0, 4901, 4908, 3, 194, 97, + 0, 4902, 4903, 5, 227, 0, 0, 4903, 4905, 5, 62, 0, 0, 4904, 4906, 5, 347, + 0, 0, 4905, 4904, 1, 0, 0, 0, 4905, 4906, 1, 0, 0, 0, 4906, 4907, 1, 0, + 0, 0, 4907, 4909, 5, 569, 0, 0, 4908, 4902, 1, 0, 0, 0, 4908, 4909, 1, + 0, 0, 0, 4909, 197, 1, 0, 0, 0, 4910, 4912, 3, 200, 100, 0, 4911, 4913, + 3, 202, 101, 0, 4912, 4911, 1, 0, 0, 0, 4912, 4913, 1, 0, 0, 0, 4913, 4915, + 1, 0, 0, 0, 4914, 4916, 7, 34, 0, 0, 4915, 4914, 1, 0, 0, 0, 4915, 4916, + 1, 0, 0, 0, 4916, 4918, 1, 0, 0, 0, 4917, 4919, 5, 363, 0, 0, 4918, 4917, + 1, 0, 0, 0, 4918, 4919, 1, 0, 0, 0, 4919, 199, 1, 0, 0, 0, 4920, 4921, + 7, 35, 0, 0, 4921, 201, 1, 0, 0, 0, 4922, 4923, 7, 36, 0, 0, 4923, 203, + 1, 0, 0, 0, 4924, 4925, 5, 360, 0, 0, 4925, 4926, 5, 401, 0, 0, 4926, 4927, + 3, 206, 103, 0, 4927, 205, 1, 0, 0, 0, 4928, 4929, 5, 154, 0, 0, 4929, + 4933, 3, 232, 116, 0, 4930, 4931, 5, 361, 0, 0, 4931, 4933, 5, 569, 0, + 0, 4932, 4928, 1, 0, 0, 0, 4932, 4930, 1, 0, 0, 0, 4933, 207, 1, 0, 0, + 0, 4934, 4935, 7, 20, 0, 0, 4935, 209, 1, 0, 0, 0, 4936, 4937, 5, 368, + 0, 0, 4937, 4938, 5, 188, 0, 0, 4938, 4939, 3, 382, 191, 0, 4939, 211, + 1, 0, 0, 0, 4940, 4941, 5, 133, 0, 0, 4941, 4942, 5, 331, 0, 0, 4942, 4943, + 3, 382, 191, 0, 4943, 213, 1, 0, 0, 0, 4944, 4945, 5, 338, 0, 0, 4945, + 4946, 5, 62, 0, 0, 4946, 4947, 3, 464, 232, 0, 4947, 215, 1, 0, 0, 0, 4948, + 4949, 5, 84, 0, 0, 4949, 4950, 5, 198, 0, 0, 4950, 4951, 5, 352, 0, 0, + 4951, 4952, 5, 29, 0, 0, 4952, 4953, 3, 316, 158, 0, 4953, 217, 1, 0, 0, + 0, 4954, 4955, 5, 439, 0, 0, 4955, 4956, 5, 2, 0, 0, 4956, 4961, 3, 220, + 110, 0, 4957, 4958, 5, 4, 0, 0, 4958, 4960, 3, 220, 110, 0, 4959, 4957, + 1, 0, 0, 0, 4960, 4963, 1, 0, 0, 0, 4961, 4959, 1, 0, 0, 0, 4961, 4962, + 1, 0, 0, 0, 4962, 4964, 1, 0, 0, 0, 4963, 4961, 1, 0, 0, 0, 4964, 4965, + 5, 3, 0, 0, 4965, 219, 1, 0, 0, 0, 4966, 4967, 3, 464, 232, 0, 4967, 4968, + 5, 543, 0, 0, 4968, 4969, 3, 382, 191, 0, 4969, 221, 1, 0, 0, 0, 4970, + 4999, 3, 224, 112, 0, 4971, 4972, 5, 537, 0, 0, 4972, 4973, 5, 426, 0, + 0, 4973, 4974, 5, 2, 0, 0, 4974, 4975, 3, 328, 164, 0, 4975, 4976, 5, 3, + 0, 0, 4976, 4999, 1, 0, 0, 0, 4977, 4978, 5, 537, 0, 0, 4978, 4979, 5, + 217, 0, 0, 4979, 4980, 5, 2, 0, 0, 4980, 4981, 3, 328, 164, 0, 4981, 4982, + 5, 3, 0, 0, 4982, 4999, 1, 0, 0, 0, 4983, 4984, 5, 537, 0, 0, 4984, 4985, + 5, 279, 0, 0, 4985, 4986, 5, 2, 0, 0, 4986, 4987, 3, 328, 164, 0, 4987, + 4988, 5, 3, 0, 0, 4988, 4999, 1, 0, 0, 0, 4989, 4990, 5, 537, 0, 0, 4990, + 4991, 5, 57, 0, 0, 4991, 4996, 3, 186, 93, 0, 4992, 4993, 5, 2, 0, 0, 4993, + 4994, 3, 328, 164, 0, 4994, 4995, 5, 3, 0, 0, 4995, 4997, 1, 0, 0, 0, 4996, + 4992, 1, 0, 0, 0, 4996, 4997, 1, 0, 0, 0, 4997, 4999, 1, 0, 0, 0, 4998, + 4970, 1, 0, 0, 0, 4998, 4971, 1, 0, 0, 0, 4998, 4977, 1, 0, 0, 0, 4998, + 4983, 1, 0, 0, 0, 4998, 4989, 1, 0, 0, 0, 4999, 223, 1, 0, 0, 0, 5000, + 5001, 5, 537, 0, 0, 5001, 5002, 5, 405, 0, 0, 5002, 5007, 3, 186, 93, 0, + 5003, 5004, 5, 2, 0, 0, 5004, 5005, 3, 328, 164, 0, 5005, 5006, 5, 3, 0, + 0, 5006, 5008, 1, 0, 0, 0, 5007, 5003, 1, 0, 0, 0, 5007, 5008, 1, 0, 0, + 0, 5008, 225, 1, 0, 0, 0, 5009, 5011, 5, 114, 0, 0, 5010, 5012, 5, 279, + 0, 0, 5011, 5010, 1, 0, 0, 0, 5011, 5012, 1, 0, 0, 0, 5012, 5013, 1, 0, + 0, 0, 5013, 5014, 5, 235, 0, 0, 5014, 5015, 5, 569, 0, 0, 5015, 5016, 5, + 244, 0, 0, 5016, 5017, 5, 472, 0, 0, 5017, 5020, 3, 338, 169, 0, 5018, + 5019, 5, 345, 0, 0, 5019, 5021, 3, 316, 158, 0, 5020, 5018, 1, 0, 0, 0, + 5020, 5021, 1, 0, 0, 0, 5021, 5026, 1, 0, 0, 0, 5022, 5023, 5, 84, 0, 0, + 5023, 5024, 5, 482, 0, 0, 5024, 5025, 5, 62, 0, 0, 5025, 5027, 5, 569, + 0, 0, 5026, 5022, 1, 0, 0, 0, 5026, 5027, 1, 0, 0, 0, 5027, 5032, 1, 0, + 0, 0, 5028, 5029, 5, 275, 0, 0, 5029, 5030, 5, 482, 0, 0, 5030, 5031, 5, + 62, 0, 0, 5031, 5033, 5, 569, 0, 0, 5032, 5028, 1, 0, 0, 0, 5032, 5033, + 1, 0, 0, 0, 5033, 5035, 1, 0, 0, 0, 5034, 5036, 3, 228, 114, 0, 5035, 5034, + 1, 0, 0, 0, 5035, 5036, 1, 0, 0, 0, 5036, 5038, 1, 0, 0, 0, 5037, 5039, + 3, 316, 158, 0, 5038, 5037, 1, 0, 0, 0, 5038, 5039, 1, 0, 0, 0, 5039, 5041, + 1, 0, 0, 0, 5040, 5042, 3, 218, 109, 0, 5041, 5040, 1, 0, 0, 0, 5041, 5042, + 1, 0, 0, 0, 5042, 5044, 1, 0, 0, 0, 5043, 5045, 3, 326, 163, 0, 5044, 5043, + 1, 0, 0, 0, 5044, 5045, 1, 0, 0, 0, 5045, 227, 1, 0, 0, 0, 5046, 5047, + 5, 229, 0, 0, 5047, 5048, 5, 575, 0, 0, 5048, 5053, 5, 275, 0, 0, 5049, + 5050, 5, 229, 0, 0, 5050, 5051, 5, 575, 0, 0, 5051, 5053, 5, 425, 0, 0, + 5052, 5046, 1, 0, 0, 0, 5052, 5049, 1, 0, 0, 0, 5053, 229, 1, 0, 0, 0, + 5054, 5055, 5, 244, 0, 0, 5055, 5056, 5, 340, 0, 0, 5056, 5060, 3, 422, + 211, 0, 5057, 5058, 5, 196, 0, 0, 5058, 5059, 5, 29, 0, 0, 5059, 5061, + 3, 464, 232, 0, 5060, 5057, 1, 0, 0, 0, 5060, 5061, 1, 0, 0, 0, 5061, 5063, + 1, 0, 0, 0, 5062, 5064, 3, 326, 163, 0, 5063, 5062, 1, 0, 0, 0, 5063, 5064, + 1, 0, 0, 0, 5064, 231, 1, 0, 0, 0, 5065, 5067, 3, 242, 121, 0, 5066, 5065, + 1, 0, 0, 0, 5066, 5067, 1, 0, 0, 0, 5067, 5068, 1, 0, 0, 0, 5068, 5069, + 3, 234, 117, 0, 5069, 5070, 3, 302, 151, 0, 5070, 233, 1, 0, 0, 0, 5071, + 5072, 6, 117, -1, 0, 5072, 5073, 3, 238, 119, 0, 5073, 5088, 1, 0, 0, 0, + 5074, 5075, 10, 2, 0, 0, 5075, 5077, 5, 242, 0, 0, 5076, 5078, 3, 236, + 118, 0, 5077, 5076, 1, 0, 0, 0, 5077, 5078, 1, 0, 0, 0, 5078, 5079, 1, + 0, 0, 0, 5079, 5087, 3, 234, 117, 3, 5080, 5081, 10, 1, 0, 0, 5081, 5083, + 7, 37, 0, 0, 5082, 5084, 3, 236, 118, 0, 5083, 5082, 1, 0, 0, 0, 5083, + 5084, 1, 0, 0, 0, 5084, 5085, 1, 0, 0, 0, 5085, 5087, 3, 234, 117, 2, 5086, + 5074, 1, 0, 0, 0, 5086, 5080, 1, 0, 0, 0, 5087, 5090, 1, 0, 0, 0, 5088, + 5086, 1, 0, 0, 0, 5088, 5089, 1, 0, 0, 0, 5089, 235, 1, 0, 0, 0, 5090, + 5088, 1, 0, 0, 0, 5091, 5092, 7, 38, 0, 0, 5092, 237, 1, 0, 0, 0, 5093, + 5100, 3, 240, 120, 0, 5094, 5095, 5, 2, 0, 0, 5095, 5096, 3, 232, 116, + 0, 5096, 5097, 5, 3, 0, 0, 5097, 5100, 1, 0, 0, 0, 5098, 5100, 3, 376, + 188, 0, 5099, 5093, 1, 0, 0, 0, 5099, 5094, 1, 0, 0, 0, 5099, 5098, 1, + 0, 0, 0, 5100, 239, 1, 0, 0, 0, 5101, 5103, 3, 248, 124, 0, 5102, 5104, + 3, 256, 128, 0, 5103, 5102, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5106, + 1, 0, 0, 0, 5105, 5107, 3, 254, 127, 0, 5106, 5105, 1, 0, 0, 0, 5106, 5107, + 1, 0, 0, 0, 5107, 5109, 1, 0, 0, 0, 5108, 5110, 3, 252, 126, 0, 5109, 5108, + 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0, 5110, 5112, 1, 0, 0, 0, 5111, 5113, + 3, 278, 139, 0, 5112, 5111, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, 5113, 5115, + 1, 0, 0, 0, 5114, 5116, 3, 284, 142, 0, 5115, 5114, 1, 0, 0, 0, 5115, 5116, + 1, 0, 0, 0, 5116, 5118, 1, 0, 0, 0, 5117, 5119, 3, 286, 143, 0, 5118, 5117, + 1, 0, 0, 0, 5118, 5119, 1, 0, 0, 0, 5119, 5121, 1, 0, 0, 0, 5120, 5122, + 3, 302, 151, 0, 5121, 5120, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 241, + 1, 0, 0, 0, 5123, 5124, 5, 537, 0, 0, 5124, 5129, 3, 244, 122, 0, 5125, + 5126, 5, 4, 0, 0, 5126, 5128, 3, 244, 122, 0, 5127, 5125, 1, 0, 0, 0, 5128, + 5131, 1, 0, 0, 0, 5129, 5127, 1, 0, 0, 0, 5129, 5130, 1, 0, 0, 0, 5130, + 243, 1, 0, 0, 0, 5131, 5129, 1, 0, 0, 0, 5132, 5134, 3, 464, 232, 0, 5133, + 5135, 3, 246, 123, 0, 5134, 5133, 1, 0, 0, 0, 5134, 5135, 1, 0, 0, 0, 5135, + 5136, 1, 0, 0, 0, 5136, 5137, 5, 29, 0, 0, 5137, 5138, 5, 2, 0, 0, 5138, + 5139, 3, 232, 116, 0, 5139, 5140, 5, 3, 0, 0, 5140, 245, 1, 0, 0, 0, 5141, + 5142, 5, 2, 0, 0, 5142, 5147, 3, 464, 232, 0, 5143, 5144, 5, 4, 0, 0, 5144, + 5146, 3, 464, 232, 0, 5145, 5143, 1, 0, 0, 0, 5146, 5149, 1, 0, 0, 0, 5147, + 5145, 1, 0, 0, 0, 5147, 5148, 1, 0, 0, 0, 5148, 5150, 1, 0, 0, 0, 5149, + 5147, 1, 0, 0, 0, 5150, 5151, 5, 3, 0, 0, 5151, 247, 1, 0, 0, 0, 5152, + 5154, 5, 433, 0, 0, 5153, 5155, 7, 38, 0, 0, 5154, 5153, 1, 0, 0, 0, 5154, + 5155, 1, 0, 0, 0, 5155, 5156, 1, 0, 0, 0, 5156, 5157, 3, 250, 125, 0, 5157, + 249, 1, 0, 0, 0, 5158, 5159, 3, 380, 190, 0, 5159, 251, 1, 0, 0, 0, 5160, + 5161, 5, 535, 0, 0, 5161, 5162, 3, 388, 194, 0, 5162, 253, 1, 0, 0, 0, + 5163, 5164, 5, 198, 0, 0, 5164, 5165, 3, 262, 131, 0, 5165, 255, 1, 0, + 0, 0, 5166, 5168, 3, 258, 129, 0, 5167, 5166, 1, 0, 0, 0, 5167, 5168, 1, + 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, 5172, 5, 244, 0, 0, 5170, 5173, + 3, 260, 130, 0, 5171, 5173, 3, 464, 232, 0, 5172, 5170, 1, 0, 0, 0, 5172, + 5171, 1, 0, 0, 0, 5173, 5181, 1, 0, 0, 0, 5174, 5177, 5, 4, 0, 0, 5175, + 5178, 3, 260, 130, 0, 5176, 5178, 3, 464, 232, 0, 5177, 5175, 1, 0, 0, + 0, 5177, 5176, 1, 0, 0, 0, 5178, 5180, 1, 0, 0, 0, 5179, 5174, 1, 0, 0, + 0, 5180, 5183, 1, 0, 0, 0, 5181, 5179, 1, 0, 0, 0, 5181, 5182, 1, 0, 0, + 0, 5182, 257, 1, 0, 0, 0, 5183, 5181, 1, 0, 0, 0, 5184, 5185, 5, 61, 0, + 0, 5185, 5186, 5, 81, 0, 0, 5186, 259, 1, 0, 0, 0, 5187, 5188, 3, 464, + 232, 0, 5188, 5189, 5, 2, 0, 0, 5189, 5190, 5, 575, 0, 0, 5190, 5191, 5, + 3, 0, 0, 5191, 261, 1, 0, 0, 0, 5192, 5197, 3, 264, 132, 0, 5193, 5194, + 5, 4, 0, 0, 5194, 5196, 3, 264, 132, 0, 5195, 5193, 1, 0, 0, 0, 5196, 5199, + 1, 0, 0, 0, 5197, 5195, 1, 0, 0, 0, 5197, 5198, 1, 0, 0, 0, 5198, 263, + 1, 0, 0, 0, 5199, 5197, 1, 0, 0, 0, 5200, 5204, 3, 322, 161, 0, 5201, 5203, + 3, 266, 133, 0, 5202, 5201, 1, 0, 0, 0, 5203, 5206, 1, 0, 0, 0, 5204, 5202, + 1, 0, 0, 0, 5204, 5205, 1, 0, 0, 0, 5205, 265, 1, 0, 0, 0, 5206, 5204, + 1, 0, 0, 0, 5207, 5208, 3, 312, 156, 0, 5208, 5210, 5, 256, 0, 0, 5209, + 5211, 3, 268, 134, 0, 5210, 5209, 1, 0, 0, 0, 5210, 5211, 1, 0, 0, 0, 5211, + 5212, 1, 0, 0, 0, 5212, 5214, 3, 322, 161, 0, 5213, 5215, 3, 314, 157, + 0, 5214, 5213, 1, 0, 0, 0, 5214, 5215, 1, 0, 0, 0, 5215, 267, 1, 0, 0, + 0, 5216, 5217, 5, 7, 0, 0, 5217, 5219, 3, 464, 232, 0, 5218, 5220, 3, 270, + 135, 0, 5219, 5218, 1, 0, 0, 0, 5219, 5220, 1, 0, 0, 0, 5220, 5221, 1, + 0, 0, 0, 5221, 5222, 5, 8, 0, 0, 5222, 5231, 1, 0, 0, 0, 5223, 5224, 5, + 564, 0, 0, 5224, 5226, 3, 464, 232, 0, 5225, 5227, 3, 270, 135, 0, 5226, + 5225, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0, 5227, 5228, 1, 0, 0, 0, 5228, + 5229, 5, 565, 0, 0, 5229, 5231, 1, 0, 0, 0, 5230, 5216, 1, 0, 0, 0, 5230, + 5223, 1, 0, 0, 0, 5231, 269, 1, 0, 0, 0, 5232, 5233, 5, 7, 0, 0, 5233, + 5234, 3, 464, 232, 0, 5234, 5235, 5, 2, 0, 0, 5235, 5236, 3, 418, 209, + 0, 5236, 5237, 3, 272, 136, 0, 5237, 5238, 5, 3, 0, 0, 5238, 5239, 5, 8, + 0, 0, 5239, 271, 1, 0, 0, 0, 5240, 5241, 5, 2, 0, 0, 5241, 5246, 3, 422, + 211, 0, 5242, 5243, 5, 4, 0, 0, 5243, 5245, 3, 422, 211, 0, 5244, 5242, + 1, 0, 0, 0, 5245, 5248, 1, 0, 0, 0, 5246, 5244, 1, 0, 0, 0, 5246, 5247, + 1, 0, 0, 0, 5247, 5249, 1, 0, 0, 0, 5248, 5246, 1, 0, 0, 0, 5249, 5250, + 5, 3, 0, 0, 5250, 273, 1, 0, 0, 0, 5251, 5252, 5, 7, 0, 0, 5252, 5257, + 3, 464, 232, 0, 5253, 5254, 5, 4, 0, 0, 5254, 5256, 3, 464, 232, 0, 5255, + 5253, 1, 0, 0, 0, 5256, 5259, 1, 0, 0, 0, 5257, 5255, 1, 0, 0, 0, 5257, + 5258, 1, 0, 0, 0, 5258, 5260, 1, 0, 0, 0, 5259, 5257, 1, 0, 0, 0, 5260, + 5261, 5, 8, 0, 0, 5261, 5274, 1, 0, 0, 0, 5262, 5263, 5, 564, 0, 0, 5263, + 5268, 3, 464, 232, 0, 5264, 5265, 5, 4, 0, 0, 5265, 5267, 3, 464, 232, + 0, 5266, 5264, 1, 0, 0, 0, 5267, 5270, 1, 0, 0, 0, 5268, 5266, 1, 0, 0, + 0, 5268, 5269, 1, 0, 0, 0, 5269, 5271, 1, 0, 0, 0, 5270, 5268, 1, 0, 0, + 0, 5271, 5272, 5, 565, 0, 0, 5272, 5274, 1, 0, 0, 0, 5273, 5251, 1, 0, + 0, 0, 5273, 5262, 1, 0, 0, 0, 5274, 275, 1, 0, 0, 0, 5275, 5277, 3, 382, + 191, 0, 5276, 5278, 7, 39, 0, 0, 5277, 5276, 1, 0, 0, 0, 5277, 5278, 1, + 0, 0, 0, 5278, 277, 1, 0, 0, 0, 5279, 5280, 5, 210, 0, 0, 5280, 5281, 5, + 62, 0, 0, 5281, 5282, 3, 280, 140, 0, 5282, 279, 1, 0, 0, 0, 5283, 5284, + 5, 420, 0, 0, 5284, 5293, 5, 2, 0, 0, 5285, 5290, 3, 382, 191, 0, 5286, + 5287, 5, 4, 0, 0, 5287, 5289, 3, 382, 191, 0, 5288, 5286, 1, 0, 0, 0, 5289, + 5292, 1, 0, 0, 0, 5290, 5288, 1, 0, 0, 0, 5290, 5291, 1, 0, 0, 0, 5291, + 5294, 1, 0, 0, 0, 5292, 5290, 1, 0, 0, 0, 5293, 5285, 1, 0, 0, 0, 5293, + 5294, 1, 0, 0, 0, 5294, 5295, 1, 0, 0, 0, 5295, 5335, 5, 3, 0, 0, 5296, + 5297, 5, 107, 0, 0, 5297, 5306, 5, 2, 0, 0, 5298, 5303, 3, 382, 191, 0, + 5299, 5300, 5, 4, 0, 0, 5300, 5302, 3, 382, 191, 0, 5301, 5299, 1, 0, 0, + 0, 5302, 5305, 1, 0, 0, 0, 5303, 5301, 1, 0, 0, 0, 5303, 5304, 1, 0, 0, + 0, 5304, 5307, 1, 0, 0, 0, 5305, 5303, 1, 0, 0, 0, 5306, 5298, 1, 0, 0, + 0, 5306, 5307, 1, 0, 0, 0, 5307, 5308, 1, 0, 0, 0, 5308, 5335, 5, 3, 0, + 0, 5309, 5310, 5, 211, 0, 0, 5310, 5311, 5, 440, 0, 0, 5311, 5312, 5, 2, + 0, 0, 5312, 5317, 3, 282, 141, 0, 5313, 5314, 5, 4, 0, 0, 5314, 5316, 3, + 282, 141, 0, 5315, 5313, 1, 0, 0, 0, 5316, 5319, 1, 0, 0, 0, 5317, 5315, + 1, 0, 0, 0, 5317, 5318, 1, 0, 0, 0, 5318, 5320, 1, 0, 0, 0, 5319, 5317, + 1, 0, 0, 0, 5320, 5321, 5, 3, 0, 0, 5321, 5335, 1, 0, 0, 0, 5322, 5327, + 3, 276, 138, 0, 5323, 5324, 5, 4, 0, 0, 5324, 5326, 3, 276, 138, 0, 5325, + 5323, 1, 0, 0, 0, 5326, 5329, 1, 0, 0, 0, 5327, 5325, 1, 0, 0, 0, 5327, + 5328, 1, 0, 0, 0, 5328, 5332, 1, 0, 0, 0, 5329, 5327, 1, 0, 0, 0, 5330, + 5331, 5, 537, 0, 0, 5331, 5333, 5, 420, 0, 0, 5332, 5330, 1, 0, 0, 0, 5332, + 5333, 1, 0, 0, 0, 5333, 5335, 1, 0, 0, 0, 5334, 5283, 1, 0, 0, 0, 5334, + 5296, 1, 0, 0, 0, 5334, 5309, 1, 0, 0, 0, 5334, 5322, 1, 0, 0, 0, 5335, + 281, 1, 0, 0, 0, 5336, 5345, 5, 2, 0, 0, 5337, 5342, 3, 382, 191, 0, 5338, + 5339, 5, 4, 0, 0, 5339, 5341, 3, 382, 191, 0, 5340, 5338, 1, 0, 0, 0, 5341, + 5344, 1, 0, 0, 0, 5342, 5340, 1, 0, 0, 0, 5342, 5343, 1, 0, 0, 0, 5343, + 5346, 1, 0, 0, 0, 5344, 5342, 1, 0, 0, 0, 5345, 5337, 1, 0, 0, 0, 5345, + 5346, 1, 0, 0, 0, 5346, 5347, 1, 0, 0, 0, 5347, 5348, 5, 3, 0, 0, 5348, + 283, 1, 0, 0, 0, 5349, 5350, 5, 216, 0, 0, 5350, 5351, 3, 388, 194, 0, + 5351, 285, 1, 0, 0, 0, 5352, 5353, 5, 382, 0, 0, 5353, 5354, 3, 388, 194, + 0, 5354, 287, 1, 0, 0, 0, 5355, 5362, 3, 290, 145, 0, 5356, 5358, 5, 4, + 0, 0, 5357, 5356, 1, 0, 0, 0, 5357, 5358, 1, 0, 0, 0, 5358, 5359, 1, 0, + 0, 0, 5359, 5361, 3, 290, 145, 0, 5360, 5357, 1, 0, 0, 0, 5361, 5364, 1, + 0, 0, 0, 5362, 5360, 1, 0, 0, 0, 5362, 5363, 1, 0, 0, 0, 5363, 5365, 1, + 0, 0, 0, 5364, 5362, 1, 0, 0, 0, 5365, 5366, 5, 565, 0, 0, 5366, 289, 1, + 0, 0, 0, 5367, 5381, 3, 292, 146, 0, 5368, 5369, 5, 2, 0, 0, 5369, 5376, + 3, 294, 147, 0, 5370, 5372, 5, 4, 0, 0, 5371, 5370, 1, 0, 0, 0, 5371, 5372, + 1, 0, 0, 0, 5372, 5373, 1, 0, 0, 0, 5373, 5375, 3, 294, 147, 0, 5374, 5371, + 1, 0, 0, 0, 5375, 5378, 1, 0, 0, 0, 5376, 5374, 1, 0, 0, 0, 5376, 5377, + 1, 0, 0, 0, 5377, 5379, 1, 0, 0, 0, 5378, 5376, 1, 0, 0, 0, 5379, 5380, + 5, 3, 0, 0, 5380, 5382, 1, 0, 0, 0, 5381, 5368, 1, 0, 0, 0, 5381, 5382, + 1, 0, 0, 0, 5382, 5398, 1, 0, 0, 0, 5383, 5395, 7, 40, 0, 0, 5384, 5385, + 5, 2, 0, 0, 5385, 5390, 3, 338, 169, 0, 5386, 5387, 5, 4, 0, 0, 5387, 5389, + 3, 338, 169, 0, 5388, 5386, 1, 0, 0, 0, 5389, 5392, 1, 0, 0, 0, 5390, 5388, + 1, 0, 0, 0, 5390, 5391, 1, 0, 0, 0, 5391, 5393, 1, 0, 0, 0, 5392, 5390, + 1, 0, 0, 0, 5393, 5394, 5, 3, 0, 0, 5394, 5396, 1, 0, 0, 0, 5395, 5384, + 1, 0, 0, 0, 5395, 5396, 1, 0, 0, 0, 5396, 5398, 1, 0, 0, 0, 5397, 5367, + 1, 0, 0, 0, 5397, 5383, 1, 0, 0, 0, 5398, 291, 1, 0, 0, 0, 5399, 5402, + 3, 464, 232, 0, 5400, 5402, 5, 269, 0, 0, 5401, 5399, 1, 0, 0, 0, 5401, + 5400, 1, 0, 0, 0, 5402, 293, 1, 0, 0, 0, 5403, 5405, 3, 186, 93, 0, 5404, + 5406, 3, 270, 135, 0, 5405, 5404, 1, 0, 0, 0, 5405, 5406, 1, 0, 0, 0, 5406, + 5412, 1, 0, 0, 0, 5407, 5410, 5, 543, 0, 0, 5408, 5411, 3, 422, 211, 0, + 5409, 5411, 3, 464, 232, 0, 5410, 5408, 1, 0, 0, 0, 5410, 5409, 1, 0, 0, + 0, 5411, 5413, 1, 0, 0, 0, 5412, 5407, 1, 0, 0, 0, 5412, 5413, 1, 0, 0, + 0, 5413, 5416, 1, 0, 0, 0, 5414, 5416, 3, 422, 211, 0, 5415, 5403, 1, 0, + 0, 0, 5415, 5414, 1, 0, 0, 0, 5416, 295, 1, 0, 0, 0, 5417, 5418, 3, 338, + 169, 0, 5418, 5421, 5, 543, 0, 0, 5419, 5422, 3, 382, 191, 0, 5420, 5422, + 5, 131, 0, 0, 5421, 5419, 1, 0, 0, 0, 5421, 5420, 1, 0, 0, 0, 5422, 297, + 1, 0, 0, 0, 5423, 5428, 3, 296, 148, 0, 5424, 5425, 5, 4, 0, 0, 5425, 5427, + 3, 296, 148, 0, 5426, 5424, 1, 0, 0, 0, 5427, 5430, 1, 0, 0, 0, 5428, 5426, + 1, 0, 0, 0, 5428, 5429, 1, 0, 0, 0, 5429, 299, 1, 0, 0, 0, 5430, 5428, + 1, 0, 0, 0, 5431, 5432, 5, 266, 0, 0, 5432, 5433, 5, 529, 0, 0, 5433, 5434, + 3, 464, 232, 0, 5434, 5443, 5, 2, 0, 0, 5435, 5440, 3, 382, 191, 0, 5436, + 5437, 5, 4, 0, 0, 5437, 5439, 3, 382, 191, 0, 5438, 5436, 1, 0, 0, 0, 5439, + 5442, 1, 0, 0, 0, 5440, 5438, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, + 5444, 1, 0, 0, 0, 5442, 5440, 1, 0, 0, 0, 5443, 5435, 1, 0, 0, 0, 5443, + 5444, 1, 0, 0, 0, 5444, 5445, 1, 0, 0, 0, 5445, 5446, 5, 3, 0, 0, 5446, + 5447, 3, 464, 232, 0, 5447, 5448, 5, 29, 0, 0, 5448, 5453, 3, 464, 232, + 0, 5449, 5450, 5, 4, 0, 0, 5450, 5452, 3, 464, 232, 0, 5451, 5449, 1, 0, + 0, 0, 5452, 5455, 1, 0, 0, 0, 5453, 5451, 1, 0, 0, 0, 5453, 5454, 1, 0, + 0, 0, 5454, 301, 1, 0, 0, 0, 5455, 5453, 1, 0, 0, 0, 5456, 5458, 3, 304, + 152, 0, 5457, 5456, 1, 0, 0, 0, 5457, 5458, 1, 0, 0, 0, 5458, 5460, 1, + 0, 0, 0, 5459, 5461, 3, 308, 154, 0, 5460, 5459, 1, 0, 0, 0, 5460, 5461, + 1, 0, 0, 0, 5461, 303, 1, 0, 0, 0, 5462, 5463, 5, 338, 0, 0, 5463, 5464, + 5, 62, 0, 0, 5464, 5469, 3, 306, 153, 0, 5465, 5466, 5, 4, 0, 0, 5466, + 5468, 3, 306, 153, 0, 5467, 5465, 1, 0, 0, 0, 5468, 5471, 1, 0, 0, 0, 5469, + 5467, 1, 0, 0, 0, 5469, 5470, 1, 0, 0, 0, 5470, 305, 1, 0, 0, 0, 5471, + 5469, 1, 0, 0, 0, 5472, 5474, 3, 382, 191, 0, 5473, 5475, 7, 39, 0, 0, + 5474, 5473, 1, 0, 0, 0, 5474, 5475, 1, 0, 0, 0, 5475, 5478, 1, 0, 0, 0, + 5476, 5477, 5, 327, 0, 0, 5477, 5479, 7, 41, 0, 0, 5478, 5476, 1, 0, 0, + 0, 5478, 5479, 1, 0, 0, 0, 5479, 307, 1, 0, 0, 0, 5480, 5481, 5, 274, 0, + 0, 5481, 5491, 5, 575, 0, 0, 5482, 5483, 5, 274, 0, 0, 5483, 5484, 5, 575, + 0, 0, 5484, 5485, 5, 330, 0, 0, 5485, 5491, 5, 575, 0, 0, 5486, 5487, 5, + 274, 0, 0, 5487, 5488, 5, 575, 0, 0, 5488, 5489, 5, 4, 0, 0, 5489, 5491, + 5, 575, 0, 0, 5490, 5480, 1, 0, 0, 0, 5490, 5482, 1, 0, 0, 0, 5490, 5486, + 1, 0, 0, 0, 5491, 309, 1, 0, 0, 0, 5492, 5493, 5, 345, 0, 0, 5493, 5498, + 5, 62, 0, 0, 5494, 5495, 5, 7, 0, 0, 5495, 5496, 3, 464, 232, 0, 5496, + 5497, 5, 8, 0, 0, 5497, 5499, 1, 0, 0, 0, 5498, 5494, 1, 0, 0, 0, 5498, + 5499, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5505, 3, 382, 191, 0, 5501, + 5502, 5, 4, 0, 0, 5502, 5504, 3, 382, 191, 0, 5503, 5501, 1, 0, 0, 0, 5504, + 5507, 1, 0, 0, 0, 5505, 5503, 1, 0, 0, 0, 5505, 5506, 1, 0, 0, 0, 5506, + 311, 1, 0, 0, 0, 5507, 5505, 1, 0, 0, 0, 5508, 5510, 5, 236, 0, 0, 5509, + 5508, 1, 0, 0, 0, 5509, 5510, 1, 0, 0, 0, 5510, 5533, 1, 0, 0, 0, 5511, + 5533, 5, 106, 0, 0, 5512, 5514, 5, 270, 0, 0, 5513, 5515, 5, 339, 0, 0, + 5514, 5513, 1, 0, 0, 0, 5514, 5515, 1, 0, 0, 0, 5515, 5533, 1, 0, 0, 0, + 5516, 5518, 5, 415, 0, 0, 5517, 5519, 5, 339, 0, 0, 5518, 5517, 1, 0, 0, + 0, 5518, 5519, 1, 0, 0, 0, 5519, 5533, 1, 0, 0, 0, 5520, 5522, 5, 201, + 0, 0, 5521, 5523, 5, 339, 0, 0, 5522, 5521, 1, 0, 0, 0, 5522, 5523, 1, + 0, 0, 0, 5523, 5533, 1, 0, 0, 0, 5524, 5525, 5, 270, 0, 0, 5525, 5533, + 5, 434, 0, 0, 5526, 5527, 5, 415, 0, 0, 5527, 5533, 5, 434, 0, 0, 5528, + 5529, 5, 270, 0, 0, 5529, 5533, 5, 26, 0, 0, 5530, 5531, 5, 415, 0, 0, + 5531, 5533, 5, 26, 0, 0, 5532, 5509, 1, 0, 0, 0, 5532, 5511, 1, 0, 0, 0, + 5532, 5512, 1, 0, 0, 0, 5532, 5516, 1, 0, 0, 0, 5532, 5520, 1, 0, 0, 0, + 5532, 5524, 1, 0, 0, 0, 5532, 5526, 1, 0, 0, 0, 5532, 5528, 1, 0, 0, 0, + 5532, 5530, 1, 0, 0, 0, 5533, 313, 1, 0, 0, 0, 5534, 5535, 5, 331, 0, 0, + 5535, 5539, 3, 388, 194, 0, 5536, 5537, 5, 517, 0, 0, 5537, 5539, 3, 316, + 158, 0, 5538, 5534, 1, 0, 0, 0, 5538, 5536, 1, 0, 0, 0, 5539, 315, 1, 0, + 0, 0, 5540, 5541, 5, 2, 0, 0, 5541, 5542, 3, 318, 159, 0, 5542, 5543, 5, + 3, 0, 0, 5543, 317, 1, 0, 0, 0, 5544, 5549, 3, 460, 230, 0, 5545, 5546, + 5, 4, 0, 0, 5546, 5548, 3, 460, 230, 0, 5547, 5545, 1, 0, 0, 0, 5548, 5551, + 1, 0, 0, 0, 5549, 5547, 1, 0, 0, 0, 5549, 5550, 1, 0, 0, 0, 5550, 319, + 1, 0, 0, 0, 5551, 5549, 1, 0, 0, 0, 5552, 5553, 5, 567, 0, 0, 5553, 5554, + 3, 464, 232, 0, 5554, 5557, 5, 2, 0, 0, 5555, 5558, 3, 328, 164, 0, 5556, + 5558, 3, 318, 159, 0, 5557, 5555, 1, 0, 0, 0, 5557, 5556, 1, 0, 0, 0, 5557, + 5558, 1, 0, 0, 0, 5558, 5559, 1, 0, 0, 0, 5559, 5560, 5, 3, 0, 0, 5560, + 321, 1, 0, 0, 0, 5561, 5563, 3, 338, 169, 0, 5562, 5564, 3, 320, 160, 0, + 5563, 5562, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, 0, 5564, 5566, 1, 0, 0, 0, + 5565, 5567, 3, 324, 162, 0, 5566, 5565, 1, 0, 0, 0, 5566, 5567, 1, 0, 0, + 0, 5567, 5569, 1, 0, 0, 0, 5568, 5570, 3, 458, 229, 0, 5569, 5568, 1, 0, + 0, 0, 5569, 5570, 1, 0, 0, 0, 5570, 5572, 1, 0, 0, 0, 5571, 5573, 3, 420, + 210, 0, 5572, 5571, 1, 0, 0, 0, 5572, 5573, 1, 0, 0, 0, 5573, 5575, 1, + 0, 0, 0, 5574, 5576, 3, 374, 187, 0, 5575, 5574, 1, 0, 0, 0, 5575, 5576, + 1, 0, 0, 0, 5576, 5577, 1, 0, 0, 0, 5577, 5579, 3, 336, 168, 0, 5578, 5580, + 3, 454, 227, 0, 5579, 5578, 1, 0, 0, 0, 5579, 5580, 1, 0, 0, 0, 5580, 5582, + 1, 0, 0, 0, 5581, 5583, 3, 274, 137, 0, 5582, 5581, 1, 0, 0, 0, 5582, 5583, + 1, 0, 0, 0, 5583, 5587, 1, 0, 0, 0, 5584, 5586, 3, 300, 150, 0, 5585, 5584, + 1, 0, 0, 0, 5586, 5589, 1, 0, 0, 0, 5587, 5585, 1, 0, 0, 0, 5587, 5588, + 1, 0, 0, 0, 5588, 5613, 1, 0, 0, 0, 5589, 5587, 1, 0, 0, 0, 5590, 5591, + 5, 2, 0, 0, 5591, 5592, 3, 232, 116, 0, 5592, 5593, 5, 3, 0, 0, 5593, 5597, + 3, 336, 168, 0, 5594, 5596, 3, 300, 150, 0, 5595, 5594, 1, 0, 0, 0, 5596, + 5599, 1, 0, 0, 0, 5597, 5595, 1, 0, 0, 0, 5597, 5598, 1, 0, 0, 0, 5598, + 5613, 1, 0, 0, 0, 5599, 5597, 1, 0, 0, 0, 5600, 5601, 3, 464, 232, 0, 5601, + 5603, 5, 2, 0, 0, 5602, 5604, 3, 328, 164, 0, 5603, 5602, 1, 0, 0, 0, 5603, + 5604, 1, 0, 0, 0, 5604, 5605, 1, 0, 0, 0, 5605, 5606, 5, 3, 0, 0, 5606, + 5607, 3, 336, 168, 0, 5607, 5613, 1, 0, 0, 0, 5608, 5609, 5, 2, 0, 0, 5609, + 5610, 3, 262, 131, 0, 5610, 5611, 5, 3, 0, 0, 5611, 5613, 1, 0, 0, 0, 5612, + 5561, 1, 0, 0, 0, 5612, 5590, 1, 0, 0, 0, 5612, 5600, 1, 0, 0, 0, 5612, + 5608, 1, 0, 0, 0, 5613, 323, 1, 0, 0, 0, 5614, 5615, 5, 233, 0, 0, 5615, + 5616, 3, 464, 232, 0, 5616, 325, 1, 0, 0, 0, 5617, 5618, 5, 375, 0, 0, + 5618, 5619, 5, 2, 0, 0, 5619, 5620, 3, 328, 164, 0, 5620, 5621, 5, 3, 0, + 0, 5621, 327, 1, 0, 0, 0, 5622, 5627, 3, 330, 165, 0, 5623, 5624, 5, 4, + 0, 0, 5624, 5626, 3, 330, 165, 0, 5625, 5623, 1, 0, 0, 0, 5626, 5629, 1, + 0, 0, 0, 5627, 5625, 1, 0, 0, 0, 5627, 5628, 1, 0, 0, 0, 5628, 329, 1, + 0, 0, 0, 5629, 5627, 1, 0, 0, 0, 5630, 5631, 3, 332, 166, 0, 5631, 5632, + 5, 543, 0, 0, 5632, 5633, 3, 334, 167, 0, 5633, 331, 1, 0, 0, 0, 5634, + 5637, 3, 464, 232, 0, 5635, 5637, 3, 422, 211, 0, 5636, 5634, 1, 0, 0, + 0, 5636, 5635, 1, 0, 0, 0, 5637, 333, 1, 0, 0, 0, 5638, 5641, 3, 464, 232, + 0, 5639, 5641, 3, 422, 211, 0, 5640, 5638, 1, 0, 0, 0, 5640, 5639, 1, 0, + 0, 0, 5641, 335, 1, 0, 0, 0, 5642, 5644, 5, 29, 0, 0, 5643, 5642, 1, 0, + 0, 0, 5643, 5644, 1, 0, 0, 0, 5644, 5645, 1, 0, 0, 0, 5645, 5647, 3, 466, + 233, 0, 5646, 5648, 3, 316, 158, 0, 5647, 5646, 1, 0, 0, 0, 5647, 5648, + 1, 0, 0, 0, 5648, 5650, 1, 0, 0, 0, 5649, 5643, 1, 0, 0, 0, 5649, 5650, + 1, 0, 0, 0, 5650, 337, 1, 0, 0, 0, 5651, 5656, 3, 460, 230, 0, 5652, 5653, + 5, 5, 0, 0, 5653, 5655, 3, 460, 230, 0, 5654, 5652, 1, 0, 0, 0, 5655, 5658, + 1, 0, 0, 0, 5656, 5654, 1, 0, 0, 0, 5656, 5657, 1, 0, 0, 0, 5657, 339, + 1, 0, 0, 0, 5658, 5656, 1, 0, 0, 0, 5659, 5664, 3, 342, 171, 0, 5660, 5661, + 5, 4, 0, 0, 5661, 5663, 3, 342, 171, 0, 5662, 5660, 1, 0, 0, 0, 5663, 5666, + 1, 0, 0, 0, 5664, 5662, 1, 0, 0, 0, 5664, 5665, 1, 0, 0, 0, 5665, 341, + 1, 0, 0, 0, 5666, 5664, 1, 0, 0, 0, 5667, 5670, 3, 464, 232, 0, 5668, 5669, + 5, 85, 0, 0, 5669, 5671, 5, 569, 0, 0, 5670, 5668, 1, 0, 0, 0, 5670, 5671, + 1, 0, 0, 0, 5671, 343, 1, 0, 0, 0, 5672, 5677, 3, 346, 173, 0, 5673, 5674, + 5, 4, 0, 0, 5674, 5676, 3, 346, 173, 0, 5675, 5673, 1, 0, 0, 0, 5676, 5679, + 1, 0, 0, 0, 5677, 5675, 1, 0, 0, 0, 5677, 5678, 1, 0, 0, 0, 5678, 345, + 1, 0, 0, 0, 5679, 5677, 1, 0, 0, 0, 5680, 5681, 3, 464, 232, 0, 5681, 5683, + 3, 436, 218, 0, 5682, 5684, 5, 259, 0, 0, 5683, 5682, 1, 0, 0, 0, 5683, + 5684, 1, 0, 0, 0, 5684, 5686, 1, 0, 0, 0, 5685, 5687, 3, 372, 186, 0, 5686, + 5685, 1, 0, 0, 0, 5686, 5687, 1, 0, 0, 0, 5687, 5697, 1, 0, 0, 0, 5688, + 5689, 5, 204, 0, 0, 5689, 5691, 5, 35, 0, 0, 5690, 5688, 1, 0, 0, 0, 5690, + 5691, 1, 0, 0, 0, 5691, 5692, 1, 0, 0, 0, 5692, 5693, 5, 29, 0, 0, 5693, + 5694, 5, 2, 0, 0, 5694, 5695, 3, 382, 191, 0, 5695, 5696, 5, 3, 0, 0, 5696, + 5698, 1, 0, 0, 0, 5697, 5690, 1, 0, 0, 0, 5697, 5698, 1, 0, 0, 0, 5698, + 5703, 1, 0, 0, 0, 5699, 5701, 5, 325, 0, 0, 5700, 5699, 1, 0, 0, 0, 5700, + 5701, 1, 0, 0, 0, 5701, 5702, 1, 0, 0, 0, 5702, 5704, 5, 326, 0, 0, 5703, + 5700, 1, 0, 0, 0, 5703, 5704, 1, 0, 0, 0, 5704, 5712, 1, 0, 0, 0, 5705, + 5710, 5, 34, 0, 0, 5706, 5707, 5, 2, 0, 0, 5707, 5708, 3, 470, 235, 0, + 5708, 5709, 5, 3, 0, 0, 5709, 5711, 1, 0, 0, 0, 5710, 5706, 1, 0, 0, 0, + 5710, 5711, 1, 0, 0, 0, 5711, 5713, 1, 0, 0, 0, 5712, 5705, 1, 0, 0, 0, + 5712, 5713, 1, 0, 0, 0, 5713, 5738, 1, 0, 0, 0, 5714, 5736, 5, 131, 0, + 0, 5715, 5737, 5, 326, 0, 0, 5716, 5718, 5, 551, 0, 0, 5717, 5716, 1, 0, + 0, 0, 5717, 5718, 1, 0, 0, 0, 5718, 5719, 1, 0, 0, 0, 5719, 5737, 5, 575, + 0, 0, 5720, 5722, 5, 551, 0, 0, 5721, 5720, 1, 0, 0, 0, 5721, 5722, 1, + 0, 0, 0, 5722, 5723, 1, 0, 0, 0, 5723, 5737, 5, 577, 0, 0, 5724, 5737, + 5, 358, 0, 0, 5725, 5737, 5, 157, 0, 0, 5726, 5737, 5, 48, 0, 0, 5727, + 5737, 5, 569, 0, 0, 5728, 5737, 5, 110, 0, 0, 5729, 5734, 5, 112, 0, 0, + 5730, 5731, 5, 2, 0, 0, 5731, 5732, 3, 470, 235, 0, 5732, 5733, 5, 3, 0, + 0, 5733, 5735, 1, 0, 0, 0, 5734, 5730, 1, 0, 0, 0, 5734, 5735, 1, 0, 0, + 0, 5735, 5737, 1, 0, 0, 0, 5736, 5715, 1, 0, 0, 0, 5736, 5717, 1, 0, 0, + 0, 5736, 5721, 1, 0, 0, 0, 5736, 5724, 1, 0, 0, 0, 5736, 5725, 1, 0, 0, + 0, 5736, 5726, 1, 0, 0, 0, 5736, 5727, 1, 0, 0, 0, 5736, 5728, 1, 0, 0, + 0, 5736, 5729, 1, 0, 0, 0, 5737, 5739, 1, 0, 0, 0, 5738, 5714, 1, 0, 0, + 0, 5738, 5739, 1, 0, 0, 0, 5739, 5749, 1, 0, 0, 0, 5740, 5741, 5, 331, + 0, 0, 5741, 5742, 5, 513, 0, 0, 5742, 5747, 5, 112, 0, 0, 5743, 5744, 5, + 2, 0, 0, 5744, 5745, 3, 470, 235, 0, 5745, 5746, 5, 3, 0, 0, 5746, 5748, + 1, 0, 0, 0, 5747, 5743, 1, 0, 0, 0, 5747, 5748, 1, 0, 0, 0, 5748, 5750, + 1, 0, 0, 0, 5749, 5740, 1, 0, 0, 0, 5749, 5750, 1, 0, 0, 0, 5750, 5753, + 1, 0, 0, 0, 5751, 5752, 5, 85, 0, 0, 5752, 5754, 5, 569, 0, 0, 5753, 5751, + 1, 0, 0, 0, 5753, 5754, 1, 0, 0, 0, 5754, 347, 1, 0, 0, 0, 5755, 5760, + 3, 350, 175, 0, 5756, 5757, 5, 4, 0, 0, 5757, 5759, 3, 350, 175, 0, 5758, + 5756, 1, 0, 0, 0, 5759, 5762, 1, 0, 0, 0, 5760, 5758, 1, 0, 0, 0, 5760, + 5761, 1, 0, 0, 0, 5761, 349, 1, 0, 0, 0, 5762, 5760, 1, 0, 0, 0, 5763, + 5767, 5, 233, 0, 0, 5764, 5765, 5, 228, 0, 0, 5765, 5766, 5, 325, 0, 0, + 5766, 5768, 5, 175, 0, 0, 5767, 5764, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, + 0, 5768, 5769, 1, 0, 0, 0, 5769, 5770, 3, 464, 232, 0, 5770, 5773, 3, 316, + 158, 0, 5771, 5772, 5, 517, 0, 0, 5772, 5774, 7, 8, 0, 0, 5773, 5771, 1, + 0, 0, 0, 5773, 5774, 1, 0, 0, 0, 5774, 5780, 1, 0, 0, 0, 5775, 5776, 5, + 375, 0, 0, 5776, 5777, 5, 2, 0, 0, 5777, 5778, 3, 328, 164, 0, 5778, 5779, + 5, 3, 0, 0, 5779, 5781, 1, 0, 0, 0, 5780, 5775, 1, 0, 0, 0, 5780, 5781, + 1, 0, 0, 0, 5781, 5784, 1, 0, 0, 0, 5782, 5783, 5, 85, 0, 0, 5783, 5785, + 5, 569, 0, 0, 5784, 5782, 1, 0, 0, 0, 5784, 5785, 1, 0, 0, 0, 5785, 351, + 1, 0, 0, 0, 5786, 5791, 3, 354, 177, 0, 5787, 5788, 5, 4, 0, 0, 5788, 5790, + 3, 354, 177, 0, 5789, 5787, 1, 0, 0, 0, 5790, 5793, 1, 0, 0, 0, 5791, 5789, + 1, 0, 0, 0, 5791, 5792, 1, 0, 0, 0, 5792, 353, 1, 0, 0, 0, 5793, 5791, + 1, 0, 0, 0, 5794, 5799, 3, 356, 178, 0, 5795, 5799, 3, 358, 179, 0, 5796, + 5799, 3, 360, 180, 0, 5797, 5799, 3, 362, 181, 0, 5798, 5794, 1, 0, 0, + 0, 5798, 5795, 1, 0, 0, 0, 5798, 5796, 1, 0, 0, 0, 5798, 5797, 1, 0, 0, + 0, 5799, 5804, 1, 0, 0, 0, 5800, 5801, 5, 2, 0, 0, 5801, 5802, 3, 328, + 164, 0, 5802, 5803, 5, 3, 0, 0, 5803, 5805, 1, 0, 0, 0, 5804, 5800, 1, + 0, 0, 0, 5804, 5805, 1, 0, 0, 0, 5805, 355, 1, 0, 0, 0, 5806, 5810, 5, + 345, 0, 0, 5807, 5808, 5, 228, 0, 0, 5808, 5809, 5, 325, 0, 0, 5809, 5811, + 5, 175, 0, 0, 5810, 5807, 1, 0, 0, 0, 5810, 5811, 1, 0, 0, 0, 5811, 5812, + 1, 0, 0, 0, 5812, 5813, 3, 464, 232, 0, 5813, 5814, 5, 519, 0, 0, 5814, + 5815, 5, 271, 0, 0, 5815, 5818, 5, 484, 0, 0, 5816, 5819, 5, 300, 0, 0, + 5817, 5819, 3, 364, 182, 0, 5818, 5816, 1, 0, 0, 0, 5818, 5817, 1, 0, 0, + 0, 5819, 357, 1, 0, 0, 0, 5820, 5824, 5, 345, 0, 0, 5821, 5822, 5, 228, + 0, 0, 5822, 5823, 5, 325, 0, 0, 5823, 5825, 5, 175, 0, 0, 5824, 5821, 1, + 0, 0, 0, 5824, 5825, 1, 0, 0, 0, 5825, 5826, 1, 0, 0, 0, 5826, 5827, 3, + 464, 232, 0, 5827, 5828, 5, 519, 0, 0, 5828, 5829, 5, 7, 0, 0, 5829, 5830, + 3, 364, 182, 0, 5830, 5831, 5, 4, 0, 0, 5831, 5832, 3, 364, 182, 0, 5832, + 5833, 5, 3, 0, 0, 5833, 359, 1, 0, 0, 0, 5834, 5835, 5, 198, 0, 0, 5835, + 5836, 3, 364, 182, 0, 5836, 5837, 5, 489, 0, 0, 5837, 5838, 3, 364, 182, + 0, 5838, 5839, 5, 243, 0, 0, 5839, 5841, 5, 575, 0, 0, 5840, 5842, 3, 432, + 216, 0, 5841, 5840, 1, 0, 0, 0, 5841, 5842, 1, 0, 0, 0, 5842, 361, 1, 0, + 0, 0, 5843, 5847, 5, 345, 0, 0, 5844, 5845, 5, 228, 0, 0, 5845, 5846, 5, + 325, 0, 0, 5846, 5848, 5, 175, 0, 0, 5847, 5844, 1, 0, 0, 0, 5847, 5848, + 1, 0, 0, 0, 5848, 5849, 1, 0, 0, 0, 5849, 5868, 3, 464, 232, 0, 5850, 5851, + 5, 519, 0, 0, 5851, 5853, 5, 231, 0, 0, 5852, 5850, 1, 0, 0, 0, 5852, 5853, + 1, 0, 0, 0, 5853, 5866, 1, 0, 0, 0, 5854, 5855, 5, 2, 0, 0, 5855, 5860, + 3, 364, 182, 0, 5856, 5857, 5, 4, 0, 0, 5857, 5859, 3, 364, 182, 0, 5858, + 5856, 1, 0, 0, 0, 5859, 5862, 1, 0, 0, 0, 5860, 5858, 1, 0, 0, 0, 5860, + 5861, 1, 0, 0, 0, 5861, 5863, 1, 0, 0, 0, 5862, 5860, 1, 0, 0, 0, 5863, + 5864, 5, 3, 0, 0, 5864, 5867, 1, 0, 0, 0, 5865, 5867, 3, 364, 182, 0, 5866, + 5854, 1, 0, 0, 0, 5866, 5865, 1, 0, 0, 0, 5867, 5869, 1, 0, 0, 0, 5868, + 5852, 1, 0, 0, 0, 5868, 5869, 1, 0, 0, 0, 5869, 363, 1, 0, 0, 0, 5870, + 5871, 5, 2, 0, 0, 5871, 5876, 3, 366, 183, 0, 5872, 5873, 5, 4, 0, 0, 5873, + 5875, 3, 366, 183, 0, 5874, 5872, 1, 0, 0, 0, 5875, 5878, 1, 0, 0, 0, 5876, + 5874, 1, 0, 0, 0, 5876, 5877, 1, 0, 0, 0, 5877, 5879, 1, 0, 0, 0, 5878, + 5876, 1, 0, 0, 0, 5879, 5880, 5, 3, 0, 0, 5880, 365, 1, 0, 0, 0, 5881, + 5883, 5, 551, 0, 0, 5882, 5881, 1, 0, 0, 0, 5882, 5883, 1, 0, 0, 0, 5883, + 5884, 1, 0, 0, 0, 5884, 5889, 5, 575, 0, 0, 5885, 5889, 5, 569, 0, 0, 5886, + 5889, 5, 300, 0, 0, 5887, 5889, 5, 326, 0, 0, 5888, 5882, 1, 0, 0, 0, 5888, + 5885, 1, 0, 0, 0, 5888, 5886, 1, 0, 0, 0, 5888, 5887, 1, 0, 0, 0, 5889, + 367, 1, 0, 0, 0, 5890, 5895, 3, 370, 185, 0, 5891, 5892, 5, 4, 0, 0, 5892, + 5894, 3, 370, 185, 0, 5893, 5891, 1, 0, 0, 0, 5894, 5897, 1, 0, 0, 0, 5895, + 5893, 1, 0, 0, 0, 5895, 5896, 1, 0, 0, 0, 5896, 369, 1, 0, 0, 0, 5897, + 5895, 1, 0, 0, 0, 5898, 5899, 3, 464, 232, 0, 5899, 5903, 3, 316, 158, + 0, 5900, 5901, 5, 155, 0, 0, 5901, 5902, 5, 259, 0, 0, 5902, 5904, 3, 316, + 158, 0, 5903, 5900, 1, 0, 0, 0, 5903, 5904, 1, 0, 0, 0, 5904, 5906, 1, + 0, 0, 0, 5905, 5907, 3, 326, 163, 0, 5906, 5905, 1, 0, 0, 0, 5906, 5907, + 1, 0, 0, 0, 5907, 371, 1, 0, 0, 0, 5908, 5909, 7, 42, 0, 0, 5909, 373, + 1, 0, 0, 0, 5910, 5911, 5, 475, 0, 0, 5911, 5912, 5, 2, 0, 0, 5912, 5917, + 5, 575, 0, 0, 5913, 5914, 5, 4, 0, 0, 5914, 5916, 5, 575, 0, 0, 5915, 5913, + 1, 0, 0, 0, 5916, 5919, 1, 0, 0, 0, 5917, 5915, 1, 0, 0, 0, 5917, 5918, + 1, 0, 0, 0, 5918, 5920, 1, 0, 0, 0, 5919, 5917, 1, 0, 0, 0, 5920, 5921, + 5, 3, 0, 0, 5921, 375, 1, 0, 0, 0, 5922, 5923, 5, 519, 0, 0, 5923, 5928, + 3, 390, 195, 0, 5924, 5925, 5, 4, 0, 0, 5925, 5927, 3, 390, 195, 0, 5926, + 5924, 1, 0, 0, 0, 5927, 5930, 1, 0, 0, 0, 5928, 5926, 1, 0, 0, 0, 5928, + 5929, 1, 0, 0, 0, 5929, 377, 1, 0, 0, 0, 5930, 5928, 1, 0, 0, 0, 5931, + 5936, 3, 382, 191, 0, 5932, 5934, 5, 29, 0, 0, 5933, 5932, 1, 0, 0, 0, + 5933, 5934, 1, 0, 0, 0, 5934, 5935, 1, 0, 0, 0, 5935, 5937, 3, 186, 93, + 0, 5936, 5933, 1, 0, 0, 0, 5936, 5937, 1, 0, 0, 0, 5937, 379, 1, 0, 0, + 0, 5938, 5943, 3, 378, 189, 0, 5939, 5940, 5, 4, 0, 0, 5940, 5942, 3, 378, + 189, 0, 5941, 5939, 1, 0, 0, 0, 5942, 5945, 1, 0, 0, 0, 5943, 5941, 1, + 0, 0, 0, 5943, 5944, 1, 0, 0, 0, 5944, 381, 1, 0, 0, 0, 5945, 5943, 1, + 0, 0, 0, 5946, 5947, 3, 388, 194, 0, 5947, 383, 1, 0, 0, 0, 5948, 5951, + 3, 382, 191, 0, 5949, 5951, 3, 386, 193, 0, 5950, 5948, 1, 0, 0, 0, 5950, + 5949, 1, 0, 0, 0, 5951, 385, 1, 0, 0, 0, 5952, 5953, 3, 460, 230, 0, 5953, + 5954, 5, 563, 0, 0, 5954, 5955, 3, 388, 194, 0, 5955, 5969, 1, 0, 0, 0, + 5956, 5957, 5, 2, 0, 0, 5957, 5960, 3, 460, 230, 0, 5958, 5959, 5, 4, 0, + 0, 5959, 5961, 3, 460, 230, 0, 5960, 5958, 1, 0, 0, 0, 5961, 5962, 1, 0, + 0, 0, 5962, 5960, 1, 0, 0, 0, 5962, 5963, 1, 0, 0, 0, 5963, 5964, 1, 0, + 0, 0, 5964, 5965, 5, 3, 0, 0, 5965, 5966, 5, 563, 0, 0, 5966, 5967, 3, + 388, 194, 0, 5967, 5969, 1, 0, 0, 0, 5968, 5952, 1, 0, 0, 0, 5968, 5956, + 1, 0, 0, 0, 5969, 387, 1, 0, 0, 0, 5970, 5971, 6, 194, -1, 0, 5971, 5972, + 5, 558, 0, 0, 5972, 5995, 3, 388, 194, 10, 5973, 5974, 5, 175, 0, 0, 5974, + 5975, 5, 2, 0, 0, 5975, 5976, 3, 232, 116, 0, 5976, 5977, 5, 3, 0, 0, 5977, + 5995, 1, 0, 0, 0, 5978, 5979, 7, 43, 0, 0, 5979, 5980, 5, 2, 0, 0, 5980, + 5981, 3, 396, 198, 0, 5981, 5982, 5, 3, 0, 0, 5982, 5995, 1, 0, 0, 0, 5983, + 5984, 5, 250, 0, 0, 5984, 5985, 5, 2, 0, 0, 5985, 5986, 3, 396, 198, 0, + 5986, 5987, 5, 3, 0, 0, 5987, 5995, 1, 0, 0, 0, 5988, 5990, 3, 396, 198, + 0, 5989, 5991, 3, 394, 197, 0, 5990, 5989, 1, 0, 0, 0, 5990, 5991, 1, 0, + 0, 0, 5991, 5995, 1, 0, 0, 0, 5992, 5993, 5, 325, 0, 0, 5993, 5995, 3, + 388, 194, 5, 5994, 5970, 1, 0, 0, 0, 5994, 5973, 1, 0, 0, 0, 5994, 5978, + 1, 0, 0, 0, 5994, 5983, 1, 0, 0, 0, 5994, 5988, 1, 0, 0, 0, 5994, 5992, + 1, 0, 0, 0, 5995, 6010, 1, 0, 0, 0, 5996, 5997, 10, 4, 0, 0, 5997, 5998, + 7, 44, 0, 0, 5998, 6009, 3, 388, 194, 5, 5999, 6000, 10, 3, 0, 0, 6000, + 6001, 5, 541, 0, 0, 6001, 6009, 3, 388, 194, 4, 6002, 6003, 10, 2, 0, 0, + 6003, 6004, 5, 337, 0, 0, 6004, 6009, 3, 388, 194, 3, 6005, 6006, 10, 1, + 0, 0, 6006, 6007, 5, 560, 0, 0, 6007, 6009, 3, 388, 194, 2, 6008, 5996, + 1, 0, 0, 0, 6008, 5999, 1, 0, 0, 0, 6008, 6002, 1, 0, 0, 0, 6008, 6005, + 1, 0, 0, 0, 6009, 6012, 1, 0, 0, 0, 6010, 6008, 1, 0, 0, 0, 6010, 6011, + 1, 0, 0, 0, 6011, 389, 1, 0, 0, 0, 6012, 6010, 1, 0, 0, 0, 6013, 6022, + 5, 2, 0, 0, 6014, 6019, 3, 392, 196, 0, 6015, 6016, 5, 4, 0, 0, 6016, 6018, + 3, 392, 196, 0, 6017, 6015, 1, 0, 0, 0, 6018, 6021, 1, 0, 0, 0, 6019, 6017, + 1, 0, 0, 0, 6019, 6020, 1, 0, 0, 0, 6020, 6023, 1, 0, 0, 0, 6021, 6019, + 1, 0, 0, 0, 6022, 6014, 1, 0, 0, 0, 6022, 6023, 1, 0, 0, 0, 6023, 6024, + 1, 0, 0, 0, 6024, 6025, 5, 3, 0, 0, 6025, 391, 1, 0, 0, 0, 6026, 6030, + 3, 422, 211, 0, 6027, 6030, 5, 131, 0, 0, 6028, 6030, 3, 378, 189, 0, 6029, + 6026, 1, 0, 0, 0, 6029, 6027, 1, 0, 0, 0, 6029, 6028, 1, 0, 0, 0, 6030, + 393, 1, 0, 0, 0, 6031, 6033, 5, 325, 0, 0, 6032, 6031, 1, 0, 0, 0, 6032, + 6033, 1, 0, 0, 0, 6033, 6034, 1, 0, 0, 0, 6034, 6035, 5, 41, 0, 0, 6035, + 6036, 3, 396, 198, 0, 6036, 6037, 5, 25, 0, 0, 6037, 6038, 3, 396, 198, + 0, 6038, 6092, 1, 0, 0, 0, 6039, 6041, 5, 325, 0, 0, 6040, 6039, 1, 0, + 0, 0, 6040, 6041, 1, 0, 0, 0, 6041, 6042, 1, 0, 0, 0, 6042, 6043, 7, 45, + 0, 0, 6043, 6092, 3, 396, 198, 0, 6044, 6046, 5, 325, 0, 0, 6045, 6044, + 1, 0, 0, 0, 6045, 6046, 1, 0, 0, 0, 6046, 6047, 1, 0, 0, 0, 6047, 6048, + 5, 273, 0, 0, 6048, 6051, 3, 396, 198, 0, 6049, 6050, 5, 169, 0, 0, 6050, + 6052, 3, 396, 198, 0, 6051, 6049, 1, 0, 0, 0, 6051, 6052, 1, 0, 0, 0, 6052, + 6092, 1, 0, 0, 0, 6053, 6055, 5, 325, 0, 0, 6054, 6053, 1, 0, 0, 0, 6054, + 6055, 1, 0, 0, 0, 6055, 6056, 1, 0, 0, 0, 6056, 6057, 7, 46, 0, 0, 6057, + 6092, 3, 396, 198, 0, 6058, 6060, 5, 325, 0, 0, 6059, 6058, 1, 0, 0, 0, + 6059, 6060, 1, 0, 0, 0, 6060, 6061, 1, 0, 0, 0, 6061, 6062, 5, 231, 0, + 0, 6062, 6063, 5, 2, 0, 0, 6063, 6064, 3, 232, 116, 0, 6064, 6065, 5, 3, + 0, 0, 6065, 6092, 1, 0, 0, 0, 6066, 6068, 5, 325, 0, 0, 6067, 6066, 1, + 0, 0, 0, 6067, 6068, 1, 0, 0, 0, 6068, 6069, 1, 0, 0, 0, 6069, 6070, 5, + 231, 0, 0, 6070, 6071, 5, 2, 0, 0, 6071, 6076, 3, 382, 191, 0, 6072, 6073, + 5, 4, 0, 0, 6073, 6075, 3, 382, 191, 0, 6074, 6072, 1, 0, 0, 0, 6075, 6078, + 1, 0, 0, 0, 6076, 6074, 1, 0, 0, 0, 6076, 6077, 1, 0, 0, 0, 6077, 6079, + 1, 0, 0, 0, 6078, 6076, 1, 0, 0, 0, 6079, 6080, 5, 3, 0, 0, 6080, 6092, + 1, 0, 0, 0, 6081, 6083, 5, 249, 0, 0, 6082, 6084, 5, 325, 0, 0, 6083, 6082, + 1, 0, 0, 0, 6083, 6084, 1, 0, 0, 0, 6084, 6085, 1, 0, 0, 0, 6085, 6092, + 5, 326, 0, 0, 6086, 6088, 5, 249, 0, 0, 6087, 6089, 5, 325, 0, 0, 6088, + 6087, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, 6089, 6090, 1, 0, 0, 0, 6090, + 6092, 7, 47, 0, 0, 6091, 6032, 1, 0, 0, 0, 6091, 6040, 1, 0, 0, 0, 6091, + 6045, 1, 0, 0, 0, 6091, 6054, 1, 0, 0, 0, 6091, 6059, 1, 0, 0, 0, 6091, + 6067, 1, 0, 0, 0, 6091, 6081, 1, 0, 0, 0, 6091, 6086, 1, 0, 0, 0, 6092, + 395, 1, 0, 0, 0, 6093, 6094, 6, 198, -1, 0, 6094, 6098, 3, 398, 199, 0, + 6095, 6096, 7, 48, 0, 0, 6096, 6098, 3, 396, 198, 7, 6097, 6093, 1, 0, + 0, 0, 6097, 6095, 1, 0, 0, 0, 6098, 6120, 1, 0, 0, 0, 6099, 6100, 10, 6, + 0, 0, 6100, 6101, 5, 561, 0, 0, 6101, 6119, 3, 396, 198, 7, 6102, 6103, + 10, 5, 0, 0, 6103, 6104, 7, 49, 0, 0, 6104, 6119, 3, 396, 198, 6, 6105, + 6106, 10, 4, 0, 0, 6106, 6107, 7, 50, 0, 0, 6107, 6119, 3, 396, 198, 5, + 6108, 6109, 10, 3, 0, 0, 6109, 6110, 5, 556, 0, 0, 6110, 6119, 3, 396, + 198, 4, 6111, 6112, 10, 2, 0, 0, 6112, 6113, 5, 559, 0, 0, 6113, 6119, + 3, 396, 198, 3, 6114, 6115, 10, 1, 0, 0, 6115, 6116, 3, 424, 212, 0, 6116, + 6117, 3, 396, 198, 2, 6117, 6119, 1, 0, 0, 0, 6118, 6099, 1, 0, 0, 0, 6118, + 6102, 1, 0, 0, 0, 6118, 6105, 1, 0, 0, 0, 6118, 6108, 1, 0, 0, 0, 6118, + 6111, 1, 0, 0, 0, 6118, 6114, 1, 0, 0, 0, 6119, 6122, 1, 0, 0, 0, 6120, + 6118, 1, 0, 0, 0, 6120, 6121, 1, 0, 0, 0, 6121, 397, 1, 0, 0, 0, 6122, + 6120, 1, 0, 0, 0, 6123, 6124, 6, 199, -1, 0, 6124, 6328, 5, 110, 0, 0, + 6125, 6328, 5, 111, 0, 0, 6126, 6328, 5, 112, 0, 0, 6127, 6328, 5, 280, + 0, 0, 6128, 6328, 5, 281, 0, 0, 6129, 6328, 5, 113, 0, 0, 6130, 6328, 5, + 438, 0, 0, 6131, 6133, 5, 67, 0, 0, 6132, 6134, 3, 428, 214, 0, 6133, 6132, + 1, 0, 0, 0, 6134, 6135, 1, 0, 0, 0, 6135, 6133, 1, 0, 0, 0, 6135, 6136, + 1, 0, 0, 0, 6136, 6139, 1, 0, 0, 0, 6137, 6138, 5, 158, 0, 0, 6138, 6140, + 3, 382, 191, 0, 6139, 6137, 1, 0, 0, 0, 6139, 6140, 1, 0, 0, 0, 6140, 6141, + 1, 0, 0, 0, 6141, 6142, 5, 163, 0, 0, 6142, 6328, 1, 0, 0, 0, 6143, 6144, + 5, 67, 0, 0, 6144, 6146, 3, 382, 191, 0, 6145, 6147, 3, 428, 214, 0, 6146, + 6145, 1, 0, 0, 0, 6147, 6148, 1, 0, 0, 0, 6148, 6146, 1, 0, 0, 0, 6148, + 6149, 1, 0, 0, 0, 6149, 6152, 1, 0, 0, 0, 6150, 6151, 5, 158, 0, 0, 6151, + 6153, 3, 382, 191, 0, 6152, 6150, 1, 0, 0, 0, 6152, 6153, 1, 0, 0, 0, 6153, + 6154, 1, 0, 0, 0, 6154, 6155, 5, 163, 0, 0, 6155, 6328, 1, 0, 0, 0, 6156, + 6157, 5, 68, 0, 0, 6157, 6158, 5, 2, 0, 0, 6158, 6159, 3, 382, 191, 0, + 6159, 6160, 5, 29, 0, 0, 6160, 6161, 3, 402, 201, 0, 6161, 6162, 5, 3, + 0, 0, 6162, 6328, 1, 0, 0, 0, 6163, 6164, 5, 500, 0, 0, 6164, 6165, 5, + 2, 0, 0, 6165, 6166, 3, 382, 191, 0, 6166, 6167, 5, 29, 0, 0, 6167, 6168, + 3, 402, 201, 0, 6168, 6169, 5, 3, 0, 0, 6169, 6328, 1, 0, 0, 0, 6170, 6328, + 3, 422, 211, 0, 6171, 6328, 3, 430, 215, 0, 6172, 6176, 5, 552, 0, 0, 6173, + 6175, 3, 400, 200, 0, 6174, 6173, 1, 0, 0, 0, 6175, 6178, 1, 0, 0, 0, 6176, + 6174, 1, 0, 0, 0, 6176, 6177, 1, 0, 0, 0, 6177, 6328, 1, 0, 0, 0, 6178, + 6176, 1, 0, 0, 0, 6179, 6180, 3, 418, 209, 0, 6180, 6181, 5, 5, 0, 0, 6181, + 6185, 5, 552, 0, 0, 6182, 6184, 3, 400, 200, 0, 6183, 6182, 1, 0, 0, 0, + 6184, 6187, 1, 0, 0, 0, 6185, 6183, 1, 0, 0, 0, 6185, 6186, 1, 0, 0, 0, + 6186, 6328, 1, 0, 0, 0, 6187, 6185, 1, 0, 0, 0, 6188, 6189, 5, 72, 0, 0, + 6189, 6190, 5, 2, 0, 0, 6190, 6195, 3, 382, 191, 0, 6191, 6192, 5, 4, 0, + 0, 6192, 6194, 3, 382, 191, 0, 6193, 6191, 1, 0, 0, 0, 6194, 6197, 1, 0, + 0, 0, 6195, 6193, 1, 0, 0, 0, 6195, 6196, 1, 0, 0, 0, 6196, 6200, 1, 0, + 0, 0, 6197, 6195, 1, 0, 0, 0, 6198, 6199, 5, 517, 0, 0, 6199, 6201, 3, + 186, 93, 0, 6200, 6198, 1, 0, 0, 0, 6200, 6201, 1, 0, 0, 0, 6201, 6202, + 1, 0, 0, 0, 6202, 6203, 5, 3, 0, 0, 6203, 6328, 1, 0, 0, 0, 6204, 6205, + 5, 99, 0, 0, 6205, 6206, 5, 2, 0, 0, 6206, 6207, 3, 382, 191, 0, 6207, + 6208, 5, 517, 0, 0, 6208, 6209, 3, 186, 93, 0, 6209, 6210, 5, 3, 0, 0, + 6210, 6328, 1, 0, 0, 0, 6211, 6212, 5, 99, 0, 0, 6212, 6213, 5, 2, 0, 0, + 6213, 6214, 3, 382, 191, 0, 6214, 6215, 5, 4, 0, 0, 6215, 6216, 3, 402, + 201, 0, 6216, 6217, 5, 3, 0, 0, 6217, 6328, 1, 0, 0, 0, 6218, 6219, 5, + 213, 0, 0, 6219, 6221, 5, 2, 0, 0, 6220, 6222, 7, 38, 0, 0, 6221, 6220, + 1, 0, 0, 0, 6221, 6222, 1, 0, 0, 0, 6222, 6227, 1, 0, 0, 0, 6223, 6224, + 5, 7, 0, 0, 6224, 6225, 3, 464, 232, 0, 6225, 6226, 5, 8, 0, 0, 6226, 6228, + 1, 0, 0, 0, 6227, 6223, 1, 0, 0, 0, 6227, 6228, 1, 0, 0, 0, 6228, 6229, + 1, 0, 0, 0, 6229, 6240, 3, 382, 191, 0, 6230, 6231, 5, 338, 0, 0, 6231, + 6232, 5, 62, 0, 0, 6232, 6237, 3, 306, 153, 0, 6233, 6234, 5, 4, 0, 0, + 6234, 6236, 3, 306, 153, 0, 6235, 6233, 1, 0, 0, 0, 6236, 6239, 1, 0, 0, + 0, 6237, 6235, 1, 0, 0, 0, 6237, 6238, 1, 0, 0, 0, 6238, 6241, 1, 0, 0, + 0, 6239, 6237, 1, 0, 0, 0, 6240, 6230, 1, 0, 0, 0, 6240, 6241, 1, 0, 0, + 0, 6241, 6244, 1, 0, 0, 0, 6242, 6243, 5, 435, 0, 0, 6243, 6245, 3, 382, + 191, 0, 6244, 6242, 1, 0, 0, 0, 6244, 6245, 1, 0, 0, 0, 6245, 6246, 1, + 0, 0, 0, 6246, 6249, 5, 3, 0, 0, 6247, 6248, 5, 341, 0, 0, 6248, 6250, + 3, 410, 205, 0, 6249, 6247, 1, 0, 0, 0, 6249, 6250, 1, 0, 0, 0, 6250, 6328, + 1, 0, 0, 0, 6251, 6252, 5, 586, 0, 0, 6252, 6253, 5, 2, 0, 0, 6253, 6254, + 3, 382, 191, 0, 6254, 6255, 5, 4, 0, 0, 6255, 6256, 3, 382, 191, 0, 6256, + 6257, 5, 3, 0, 0, 6257, 6328, 1, 0, 0, 0, 6258, 6259, 5, 497, 0, 0, 6259, + 6265, 5, 2, 0, 0, 6260, 6262, 7, 51, 0, 0, 6261, 6263, 3, 382, 191, 0, + 6262, 6261, 1, 0, 0, 0, 6262, 6263, 1, 0, 0, 0, 6263, 6266, 1, 0, 0, 0, + 6264, 6266, 3, 382, 191, 0, 6265, 6260, 1, 0, 0, 0, 6265, 6264, 1, 0, 0, + 0, 6266, 6267, 1, 0, 0, 0, 6267, 6268, 5, 198, 0, 0, 6268, 6269, 3, 382, + 191, 0, 6269, 6270, 5, 3, 0, 0, 6270, 6328, 1, 0, 0, 0, 6271, 6272, 7, + 52, 0, 0, 6272, 6273, 5, 2, 0, 0, 6273, 6274, 3, 382, 191, 0, 6274, 6275, + 5, 198, 0, 0, 6275, 6278, 3, 382, 191, 0, 6276, 6277, 5, 193, 0, 0, 6277, + 6279, 3, 382, 191, 0, 6278, 6276, 1, 0, 0, 0, 6278, 6279, 1, 0, 0, 0, 6279, + 6280, 1, 0, 0, 0, 6280, 6281, 5, 3, 0, 0, 6281, 6328, 1, 0, 0, 0, 6282, + 6283, 5, 367, 0, 0, 6283, 6284, 5, 2, 0, 0, 6284, 6285, 3, 382, 191, 0, + 6285, 6286, 5, 231, 0, 0, 6286, 6287, 3, 382, 191, 0, 6287, 6288, 5, 3, + 0, 0, 6288, 6328, 1, 0, 0, 0, 6289, 6328, 3, 404, 202, 0, 6290, 6291, 5, + 2, 0, 0, 6291, 6292, 3, 232, 116, 0, 6292, 6293, 5, 3, 0, 0, 6293, 6328, + 1, 0, 0, 0, 6294, 6295, 5, 567, 0, 0, 6295, 6328, 3, 186, 93, 0, 6296, + 6299, 5, 568, 0, 0, 6297, 6298, 7, 53, 0, 0, 6298, 6300, 5, 5, 0, 0, 6299, + 6297, 1, 0, 0, 0, 6299, 6300, 1, 0, 0, 0, 6300, 6301, 1, 0, 0, 0, 6301, + 6328, 3, 464, 232, 0, 6302, 6304, 5, 44, 0, 0, 6303, 6302, 1, 0, 0, 0, + 6303, 6304, 1, 0, 0, 0, 6304, 6305, 1, 0, 0, 0, 6305, 6328, 3, 464, 232, + 0, 6306, 6307, 5, 2, 0, 0, 6307, 6308, 3, 382, 191, 0, 6308, 6309, 5, 3, + 0, 0, 6309, 6328, 1, 0, 0, 0, 6310, 6314, 5, 259, 0, 0, 6311, 6312, 3, + 464, 232, 0, 6312, 6313, 5, 5, 0, 0, 6313, 6315, 1, 0, 0, 0, 6314, 6311, + 1, 0, 0, 0, 6314, 6315, 1, 0, 0, 0, 6315, 6316, 1, 0, 0, 0, 6316, 6328, + 3, 464, 232, 0, 6317, 6318, 5, 181, 0, 0, 6318, 6319, 5, 2, 0, 0, 6319, + 6320, 3, 464, 232, 0, 6320, 6322, 5, 198, 0, 0, 6321, 6323, 7, 54, 0, 0, + 6322, 6321, 1, 0, 0, 0, 6322, 6323, 1, 0, 0, 0, 6323, 6324, 1, 0, 0, 0, + 6324, 6325, 3, 396, 198, 0, 6325, 6326, 5, 3, 0, 0, 6326, 6328, 1, 0, 0, + 0, 6327, 6123, 1, 0, 0, 0, 6327, 6125, 1, 0, 0, 0, 6327, 6126, 1, 0, 0, + 0, 6327, 6127, 1, 0, 0, 0, 6327, 6128, 1, 0, 0, 0, 6327, 6129, 1, 0, 0, + 0, 6327, 6130, 1, 0, 0, 0, 6327, 6131, 1, 0, 0, 0, 6327, 6143, 1, 0, 0, + 0, 6327, 6156, 1, 0, 0, 0, 6327, 6163, 1, 0, 0, 0, 6327, 6170, 1, 0, 0, + 0, 6327, 6171, 1, 0, 0, 0, 6327, 6172, 1, 0, 0, 0, 6327, 6179, 1, 0, 0, + 0, 6327, 6188, 1, 0, 0, 0, 6327, 6204, 1, 0, 0, 0, 6327, 6211, 1, 0, 0, + 0, 6327, 6218, 1, 0, 0, 0, 6327, 6251, 1, 0, 0, 0, 6327, 6258, 1, 0, 0, + 0, 6327, 6271, 1, 0, 0, 0, 6327, 6282, 1, 0, 0, 0, 6327, 6289, 1, 0, 0, + 0, 6327, 6290, 1, 0, 0, 0, 6327, 6294, 1, 0, 0, 0, 6327, 6296, 1, 0, 0, + 0, 6327, 6303, 1, 0, 0, 0, 6327, 6306, 1, 0, 0, 0, 6327, 6310, 1, 0, 0, + 0, 6327, 6317, 1, 0, 0, 0, 6328, 6355, 1, 0, 0, 0, 6329, 6330, 10, 11, + 0, 0, 6330, 6331, 5, 7, 0, 0, 6331, 6332, 3, 396, 198, 0, 6332, 6333, 5, + 8, 0, 0, 6333, 6354, 1, 0, 0, 0, 6334, 6335, 10, 10, 0, 0, 6335, 6336, + 5, 7, 0, 0, 6336, 6337, 3, 396, 198, 0, 6337, 6339, 5, 562, 0, 0, 6338, + 6340, 3, 396, 198, 0, 6339, 6338, 1, 0, 0, 0, 6339, 6340, 1, 0, 0, 0, 6340, + 6341, 1, 0, 0, 0, 6341, 6342, 5, 8, 0, 0, 6342, 6354, 1, 0, 0, 0, 6343, + 6344, 10, 5, 0, 0, 6344, 6345, 5, 5, 0, 0, 6345, 6354, 3, 464, 232, 0, + 6346, 6347, 10, 1, 0, 0, 6347, 6351, 5, 79, 0, 0, 6348, 6352, 3, 464, 232, + 0, 6349, 6352, 5, 569, 0, 0, 6350, 6352, 5, 131, 0, 0, 6351, 6348, 1, 0, + 0, 0, 6351, 6349, 1, 0, 0, 0, 6351, 6350, 1, 0, 0, 0, 6352, 6354, 1, 0, + 0, 0, 6353, 6329, 1, 0, 0, 0, 6353, 6334, 1, 0, 0, 0, 6353, 6343, 1, 0, + 0, 0, 6353, 6346, 1, 0, 0, 0, 6354, 6357, 1, 0, 0, 0, 6355, 6353, 1, 0, + 0, 0, 6355, 6356, 1, 0, 0, 0, 6356, 399, 1, 0, 0, 0, 6357, 6355, 1, 0, + 0, 0, 6358, 6359, 5, 172, 0, 0, 6359, 6360, 5, 2, 0, 0, 6360, 6361, 3, + 380, 190, 0, 6361, 6362, 5, 3, 0, 0, 6362, 6369, 1, 0, 0, 0, 6363, 6364, + 5, 399, 0, 0, 6364, 6365, 5, 2, 0, 0, 6365, 6366, 3, 380, 190, 0, 6366, + 6367, 5, 3, 0, 0, 6367, 6369, 1, 0, 0, 0, 6368, 6358, 1, 0, 0, 0, 6368, + 6363, 1, 0, 0, 0, 6369, 401, 1, 0, 0, 0, 6370, 6376, 3, 436, 218, 0, 6371, + 6373, 7, 55, 0, 0, 6372, 6374, 7, 56, 0, 0, 6373, 6372, 1, 0, 0, 0, 6373, + 6374, 1, 0, 0, 0, 6374, 6376, 1, 0, 0, 0, 6375, 6370, 1, 0, 0, 0, 6375, + 6371, 1, 0, 0, 0, 6376, 403, 1, 0, 0, 0, 6377, 6378, 3, 406, 203, 0, 6378, + 6408, 5, 2, 0, 0, 6379, 6381, 7, 38, 0, 0, 6380, 6379, 1, 0, 0, 0, 6380, + 6381, 1, 0, 0, 0, 6381, 6386, 1, 0, 0, 0, 6382, 6383, 5, 7, 0, 0, 6383, + 6384, 3, 464, 232, 0, 6384, 6385, 5, 8, 0, 0, 6385, 6387, 1, 0, 0, 0, 6386, + 6382, 1, 0, 0, 0, 6386, 6387, 1, 0, 0, 0, 6387, 6388, 1, 0, 0, 0, 6388, + 6393, 3, 384, 192, 0, 6389, 6390, 5, 4, 0, 0, 6390, 6392, 3, 384, 192, + 0, 6391, 6389, 1, 0, 0, 0, 6392, 6395, 1, 0, 0, 0, 6393, 6391, 1, 0, 0, + 0, 6393, 6394, 1, 0, 0, 0, 6394, 6406, 1, 0, 0, 0, 6395, 6393, 1, 0, 0, + 0, 6396, 6397, 5, 338, 0, 0, 6397, 6398, 5, 62, 0, 0, 6398, 6403, 3, 306, + 153, 0, 6399, 6400, 5, 4, 0, 0, 6400, 6402, 3, 306, 153, 0, 6401, 6399, + 1, 0, 0, 0, 6402, 6405, 1, 0, 0, 0, 6403, 6401, 1, 0, 0, 0, 6403, 6404, + 1, 0, 0, 0, 6404, 6407, 1, 0, 0, 0, 6405, 6403, 1, 0, 0, 0, 6406, 6396, + 1, 0, 0, 0, 6406, 6407, 1, 0, 0, 0, 6407, 6409, 1, 0, 0, 0, 6408, 6380, + 1, 0, 0, 0, 6408, 6409, 1, 0, 0, 0, 6409, 6410, 1, 0, 0, 0, 6410, 6413, + 5, 3, 0, 0, 6411, 6412, 5, 341, 0, 0, 6412, 6414, 3, 410, 205, 0, 6413, + 6411, 1, 0, 0, 0, 6413, 6414, 1, 0, 0, 0, 6414, 405, 1, 0, 0, 0, 6415, + 6416, 3, 464, 232, 0, 6416, 6417, 5, 5, 0, 0, 6417, 6419, 1, 0, 0, 0, 6418, + 6415, 1, 0, 0, 0, 6418, 6419, 1, 0, 0, 0, 6419, 6420, 1, 0, 0, 0, 6420, + 6421, 3, 408, 204, 0, 6421, 407, 1, 0, 0, 0, 6422, 6439, 3, 464, 232, 0, + 6423, 6439, 5, 14, 0, 0, 6424, 6439, 5, 95, 0, 0, 6425, 6439, 5, 109, 0, + 0, 6426, 6439, 5, 113, 0, 0, 6427, 6439, 5, 115, 0, 0, 6428, 6439, 5, 228, + 0, 0, 6429, 6439, 5, 270, 0, 0, 6430, 6439, 5, 273, 0, 0, 6431, 6439, 5, + 347, 0, 0, 6432, 6439, 5, 394, 0, 0, 6433, 6439, 5, 415, 0, 0, 6434, 6439, + 5, 430, 0, 0, 6435, 6439, 5, 438, 0, 0, 6436, 6439, 5, 497, 0, 0, 6437, + 6439, 5, 515, 0, 0, 6438, 6422, 1, 0, 0, 0, 6438, 6423, 1, 0, 0, 0, 6438, + 6424, 1, 0, 0, 0, 6438, 6425, 1, 0, 0, 0, 6438, 6426, 1, 0, 0, 0, 6438, + 6427, 1, 0, 0, 0, 6438, 6428, 1, 0, 0, 0, 6438, 6429, 1, 0, 0, 0, 6438, + 6430, 1, 0, 0, 0, 6438, 6431, 1, 0, 0, 0, 6438, 6432, 1, 0, 0, 0, 6438, + 6433, 1, 0, 0, 0, 6438, 6434, 1, 0, 0, 0, 6438, 6435, 1, 0, 0, 0, 6438, + 6436, 1, 0, 0, 0, 6438, 6437, 1, 0, 0, 0, 6439, 409, 1, 0, 0, 0, 6440, + 6442, 5, 2, 0, 0, 6441, 6443, 3, 310, 155, 0, 6442, 6441, 1, 0, 0, 0, 6442, + 6443, 1, 0, 0, 0, 6443, 6445, 1, 0, 0, 0, 6444, 6446, 3, 304, 152, 0, 6445, + 6444, 1, 0, 0, 0, 6445, 6446, 1, 0, 0, 0, 6446, 6448, 1, 0, 0, 0, 6447, + 6449, 3, 412, 206, 0, 6448, 6447, 1, 0, 0, 0, 6448, 6449, 1, 0, 0, 0, 6449, + 6450, 1, 0, 0, 0, 6450, 6451, 5, 3, 0, 0, 6451, 411, 1, 0, 0, 0, 6452, + 6453, 3, 414, 207, 0, 6453, 6454, 3, 416, 208, 0, 6454, 6462, 1, 0, 0, + 0, 6455, 6456, 3, 414, 207, 0, 6456, 6457, 5, 41, 0, 0, 6457, 6458, 3, + 416, 208, 0, 6458, 6459, 5, 25, 0, 0, 6459, 6460, 3, 416, 208, 0, 6460, + 6462, 1, 0, 0, 0, 6461, 6452, 1, 0, 0, 0, 6461, 6455, 1, 0, 0, 0, 6462, + 413, 1, 0, 0, 0, 6463, 6464, 7, 57, 0, 0, 6464, 415, 1, 0, 0, 0, 6465, + 6466, 5, 504, 0, 0, 6466, 6473, 7, 58, 0, 0, 6467, 6468, 5, 108, 0, 0, + 6468, 6473, 5, 424, 0, 0, 6469, 6470, 3, 382, 191, 0, 6470, 6471, 7, 58, + 0, 0, 6471, 6473, 1, 0, 0, 0, 6472, 6465, 1, 0, 0, 0, 6472, 6467, 1, 0, + 0, 0, 6472, 6469, 1, 0, 0, 0, 6473, 417, 1, 0, 0, 0, 6474, 6479, 3, 464, + 232, 0, 6475, 6476, 5, 5, 0, 0, 6476, 6478, 3, 464, 232, 0, 6477, 6475, + 1, 0, 0, 0, 6478, 6481, 1, 0, 0, 0, 6479, 6477, 1, 0, 0, 0, 6479, 6480, + 1, 0, 0, 0, 6480, 419, 1, 0, 0, 0, 6481, 6479, 1, 0, 0, 0, 6482, 6484, + 5, 481, 0, 0, 6483, 6482, 1, 0, 0, 0, 6483, 6484, 1, 0, 0, 0, 6484, 6485, + 1, 0, 0, 0, 6485, 6488, 5, 345, 0, 0, 6486, 6489, 3, 464, 232, 0, 6487, + 6489, 3, 316, 158, 0, 6488, 6486, 1, 0, 0, 0, 6488, 6487, 1, 0, 0, 0, 6489, + 6496, 1, 0, 0, 0, 6490, 6492, 5, 481, 0, 0, 6491, 6490, 1, 0, 0, 0, 6491, + 6492, 1, 0, 0, 0, 6492, 6493, 1, 0, 0, 0, 6493, 6494, 5, 346, 0, 0, 6494, + 6496, 3, 316, 158, 0, 6495, 6483, 1, 0, 0, 0, 6495, 6491, 1, 0, 0, 0, 6496, + 421, 1, 0, 0, 0, 6497, 6550, 5, 326, 0, 0, 6498, 6499, 7, 59, 0, 0, 6499, + 6550, 5, 569, 0, 0, 6500, 6550, 3, 470, 235, 0, 6501, 6550, 3, 426, 213, + 0, 6502, 6504, 5, 44, 0, 0, 6503, 6502, 1, 0, 0, 0, 6503, 6504, 1, 0, 0, + 0, 6504, 6505, 1, 0, 0, 0, 6505, 6550, 5, 569, 0, 0, 6506, 6550, 5, 570, + 0, 0, 6507, 6509, 5, 7, 0, 0, 6508, 6510, 3, 422, 211, 0, 6509, 6508, 1, + 0, 0, 0, 6509, 6510, 1, 0, 0, 0, 6510, 6515, 1, 0, 0, 0, 6511, 6512, 5, + 4, 0, 0, 6512, 6514, 3, 422, 211, 0, 6513, 6511, 1, 0, 0, 0, 6514, 6517, + 1, 0, 0, 0, 6515, 6513, 1, 0, 0, 0, 6515, 6516, 1, 0, 0, 0, 6516, 6518, + 1, 0, 0, 0, 6517, 6515, 1, 0, 0, 0, 6518, 6550, 5, 8, 0, 0, 6519, 6524, + 5, 9, 0, 0, 6520, 6521, 3, 422, 211, 0, 6521, 6522, 5, 562, 0, 0, 6522, + 6523, 3, 422, 211, 0, 6523, 6525, 1, 0, 0, 0, 6524, 6520, 1, 0, 0, 0, 6524, + 6525, 1, 0, 0, 0, 6525, 6533, 1, 0, 0, 0, 6526, 6527, 5, 4, 0, 0, 6527, + 6528, 3, 422, 211, 0, 6528, 6529, 5, 562, 0, 0, 6529, 6530, 3, 422, 211, + 0, 6530, 6532, 1, 0, 0, 0, 6531, 6526, 1, 0, 0, 0, 6532, 6535, 1, 0, 0, + 0, 6533, 6531, 1, 0, 0, 0, 6533, 6534, 1, 0, 0, 0, 6534, 6536, 1, 0, 0, + 0, 6535, 6533, 1, 0, 0, 0, 6536, 6550, 5, 10, 0, 0, 6537, 6538, 5, 9, 0, + 0, 6538, 6543, 3, 422, 211, 0, 6539, 6540, 5, 4, 0, 0, 6540, 6542, 3, 422, + 211, 0, 6541, 6539, 1, 0, 0, 0, 6542, 6545, 1, 0, 0, 0, 6543, 6541, 1, + 0, 0, 0, 6543, 6544, 1, 0, 0, 0, 6544, 6546, 1, 0, 0, 0, 6545, 6543, 1, + 0, 0, 0, 6546, 6547, 5, 10, 0, 0, 6547, 6550, 1, 0, 0, 0, 6548, 6550, 5, + 359, 0, 0, 6549, 6497, 1, 0, 0, 0, 6549, 6498, 1, 0, 0, 0, 6549, 6500, + 1, 0, 0, 0, 6549, 6501, 1, 0, 0, 0, 6549, 6503, 1, 0, 0, 0, 6549, 6506, + 1, 0, 0, 0, 6549, 6507, 1, 0, 0, 0, 6549, 6519, 1, 0, 0, 0, 6549, 6537, + 1, 0, 0, 0, 6549, 6548, 1, 0, 0, 0, 6550, 423, 1, 0, 0, 0, 6551, 6552, + 7, 60, 0, 0, 6552, 425, 1, 0, 0, 0, 6553, 6554, 7, 47, 0, 0, 6554, 427, + 1, 0, 0, 0, 6555, 6556, 5, 534, 0, 0, 6556, 6557, 3, 382, 191, 0, 6557, + 6558, 5, 485, 0, 0, 6558, 6559, 3, 382, 191, 0, 6559, 429, 1, 0, 0, 0, + 6560, 6561, 5, 243, 0, 0, 6561, 6562, 3, 382, 191, 0, 6562, 6563, 3, 432, + 216, 0, 6563, 431, 1, 0, 0, 0, 6564, 6565, 7, 61, 0, 0, 6565, 433, 1, 0, + 0, 0, 6566, 6571, 3, 436, 218, 0, 6567, 6569, 5, 325, 0, 0, 6568, 6567, + 1, 0, 0, 0, 6568, 6569, 1, 0, 0, 0, 6569, 6570, 1, 0, 0, 0, 6570, 6572, + 5, 326, 0, 0, 6571, 6568, 1, 0, 0, 0, 6571, 6572, 1, 0, 0, 0, 6572, 435, + 1, 0, 0, 0, 6573, 6574, 5, 28, 0, 0, 6574, 6575, 5, 546, 0, 0, 6575, 6576, + 3, 436, 218, 0, 6576, 6577, 5, 548, 0, 0, 6577, 6620, 1, 0, 0, 0, 6578, + 6579, 5, 287, 0, 0, 6579, 6580, 5, 546, 0, 0, 6580, 6581, 3, 436, 218, + 0, 6581, 6582, 5, 4, 0, 0, 6582, 6583, 3, 436, 218, 0, 6583, 6584, 5, 548, + 0, 0, 6584, 6620, 1, 0, 0, 0, 6585, 6586, 5, 464, 0, 0, 6586, 6587, 5, + 546, 0, 0, 6587, 6588, 3, 440, 220, 0, 6588, 6589, 5, 548, 0, 0, 6589, + 6620, 1, 0, 0, 0, 6590, 6620, 3, 444, 222, 0, 6591, 6592, 5, 17, 0, 0, + 6592, 6593, 5, 546, 0, 0, 6593, 6594, 3, 408, 204, 0, 6594, 6595, 5, 2, + 0, 0, 6595, 6600, 3, 434, 217, 0, 6596, 6597, 5, 4, 0, 0, 6597, 6599, 3, + 434, 217, 0, 6598, 6596, 1, 0, 0, 0, 6599, 6602, 1, 0, 0, 0, 6600, 6598, + 1, 0, 0, 0, 6600, 6601, 1, 0, 0, 0, 6601, 6603, 1, 0, 0, 0, 6602, 6600, + 1, 0, 0, 0, 6603, 6604, 5, 3, 0, 0, 6604, 6605, 5, 548, 0, 0, 6605, 6620, + 1, 0, 0, 0, 6606, 6617, 3, 438, 219, 0, 6607, 6608, 5, 2, 0, 0, 6608, 6613, + 7, 62, 0, 0, 6609, 6610, 5, 4, 0, 0, 6610, 6612, 5, 575, 0, 0, 6611, 6609, + 1, 0, 0, 0, 6612, 6615, 1, 0, 0, 0, 6613, 6611, 1, 0, 0, 0, 6613, 6614, + 1, 0, 0, 0, 6614, 6616, 1, 0, 0, 0, 6615, 6613, 1, 0, 0, 0, 6616, 6618, + 5, 3, 0, 0, 6617, 6607, 1, 0, 0, 0, 6617, 6618, 1, 0, 0, 0, 6618, 6620, + 1, 0, 0, 0, 6619, 6573, 1, 0, 0, 0, 6619, 6578, 1, 0, 0, 0, 6619, 6585, + 1, 0, 0, 0, 6619, 6590, 1, 0, 0, 0, 6619, 6591, 1, 0, 0, 0, 6619, 6606, + 1, 0, 0, 0, 6620, 437, 1, 0, 0, 0, 6621, 6655, 5, 488, 0, 0, 6622, 6655, + 5, 446, 0, 0, 6623, 6655, 7, 56, 0, 0, 6624, 6655, 5, 42, 0, 0, 6625, 6655, + 5, 263, 0, 0, 6626, 6655, 5, 53, 0, 0, 6627, 6655, 5, 190, 0, 0, 6628, + 6655, 5, 150, 0, 0, 6629, 6655, 5, 117, 0, 0, 6630, 6655, 5, 118, 0, 0, + 6631, 6655, 5, 486, 0, 0, 6632, 6655, 5, 120, 0, 0, 6633, 6655, 5, 119, + 0, 0, 6634, 6655, 5, 122, 0, 0, 6635, 6655, 5, 121, 0, 0, 6636, 6655, 5, + 47, 0, 0, 6637, 6655, 5, 377, 0, 0, 6638, 6655, 5, 220, 0, 0, 6639, 6655, + 5, 17, 0, 0, 6640, 6655, 5, 463, 0, 0, 6641, 6655, 5, 257, 0, 0, 6642, + 6655, 5, 258, 0, 0, 6643, 6655, 5, 483, 0, 0, 6644, 6655, 5, 521, 0, 0, + 6645, 6655, 5, 72, 0, 0, 6646, 6655, 5, 127, 0, 0, 6647, 6655, 5, 128, + 0, 0, 6648, 6655, 5, 129, 0, 0, 6649, 6655, 5, 247, 0, 0, 6650, 6655, 5, + 248, 0, 0, 6651, 6655, 5, 520, 0, 0, 6652, 6655, 5, 524, 0, 0, 6653, 6655, + 5, 20, 0, 0, 6654, 6621, 1, 0, 0, 0, 6654, 6622, 1, 0, 0, 0, 6654, 6623, + 1, 0, 0, 0, 6654, 6624, 1, 0, 0, 0, 6654, 6625, 1, 0, 0, 0, 6654, 6626, + 1, 0, 0, 0, 6654, 6627, 1, 0, 0, 0, 6654, 6628, 1, 0, 0, 0, 6654, 6629, + 1, 0, 0, 0, 6654, 6630, 1, 0, 0, 0, 6654, 6631, 1, 0, 0, 0, 6654, 6632, + 1, 0, 0, 0, 6654, 6633, 1, 0, 0, 0, 6654, 6634, 1, 0, 0, 0, 6654, 6635, + 1, 0, 0, 0, 6654, 6636, 1, 0, 0, 0, 6654, 6637, 1, 0, 0, 0, 6654, 6638, + 1, 0, 0, 0, 6654, 6639, 1, 0, 0, 0, 6654, 6640, 1, 0, 0, 0, 6654, 6641, + 1, 0, 0, 0, 6654, 6642, 1, 0, 0, 0, 6654, 6643, 1, 0, 0, 0, 6654, 6644, + 1, 0, 0, 0, 6654, 6645, 1, 0, 0, 0, 6654, 6646, 1, 0, 0, 0, 6654, 6647, + 1, 0, 0, 0, 6654, 6648, 1, 0, 0, 0, 6654, 6649, 1, 0, 0, 0, 6654, 6650, + 1, 0, 0, 0, 6654, 6651, 1, 0, 0, 0, 6654, 6652, 1, 0, 0, 0, 6654, 6653, + 1, 0, 0, 0, 6655, 439, 1, 0, 0, 0, 6656, 6661, 3, 442, 221, 0, 6657, 6658, + 5, 4, 0, 0, 6658, 6660, 3, 442, 221, 0, 6659, 6657, 1, 0, 0, 0, 6660, 6663, + 1, 0, 0, 0, 6661, 6659, 1, 0, 0, 0, 6661, 6662, 1, 0, 0, 0, 6662, 441, + 1, 0, 0, 0, 6663, 6661, 1, 0, 0, 0, 6664, 6665, 3, 464, 232, 0, 6665, 6666, + 5, 562, 0, 0, 6666, 6668, 3, 436, 218, 0, 6667, 6669, 3, 452, 226, 0, 6668, + 6667, 1, 0, 0, 0, 6668, 6669, 1, 0, 0, 0, 6669, 443, 1, 0, 0, 0, 6670, + 6671, 5, 524, 0, 0, 6671, 6672, 5, 546, 0, 0, 6672, 6673, 3, 446, 223, + 0, 6673, 6674, 5, 4, 0, 0, 6674, 6675, 3, 326, 163, 0, 6675, 6676, 5, 548, + 0, 0, 6676, 6689, 1, 0, 0, 0, 6677, 6678, 5, 524, 0, 0, 6678, 6679, 5, + 546, 0, 0, 6679, 6680, 3, 446, 223, 0, 6680, 6681, 5, 548, 0, 0, 6681, + 6689, 1, 0, 0, 0, 6682, 6683, 5, 524, 0, 0, 6683, 6684, 5, 546, 0, 0, 6684, + 6685, 3, 326, 163, 0, 6685, 6686, 5, 548, 0, 0, 6686, 6689, 1, 0, 0, 0, + 6687, 6689, 5, 524, 0, 0, 6688, 6670, 1, 0, 0, 0, 6688, 6677, 1, 0, 0, + 0, 6688, 6682, 1, 0, 0, 0, 6688, 6687, 1, 0, 0, 0, 6689, 445, 1, 0, 0, + 0, 6690, 6695, 3, 448, 224, 0, 6691, 6692, 5, 4, 0, 0, 6692, 6694, 3, 448, + 224, 0, 6693, 6691, 1, 0, 0, 0, 6694, 6697, 1, 0, 0, 0, 6695, 6693, 1, + 0, 0, 0, 6695, 6696, 1, 0, 0, 0, 6696, 447, 1, 0, 0, 0, 6697, 6695, 1, + 0, 0, 0, 6698, 6700, 3, 450, 225, 0, 6699, 6698, 1, 0, 0, 0, 6699, 6700, + 1, 0, 0, 0, 6700, 6701, 1, 0, 0, 0, 6701, 6702, 5, 569, 0, 0, 6702, 6703, + 5, 562, 0, 0, 6703, 6705, 3, 436, 218, 0, 6704, 6706, 3, 452, 226, 0, 6705, + 6704, 1, 0, 0, 0, 6705, 6706, 1, 0, 0, 0, 6706, 449, 1, 0, 0, 0, 6707, + 6708, 7, 63, 0, 0, 6708, 451, 1, 0, 0, 0, 6709, 6710, 5, 85, 0, 0, 6710, + 6711, 5, 569, 0, 0, 6711, 453, 1, 0, 0, 0, 6712, 6713, 5, 474, 0, 0, 6713, + 6715, 5, 2, 0, 0, 6714, 6716, 3, 456, 228, 0, 6715, 6714, 1, 0, 0, 0, 6715, + 6716, 1, 0, 0, 0, 6716, 6717, 1, 0, 0, 0, 6717, 6720, 5, 3, 0, 0, 6718, + 6719, 5, 398, 0, 0, 6719, 6721, 5, 575, 0, 0, 6720, 6718, 1, 0, 0, 0, 6720, + 6721, 1, 0, 0, 0, 6721, 455, 1, 0, 0, 0, 6722, 6723, 5, 575, 0, 0, 6723, + 6727, 5, 354, 0, 0, 6724, 6725, 5, 575, 0, 0, 6725, 6727, 5, 425, 0, 0, + 6726, 6722, 1, 0, 0, 0, 6726, 6724, 1, 0, 0, 0, 6727, 457, 1, 0, 0, 0, + 6728, 6729, 5, 193, 0, 0, 6729, 6730, 5, 528, 0, 0, 6730, 6731, 5, 29, + 0, 0, 6731, 6732, 5, 329, 0, 0, 6732, 6739, 7, 18, 0, 0, 6733, 6734, 5, + 193, 0, 0, 6734, 6735, 5, 486, 0, 0, 6735, 6736, 5, 29, 0, 0, 6736, 6737, + 5, 329, 0, 0, 6737, 6739, 7, 18, 0, 0, 6738, 6728, 1, 0, 0, 0, 6738, 6733, + 1, 0, 0, 0, 6739, 459, 1, 0, 0, 0, 6740, 6741, 3, 464, 232, 0, 6741, 6742, + 3, 462, 231, 0, 6742, 461, 1, 0, 0, 0, 6743, 6744, 5, 551, 0, 0, 6744, + 6746, 3, 464, 232, 0, 6745, 6743, 1, 0, 0, 0, 6746, 6747, 1, 0, 0, 0, 6747, + 6745, 1, 0, 0, 0, 6747, 6748, 1, 0, 0, 0, 6748, 6751, 1, 0, 0, 0, 6749, + 6751, 1, 0, 0, 0, 6750, 6745, 1, 0, 0, 0, 6750, 6749, 1, 0, 0, 0, 6751, + 463, 1, 0, 0, 0, 6752, 6753, 3, 466, 233, 0, 6753, 465, 1, 0, 0, 0, 6754, + 6758, 5, 579, 0, 0, 6755, 6758, 3, 468, 234, 0, 6756, 6758, 3, 472, 236, + 0, 6757, 6754, 1, 0, 0, 0, 6757, 6755, 1, 0, 0, 0, 6757, 6756, 1, 0, 0, + 0, 6758, 467, 1, 0, 0, 0, 6759, 6760, 5, 580, 0, 0, 6760, 469, 1, 0, 0, + 0, 6761, 6763, 5, 551, 0, 0, 6762, 6761, 1, 0, 0, 0, 6762, 6763, 1, 0, + 0, 0, 6763, 6764, 1, 0, 0, 0, 6764, 6770, 5, 575, 0, 0, 6765, 6767, 5, + 551, 0, 0, 6766, 6765, 1, 0, 0, 0, 6766, 6767, 1, 0, 0, 0, 6767, 6768, + 1, 0, 0, 0, 6768, 6770, 7, 64, 0, 0, 6769, 6762, 1, 0, 0, 0, 6769, 6766, + 1, 0, 0, 0, 6770, 471, 1, 0, 0, 0, 6771, 6772, 7, 65, 0, 0, 6772, 473, + 1, 0, 0, 0, 959, 477, 481, 486, 491, 497, 505, 509, 514, 531, 534, 542, + 545, 553, 560, 567, 576, 583, 590, 594, 596, 599, 603, 628, 636, 643, 646, + 650, 653, 655, 658, 662, 666, 674, 681, 685, 687, 690, 693, 704, 718, 726, + 733, 740, 745, 771, 777, 788, 790, 794, 799, 801, 803, 806, 826, 832, 857, + 878, 887, 890, 896, 900, 906, 909, 914, 917, 923, 927, 930, 938, 941, 944, + 947, 953, 958, 961, 964, 967, 973, 976, 984, 986, 997, 1002, 1005, 1008, + 1015, 1018, 1023, 1026, 1032, 1036, 1046, 1050, 1053, 1059, 1062, 1064, + 1070, 1077, 1084, 1089, 1096, 1102, 1106, 1112, 1115, 1119, 1124, 1132, + 1134, 1138, 1141, 1148, 1153, 1155, 1157, 1164, 1167, 1171, 1174, 1177, + 1182, 1188, 1195, 1199, 1202, 1211, 1216, 1222, 1230, 1232, 1239, 1244, + 1252, 1257, 1260, 1267, 1273, 1277, 1280, 1288, 1299, 1312, 1316, 1321, + 1326, 1333, 1341, 1344, 1348, 1356, 1364, 1371, 1374, 1381, 1385, 1392, + 1400, 1403, 1409, 1414, 1421, 1424, 1428, 1435, 1440, 1447, 1458, 1465, + 1469, 1476, 1480, 1485, 1494, 1500, 1504, 1511, 1524, 1531, 1535, 1543, + 1547, 1556, 1560, 1569, 1573, 1582, 1586, 1595, 1599, 1601, 1608, 1626, + 1630, 1634, 1659, 1662, 1669, 1685, 1691, 1720, 1730, 1734, 1738, 1750, + 1763, 1782, 1805, 1811, 1823, 1826, 1829, 1837, 1852, 1858, 1860, 1874, + 1881, 1888, 1895, 1903, 1911, 1916, 1922, 1930, 1938, 1946, 1951, 1955, + 1961, 1965, 1969, 1974, 1979, 1987, 1997, 2005, 2014, 2016, 2022, 2029, + 2036, 2045, 2054, 2063, 2072, 2075, 2079, 2083, 2094, 2098, 2101, 2104, + 2107, 2117, 2120, 2129, 2132, 2135, 2138, 2146, 2152, 2155, 2161, 2164, + 2167, 2170, 2179, 2185, 2190, 2196, 2201, 2205, 2208, 2213, 2217, 2222, + 2227, 2231, 2247, 2253, 2256, 2269, 2282, 2286, 2290, 2297, 2302, 2308, + 2311, 2314, 2318, 2323, 2326, 2342, 2346, 2359, 2365, 2369, 2376, 2381, + 2390, 2392, 2400, 2402, 2408, 2425, 2429, 2432, 2435, 2448, 2468, 2471, + 2474, 2478, 2483, 2486, 2489, 2492, 2499, 2502, 2505, 2509, 2513, 2518, + 2521, 2532, 2535, 2540, 2547, 2554, 2557, 2566, 2572, 2578, 2582, 2595, + 2608, 2612, 2619, 2625, 2628, 2634, 2638, 2643, 2646, 2650, 2655, 2658, + 2665, 2668, 2674, 2677, 2684, 2687, 2690, 2693, 2701, 2709, 2715, 2718, + 2726, 2733, 2739, 2742, 2745, 2748, 2759, 2761, 2763, 2771, 2778, 2780, + 2796, 2799, 2803, 2835, 2843, 2845, 2853, 2856, 2874, 2878, 2884, 2895, + 2907, 2910, 2924, 2929, 2932, 2939, 2946, 2954, 2957, 2960, 2963, 2966, + 2975, 2989, 2994, 2997, 3004, 3006, 3012, 3016, 3021, 3025, 3028, 3031, + 3039, 3043, 3050, 3053, 3056, 3064, 3076, 3100, 3108, 3114, 3118, 3124, + 3130, 3143, 3145, 3153, 3164, 3170, 3176, 3179, 3185, 3188, 3195, 3205, + 3212, 3218, 3231, 3235, 3244, 3254, 3258, 3260, 3278, 3282, 3295, 3299, + 3316, 3326, 3332, 3340, 3347, 3354, 3357, 3369, 3373, 3390, 3415, 3434, + 3441, 3449, 3472, 3474, 3480, 3484, 3490, 3494, 3500, 3504, 3509, 3513, + 3516, 3519, 3522, 3526, 3529, 3535, 3541, 3543, 3547, 3551, 3554, 3557, + 3560, 3564, 3568, 3571, 3574, 3577, 3579, 3589, 3603, 3610, 3618, 3630, + 3648, 3655, 3665, 3667, 3671, 3674, 3681, 3691, 3695, 3704, 3714, 3737, + 3748, 3760, 3769, 3782, 3786, 3793, 3796, 3799, 3805, 3808, 3811, 3819, + 3822, 3828, 3831, 3837, 3840, 3843, 3849, 3852, 3856, 3864, 3869, 3871, + 3873, 3876, 3880, 3885, 3889, 3894, 3898, 3906, 3915, 3919, 3922, 3925, + 3932, 3935, 3960, 3968, 3977, 3982, 3984, 3986, 4002, 4006, 4016, 4019, + 4031, 4038, 4045, 4051, 4053, 4060, 4067, 4074, 4081, 4088, 4095, 4101, + 4104, 4110, 4113, 4116, 4135, 4147, 4155, 4172, 4177, 4187, 4192, 4199, + 4206, 4213, 4224, 4229, 4232, 4246, 4250, 4256, 4259, 4265, 4269, 4280, + 4287, 4298, 4310, 4313, 4334, 4337, 4343, 4355, 4363, 4370, 4377, 4379, + 4386, 4393, 4397, 4403, 4408, 4410, 4418, 4420, 4427, 4429, 4433, 4439, + 4441, 4444, 4452, 4459, 4465, 4470, 4474, 4488, 4493, 4506, 4508, 4517, + 4525, 4529, 4534, 4539, 4544, 4552, 4561, 4564, 4570, 4572, 4580, 4587, + 4601, 4605, 4610, 4616, 4624, 4631, 4634, 4638, 4643, 4648, 4655, 4667, + 4673, 4687, 4690, 4695, 4703, 4706, 4711, 4716, 4726, 4733, 4736, 4739, + 4749, 4754, 4760, 4766, 4772, 4777, 4782, 4785, 4788, 4791, 4794, 4797, + 4800, 4803, 4806, 4809, 4812, 4819, 4826, 4829, 4832, 4835, 4838, 4840, + 4854, 4861, 4867, 4871, 4876, 4883, 4888, 4897, 4899, 4905, 4908, 4912, + 4915, 4918, 4932, 4961, 4996, 4998, 5007, 5011, 5020, 5026, 5032, 5035, + 5038, 5041, 5044, 5052, 5060, 5063, 5066, 5077, 5083, 5086, 5088, 5099, + 5103, 5106, 5109, 5112, 5115, 5118, 5121, 5129, 5134, 5147, 5154, 5167, + 5172, 5177, 5181, 5197, 5204, 5210, 5214, 5219, 5226, 5230, 5246, 5257, + 5268, 5273, 5277, 5290, 5293, 5303, 5306, 5317, 5327, 5332, 5334, 5342, + 5345, 5357, 5362, 5371, 5376, 5381, 5390, 5395, 5397, 5401, 5405, 5410, + 5412, 5415, 5421, 5428, 5440, 5443, 5453, 5457, 5460, 5469, 5474, 5478, + 5490, 5498, 5505, 5509, 5514, 5518, 5522, 5532, 5538, 5549, 5557, 5563, + 5566, 5569, 5572, 5575, 5579, 5582, 5587, 5597, 5603, 5612, 5627, 5636, + 5640, 5643, 5647, 5649, 5656, 5664, 5670, 5677, 5683, 5686, 5690, 5697, + 5700, 5703, 5710, 5712, 5717, 5721, 5734, 5736, 5738, 5747, 5749, 5753, + 5760, 5767, 5773, 5780, 5784, 5791, 5798, 5804, 5810, 5818, 5824, 5841, + 5847, 5852, 5860, 5866, 5868, 5876, 5882, 5888, 5895, 5903, 5906, 5917, + 5928, 5933, 5936, 5943, 5950, 5962, 5968, 5990, 5994, 6008, 6010, 6019, + 6022, 6029, 6032, 6040, 6045, 6051, 6054, 6059, 6067, 6076, 6083, 6088, + 6091, 6097, 6118, 6120, 6135, 6139, 6148, 6152, 6176, 6185, 6195, 6200, + 6221, 6227, 6237, 6240, 6244, 6249, 6262, 6265, 6278, 6299, 6303, 6314, + 6322, 6327, 6339, 6351, 6353, 6355, 6368, 6373, 6375, 6380, 6386, 6393, + 6403, 6406, 6408, 6413, 6418, 6438, 6442, 6445, 6448, 6461, 6472, 6479, + 6483, 6488, 6491, 6495, 6503, 6509, 6515, 6524, 6533, 6543, 6549, 6568, + 6571, 6600, 6613, 6617, 6619, 6654, 6661, 6668, 6688, 6695, 6699, 6705, + 6715, 6720, 6726, 6738, 6747, 6750, 6757, 6762, 6766, 6769, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// DorisParserInit initializes any static state used to implement DorisParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewDorisParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func DorisParserInit() { + staticData := &DorisParserParserStaticData + staticData.once.Do(dorisparserParserInit) +} + +// NewDorisParser produces a new parser instance for the optional input antlr.TokenStream. +func NewDorisParser(input antlr.TokenStream) *DorisParser { + DorisParserInit() + this := new(DorisParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &DorisParserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + this.RuleNames = staticData.RuleNames + this.LiteralNames = staticData.LiteralNames + this.SymbolicNames = staticData.SymbolicNames + this.GrammarFileName = "DorisParser.g4" + + return this +} + +// DorisParser tokens. +const ( + DorisParserEOF = antlr.TokenEOF + DorisParserSEMICOLON = 1 + DorisParserLEFT_PAREN = 2 + DorisParserRIGHT_PAREN = 3 + DorisParserCOMMA = 4 + DorisParserDOT = 5 + DorisParserDOTDOTDOT = 6 + DorisParserLEFT_BRACKET = 7 + DorisParserRIGHT_BRACKET = 8 + DorisParserLEFT_BRACE = 9 + DorisParserRIGHT_BRACE = 10 + DorisParserACCOUNT_LOCK = 11 + DorisParserACCOUNT_UNLOCK = 12 + DorisParserACTIONS = 13 + DorisParserADD = 14 + DorisParserADMIN = 15 + DorisParserAFTER = 16 + DorisParserAGG_STATE = 17 + DorisParserAGGREGATE = 18 + DorisParserALIAS = 19 + DorisParserALL = 20 + DorisParserALTER = 21 + DorisParserANALYZE = 22 + DorisParserANALYZED = 23 + DorisParserANALYZER = 24 + DorisParserAND = 25 + DorisParserANTI = 26 + DorisParserAPPEND = 27 + DorisParserARRAY = 28 + DorisParserAS = 29 + DorisParserASC = 30 + DorisParserAT = 31 + DorisParserAUTHORS = 32 + DorisParserAUTO = 33 + DorisParserAUTO_INCREMENT = 34 + DorisParserALWAYS = 35 + DorisParserBACKEND = 36 + DorisParserBACKENDS = 37 + DorisParserBACKUP = 38 + DorisParserBEGIN = 39 + DorisParserBELONG = 40 + DorisParserBETWEEN = 41 + DorisParserBIGINT = 42 + DorisParserBIN = 43 + DorisParserBINARY = 44 + DorisParserBINLOG = 45 + DorisParserBITAND = 46 + DorisParserBITMAP = 47 + DorisParserBITMAP_EMPTY = 48 + DorisParserBITMAP_UNION = 49 + DorisParserBITOR = 50 + DorisParserBITXOR = 51 + DorisParserBLOB = 52 + DorisParserBOOLEAN = 53 + DorisParserBOTH = 54 + DorisParserBRANCH = 55 + DorisParserBRIEF = 56 + DorisParserBROKER = 57 + DorisParserBUCKETS = 58 + DorisParserBUILD = 59 + DorisParserBUILTIN = 60 + DorisParserBULK = 61 + DorisParserBY = 62 + DorisParserCACHE = 63 + DorisParserCACHED = 64 + DorisParserCALL = 65 + DorisParserCANCEL = 66 + DorisParserCASE = 67 + DorisParserCAST = 68 + DorisParserCATALOG = 69 + DorisParserCATALOGS = 70 + DorisParserCHAIN = 71 + DorisParserCHAR = 72 + DorisParserCHARSET = 73 + DorisParserCHAR_FILTER = 74 + DorisParserCHECK = 75 + DorisParserCLEAN = 76 + DorisParserCLUSTER = 77 + DorisParserCLUSTERS = 78 + DorisParserCOLLATE = 79 + DorisParserCOLLATION = 80 + DorisParserCOLLECT = 81 + DorisParserCOLOCATE = 82 + DorisParserCOLUMN = 83 + DorisParserCOLUMNS = 84 + DorisParserCOMMENT = 85 + DorisParserCOMMIT = 86 + DorisParserCOMMITTED = 87 + DorisParserCOMPACT = 88 + DorisParserCOMPLETE = 89 + DorisParserCOMPRESS_TYPE = 90 + DorisParserCOMPUTE = 91 + DorisParserCONDITIONS = 92 + DorisParserCONFIG = 93 + DorisParserCONNECTION = 94 + DorisParserCONNECTION_ID = 95 + DorisParserCONSISTENT = 96 + DorisParserCONSTRAINT = 97 + DorisParserCONSTRAINTS = 98 + DorisParserCONVERT = 99 + DorisParserCONVERT_LSC = 100 + DorisParserCOPY = 101 + DorisParserCOUNT = 102 + DorisParserCREATE = 103 + DorisParserCREATION = 104 + DorisParserCRON = 105 + DorisParserCROSS = 106 + DorisParserCUBE = 107 + DorisParserCURRENT = 108 + DorisParserCURRENT_CATALOG = 109 + DorisParserCURRENT_DATE = 110 + DorisParserCURRENT_TIME = 111 + DorisParserCURRENT_TIMESTAMP = 112 + DorisParserCURRENT_USER = 113 + DorisParserDATA = 114 + DorisParserDATABASE = 115 + DorisParserDATABASES = 116 + DorisParserDATE = 117 + DorisParserDATETIME = 118 + DorisParserDATETIMEV2 = 119 + DorisParserDATEV2 = 120 + DorisParserDATETIMEV1 = 121 + DorisParserDATEV1 = 122 + DorisParserDAY = 123 + DorisParserDAY_SECOND = 124 + DorisParserDAYS = 125 + DorisParserDAY_HOUR = 126 + DorisParserDECIMAL = 127 + DorisParserDECIMALV2 = 128 + DorisParserDECIMALV3 = 129 + DorisParserDECOMMISSION = 130 + DorisParserDEFAULT = 131 + DorisParserDEFERRED = 132 + DorisParserDELETE = 133 + DorisParserDEMAND = 134 + DorisParserDESC = 135 + DorisParserDESCRIBE = 136 + DorisParserDIAGNOSE = 137 + DorisParserDIAGNOSIS = 138 + DorisParserDICTIONARIES = 139 + DorisParserDICTIONARY = 140 + DorisParserDISK = 141 + DorisParserDISTINCT = 142 + DorisParserDISTINCTPC = 143 + DorisParserDISTINCTPCSA = 144 + DorisParserDISTRIBUTED = 145 + DorisParserDISTRIBUTION = 146 + DorisParserDIV = 147 + DorisParserDO = 148 + DorisParserDORIS_INTERNAL_TABLE_ID = 149 + DorisParserDOUBLE = 150 + DorisParserDROP = 151 + DorisParserDROPP = 152 + DorisParserDUAL = 153 + DorisParserDUMP = 154 + DorisParserDUPLICATE = 155 + DorisParserDYNAMIC = 156 + DorisParserE = 157 + DorisParserELSE = 158 + DorisParserENABLE = 159 + DorisParserENCRYPTION = 160 + DorisParserENCRYPTKEY = 161 + DorisParserENCRYPTKEYS = 162 + DorisParserEND = 163 + DorisParserENDS = 164 + DorisParserENGINE = 165 + DorisParserENGINES = 166 + DorisParserENTER = 167 + DorisParserERRORS = 168 + DorisParserESCAPE = 169 + DorisParserEVENTS = 170 + DorisParserEVERY = 171 + DorisParserEXCEPT = 172 + DorisParserEXCLUDE = 173 + DorisParserEXECUTE = 174 + DorisParserEXISTS = 175 + DorisParserEXPIRED = 176 + DorisParserEXPLAIN = 177 + DorisParserEXPORT = 178 + DorisParserEXTENDED = 179 + DorisParserEXTERNAL = 180 + DorisParserEXTRACT = 181 + DorisParserFAILED_LOGIN_ATTEMPTS = 182 + DorisParserFALSE = 183 + DorisParserFAST = 184 + DorisParserFEATURE = 185 + DorisParserFIELDS = 186 + DorisParserFILE = 187 + DorisParserFILTER = 188 + DorisParserFIRST = 189 + DorisParserFLOAT = 190 + DorisParserFOLLOWER = 191 + DorisParserFOLLOWING = 192 + DorisParserFOR = 193 + DorisParserFOREIGN = 194 + DorisParserFORCE = 195 + DorisParserFORMAT = 196 + DorisParserFREE = 197 + DorisParserFROM = 198 + DorisParserFRONTEND = 199 + DorisParserFRONTENDS = 200 + DorisParserFULL = 201 + DorisParserFUNCTION = 202 + DorisParserFUNCTIONS = 203 + DorisParserGENERATED = 204 + DorisParserGENERIC = 205 + DorisParserGLOBAL = 206 + DorisParserGRANT = 207 + DorisParserGRANTS = 208 + DorisParserGRAPH = 209 + DorisParserGROUP = 210 + DorisParserGROUPING = 211 + DorisParserGROUPS = 212 + DorisParserGROUP_CONCAT = 213 + DorisParserHASH = 214 + DorisParserHASH_MAP = 215 + DorisParserHAVING = 216 + DorisParserHDFS = 217 + DorisParserHELP = 218 + DorisParserHISTOGRAM = 219 + DorisParserHLL = 220 + DorisParserHLL_UNION = 221 + DorisParserHOSTNAME = 222 + DorisParserHOTSPOT = 223 + DorisParserHOUR = 224 + DorisParserHOURS = 225 + DorisParserHUB = 226 + DorisParserIDENTIFIED = 227 + DorisParserIF = 228 + DorisParserIGNORE = 229 + DorisParserIMMEDIATE = 230 + DorisParserIN = 231 + DorisParserINCREMENTAL = 232 + DorisParserINDEX = 233 + DorisParserINDEXES = 234 + DorisParserINFILE = 235 + DorisParserINNER = 236 + DorisParserINSERT = 237 + DorisParserINSTALL = 238 + DorisParserINT = 239 + DorisParserINTEGER = 240 + DorisParserINTERMEDIATE = 241 + DorisParserINTERSECT = 242 + DorisParserINTERVAL = 243 + DorisParserINTO = 244 + DorisParserINVERTED = 245 + DorisParserIP_TRIE = 246 + DorisParserIPV4 = 247 + DorisParserIPV6 = 248 + DorisParserIS = 249 + DorisParserIS_NOT_NULL_PRED = 250 + DorisParserIS_NULL_PRED = 251 + DorisParserISNULL = 252 + DorisParserISOLATION = 253 + DorisParserJOB = 254 + DorisParserJOBS = 255 + DorisParserJOIN = 256 + DorisParserJSON = 257 + DorisParserJSONB = 258 + DorisParserKEY = 259 + DorisParserKEYS = 260 + DorisParserKILL = 261 + DorisParserLABEL = 262 + DorisParserLARGEINT = 263 + DorisParserLAYOUT = 264 + DorisParserLAST = 265 + DorisParserLATERAL = 266 + DorisParserLDAP = 267 + DorisParserLDAP_ADMIN_PASSWORD = 268 + DorisParserLEADING = 269 + DorisParserLEFT = 270 + DorisParserLESS = 271 + DorisParserLEVEL = 272 + DorisParserLIKE = 273 + DorisParserLIMIT = 274 + DorisParserLINES = 275 + DorisParserLINK = 276 + DorisParserLIST = 277 + DorisParserLOAD = 278 + DorisParserLOCAL = 279 + DorisParserLOCALTIME = 280 + DorisParserLOCALTIMESTAMP = 281 + DorisParserLOCATION = 282 + DorisParserLOCK = 283 + DorisParserLOGICAL = 284 + DorisParserLOW_PRIORITY = 285 + DorisParserMANUAL = 286 + DorisParserMAP = 287 + DorisParserMATCH = 288 + DorisParserMATCHED = 289 + DorisParserMATCH_ALL = 290 + DorisParserMATCH_ANY = 291 + DorisParserMATCH_NAME = 292 + DorisParserMATCH_NAME_GLOB = 293 + DorisParserMATCH_PHRASE = 294 + DorisParserMATCH_PHRASE_EDGE = 295 + DorisParserMATCH_PHRASE_PREFIX = 296 + DorisParserMATCH_REGEXP = 297 + DorisParserMATERIALIZED = 298 + DorisParserMAX = 299 + DorisParserMAXVALUE = 300 + DorisParserMEMO = 301 + DorisParserMERGE = 302 + DorisParserMID = 303 + DorisParserMIGRATE = 304 + DorisParserMIGRATIONS = 305 + DorisParserMIN = 306 + DorisParserMINUS = 307 + DorisParserMINUTE = 308 + DorisParserMINUTES = 309 + DorisParserMINUTE_SECOND = 310 + DorisParserMODIFY = 311 + DorisParserMONTH = 312 + DorisParserMTMV = 313 + DorisParserNAME = 314 + DorisParserNAMES = 315 + DorisParserNATURAL = 316 + DorisParserNEGATIVE = 317 + DorisParserNEVER = 318 + DorisParserNEXT = 319 + DorisParserNGRAM_BF = 320 + DorisParserANN = 321 + DorisParserNO = 322 + DorisParserNO_USE_MV = 323 + DorisParserNON_NULLABLE = 324 + DorisParserNOT = 325 + DorisParserNULL = 326 + DorisParserNULLS = 327 + DorisParserOBSERVER = 328 + DorisParserOF = 329 + DorisParserOFFSET = 330 + DorisParserON = 331 + DorisParserOFF = 332 + DorisParserONLY = 333 + DorisParserOPEN = 334 + DorisParserOPTIMIZE = 335 + DorisParserOPTIMIZED = 336 + DorisParserOR = 337 + DorisParserORDER = 338 + DorisParserOUTER = 339 + DorisParserOUTFILE = 340 + DorisParserOVER = 341 + DorisParserOVERWRITE = 342 + DorisParserPARAMETER = 343 + DorisParserPARSED = 344 + DorisParserPARTITION = 345 + DorisParserPARTITIONS = 346 + DorisParserPASSWORD = 347 + DorisParserPASSWORD_EXPIRE = 348 + DorisParserPASSWORD_HISTORY = 349 + DorisParserPASSWORD_LOCK_TIME = 350 + DorisParserPASSWORD_REUSE = 351 + DorisParserPATH = 352 + DorisParserPAUSE = 353 + DorisParserPERCENT = 354 + DorisParserPERIOD = 355 + DorisParserPERMISSIVE = 356 + DorisParserPHYSICAL = 357 + DorisParserPI = 358 + DorisParserPLACEHOLDER = 359 + DorisParserPLAN = 360 + DorisParserPLAY = 361 + DorisParserPRIVILEGES = 362 + DorisParserPROCESS = 363 + DorisParserPLUGIN = 364 + DorisParserPLUGINS = 365 + DorisParserPOLICY = 366 + DorisParserPOSITION = 367 + DorisParserPRECEDING = 368 + DorisParserPREPARE = 369 + DorisParserPRIMARY = 370 + DorisParserPROC = 371 + DorisParserPROCEDURE = 372 + DorisParserPROCESSLIST = 373 + DorisParserPROFILE = 374 + DorisParserPROPERTIES = 375 + DorisParserPROPERTY = 376 + DorisParserQUANTILE_STATE = 377 + DorisParserQUANTILE_UNION = 378 + DorisParserQUERY = 379 + DorisParserQUEUED = 380 + DorisParserQUOTA = 381 + DorisParserQUALIFY = 382 + DorisParserQUARTER = 383 + DorisParserRANDOM = 384 + DorisParserRANGE = 385 + DorisParserREAD = 386 + DorisParserREAL = 387 + DorisParserREBALANCE = 388 + DorisParserRECENT = 389 + DorisParserRECOVER = 390 + DorisParserRECYCLE = 391 + DorisParserREFRESH = 392 + DorisParserREFERENCES = 393 + DorisParserREGEXP = 394 + DorisParserRELEASE = 395 + DorisParserRENAME = 396 + DorisParserREPAIR = 397 + DorisParserREPEATABLE = 398 + DorisParserREPLACE = 399 + DorisParserREPLACE_IF_NOT_NULL = 400 + DorisParserREPLAYER = 401 + DorisParserREPLICA = 402 + DorisParserREPOSITORIES = 403 + DorisParserREPOSITORY = 404 + DorisParserRESOURCE = 405 + DorisParserRESOURCES = 406 + DorisParserRESTORE = 407 + DorisParserRESTRICTIVE = 408 + DorisParserRESUME = 409 + DorisParserRETAIN = 410 + DorisParserRETENTION = 411 + DorisParserRETURNS = 412 + DorisParserREVOKE = 413 + DorisParserREWRITTEN = 414 + DorisParserRIGHT = 415 + DorisParserRLIKE = 416 + DorisParserROLE = 417 + DorisParserROLES = 418 + DorisParserROLLBACK = 419 + DorisParserROLLUP = 420 + DorisParserROOT = 421 + DorisParserROTATE = 422 + DorisParserROUTINE = 423 + DorisParserROW = 424 + DorisParserROWS = 425 + DorisParserS3 = 426 + DorisParserSAMPLE = 427 + DorisParserSCHEDULE = 428 + DorisParserSCHEDULER = 429 + DorisParserSCHEMA = 430 + DorisParserSCHEMAS = 431 + DorisParserSECOND = 432 + DorisParserSELECT = 433 + DorisParserSEMI = 434 + DorisParserSEPARATOR = 435 + DorisParserSERIALIZABLE = 436 + DorisParserSESSION = 437 + DorisParserSESSION_USER = 438 + DorisParserSET = 439 + DorisParserSETS = 440 + DorisParserSET_SESSION_VARIABLE = 441 + DorisParserSHAPE = 442 + DorisParserSHOW = 443 + DorisParserSIGNED = 444 + DorisParserSKEW = 445 + DorisParserSMALLINT = 446 + DorisParserSNAPSHOT = 447 + DorisParserSNAPSHOTS = 448 + DorisParserSONAME = 449 + DorisParserSPLIT = 450 + DorisParserSQL = 451 + DorisParserSQL_BLOCK_RULE = 452 + DorisParserSTAGE = 453 + DorisParserSTAGES = 454 + DorisParserSTART = 455 + DorisParserSTARTS = 456 + DorisParserSTATS = 457 + DorisParserSTATUS = 458 + DorisParserSTOP = 459 + DorisParserSTORAGE = 460 + DorisParserSTREAM = 461 + DorisParserSTREAMING = 462 + DorisParserSTRING = 463 + DorisParserSTRUCT = 464 + DorisParserSUBSTR = 465 + DorisParserSUBSTRING = 466 + DorisParserSUM = 467 + DorisParserSUPERUSER = 468 + DorisParserSWITCH = 469 + DorisParserSYNC = 470 + DorisParserSYSTEM = 471 + DorisParserTABLE = 472 + DorisParserTABLES = 473 + DorisParserTABLESAMPLE = 474 + DorisParserTABLET = 475 + DorisParserTABLETS = 476 + DorisParserTAG = 477 + DorisParserTASK = 478 + DorisParserTASKS = 479 + DorisParserTDE = 480 + DorisParserTEMPORARY = 481 + DorisParserTERMINATED = 482 + DorisParserTEXT = 483 + DorisParserTHAN = 484 + DorisParserTHEN = 485 + DorisParserTIME = 486 + DorisParserTIMESTAMP = 487 + DorisParserTINYINT = 488 + DorisParserTO = 489 + DorisParserTOKENIZER = 490 + DorisParserTOKEN_FILTER = 491 + DorisParserTRAILING = 492 + DorisParserTRANSACTION = 493 + DorisParserTRASH = 494 + DorisParserTREE = 495 + DorisParserTRIGGERS = 496 + DorisParserTRIM = 497 + DorisParserTRUE = 498 + DorisParserTRUNCATE = 499 + DorisParserTRY_CAST = 500 + DorisParserTYPE = 501 + DorisParserTYPECAST = 502 + DorisParserTYPES = 503 + DorisParserUNBOUNDED = 504 + DorisParserUNCOMMITTED = 505 + DorisParserUNINSTALL = 506 + DorisParserUNION = 507 + DorisParserUNIQUE = 508 + DorisParserUNLOCK = 509 + DorisParserUNSET = 510 + DorisParserUNSIGNED = 511 + DorisParserUP = 512 + DorisParserUPDATE = 513 + DorisParserUSE = 514 + DorisParserUSER = 515 + DorisParserUSE_MV = 516 + DorisParserUSING = 517 + DorisParserVALUE = 518 + DorisParserVALUES = 519 + DorisParserVARBINARY = 520 + DorisParserVARCHAR = 521 + DorisParserVARIABLE = 522 + DorisParserVARIABLES = 523 + DorisParserVARIANT = 524 + DorisParserVAULT = 525 + DorisParserVAULTS = 526 + DorisParserVERBOSE = 527 + DorisParserVERSION = 528 + DorisParserVIEW = 529 + DorisParserVIEWS = 530 + DorisParserWARM = 531 + DorisParserWARNINGS = 532 + DorisParserWEEK = 533 + DorisParserWHEN = 534 + DorisParserWHERE = 535 + DorisParserWHITELIST = 536 + DorisParserWITH = 537 + DorisParserWORK = 538 + DorisParserWORKLOAD = 539 + DorisParserWRITE = 540 + DorisParserXOR = 541 + DorisParserYEAR = 542 + DorisParserEQ = 543 + DorisParserNSEQ = 544 + DorisParserNEQ = 545 + DorisParserLT = 546 + DorisParserLTE = 547 + DorisParserGT = 548 + DorisParserGTE = 549 + DorisParserPLUS = 550 + DorisParserSUBTRACT = 551 + DorisParserASTERISK = 552 + DorisParserSLASH = 553 + DorisParserMOD = 554 + DorisParserTILDE = 555 + DorisParserAMPERSAND = 556 + DorisParserLOGICALAND = 557 + DorisParserLOGICALNOT = 558 + DorisParserPIPE = 559 + DorisParserDOUBLEPIPES = 560 + DorisParserHAT = 561 + DorisParserCOLON = 562 + DorisParserARROW = 563 + DorisParserHINT_START = 564 + DorisParserHINT_END = 565 + DorisParserCOMMENT_START = 566 + DorisParserATSIGN = 567 + DorisParserDOUBLEATSIGN = 568 + DorisParserSTRING_LITERAL = 569 + DorisParserVARBINARY_LITERAL = 570 + DorisParserLEADING_STRING = 571 + DorisParserBIGINT_LITERAL = 572 + DorisParserSMALLINT_LITERAL = 573 + DorisParserTINYINT_LITERAL = 574 + DorisParserINTEGER_VALUE = 575 + DorisParserEXPONENT_VALUE = 576 + DorisParserDECIMAL_VALUE = 577 + DorisParserBIGDECIMAL_LITERAL = 578 + DorisParserIDENTIFIER = 579 + DorisParserBACKQUOTED_IDENTIFIER = 580 + DorisParserSIMPLE_COMMENT = 581 + DorisParserBRACKETED_COMMENT = 582 + DorisParserFROM_DUAL = 583 + DorisParserWS = 584 + DorisParserUNRECOGNIZED = 585 + DorisParserGET_FORMAT = 586 +) + +// DorisParser rules. +const ( + DorisParserRULE_multiStatements = 0 + DorisParserRULE_singleStatement = 1 + DorisParserRULE_expressionWithEof = 2 + DorisParserRULE_statement = 3 + DorisParserRULE_statementBase = 4 + DorisParserRULE_materializedViewStatement = 5 + DorisParserRULE_supportedJobStatement = 6 + DorisParserRULE_constraintStatement = 7 + DorisParserRULE_optSpecBranch = 8 + DorisParserRULE_supportedDmlStatement = 9 + DorisParserRULE_mergeMatchedClause = 10 + DorisParserRULE_mergeNotMatchedClause = 11 + DorisParserRULE_supportedCreateStatement = 12 + DorisParserRULE_dictionaryColumnDefs = 13 + DorisParserRULE_dictionaryColumnDef = 14 + DorisParserRULE_supportedAlterStatement = 15 + DorisParserRULE_supportedDropStatement = 16 + DorisParserRULE_supportedShowStatement = 17 + DorisParserRULE_supportedLoadStatement = 18 + DorisParserRULE_supportedKillStatement = 19 + DorisParserRULE_supportedOtherStatement = 20 + DorisParserRULE_warmUpItem = 21 + DorisParserRULE_warmUpSingleTableRef = 22 + DorisParserRULE_lockTable = 23 + DorisParserRULE_createRoutineLoad = 24 + DorisParserRULE_loadProperty = 25 + DorisParserRULE_importSequenceStatement = 26 + DorisParserRULE_importDeleteOnStatement = 27 + DorisParserRULE_importWhereStatement = 28 + DorisParserRULE_importPrecedingFilterStatement = 29 + DorisParserRULE_importColumnsStatement = 30 + DorisParserRULE_importColumnDesc = 31 + DorisParserRULE_supportedRefreshStatement = 32 + DorisParserRULE_supportedCleanStatement = 33 + DorisParserRULE_supportedCancelStatement = 34 + DorisParserRULE_supportedAdminStatement = 35 + DorisParserRULE_supportedRecoverStatement = 36 + DorisParserRULE_baseTableRef = 37 + DorisParserRULE_wildWhere = 38 + DorisParserRULE_supportedTransactionStatement = 39 + DorisParserRULE_supportedGrantRevokeStatement = 40 + DorisParserRULE_privilege = 41 + DorisParserRULE_privilegeList = 42 + DorisParserRULE_alterSystemClause = 43 + DorisParserRULE_dropRollupClause = 44 + DorisParserRULE_addRollupClause = 45 + DorisParserRULE_alterTableClause = 46 + DorisParserRULE_createOrReplaceTagClause = 47 + DorisParserRULE_createOrReplaceBranchClause = 48 + DorisParserRULE_tagOptions = 49 + DorisParserRULE_branchOptions = 50 + DorisParserRULE_retainTime = 51 + DorisParserRULE_retentionSnapshot = 52 + DorisParserRULE_minSnapshotsToKeep = 53 + DorisParserRULE_timeValueWithUnit = 54 + DorisParserRULE_dropBranchClause = 55 + DorisParserRULE_dropTagClause = 56 + DorisParserRULE_partitionTransform = 57 + DorisParserRULE_columnPosition = 58 + DorisParserRULE_toRollup = 59 + DorisParserRULE_fromRollup = 60 + DorisParserRULE_supportedStatsStatement = 61 + DorisParserRULE_analyzeProperties = 62 + DorisParserRULE_workloadPolicyActions = 63 + DorisParserRULE_workloadPolicyAction = 64 + DorisParserRULE_workloadPolicyConditions = 65 + DorisParserRULE_workloadPolicyCondition = 66 + DorisParserRULE_storageBackend = 67 + DorisParserRULE_passwordOption = 68 + DorisParserRULE_functionArguments = 69 + DorisParserRULE_dataTypeList = 70 + DorisParserRULE_supportedSetStatement = 71 + DorisParserRULE_optionWithType = 72 + DorisParserRULE_optionWithoutType = 73 + DorisParserRULE_variable = 74 + DorisParserRULE_transactionAccessMode = 75 + DorisParserRULE_isolationLevel = 76 + DorisParserRULE_supportedUnsetStatement = 77 + DorisParserRULE_supportedUseStatement = 78 + DorisParserRULE_stageAndPattern = 79 + DorisParserRULE_supportedDescribeStatement = 80 + DorisParserRULE_constraint = 81 + DorisParserRULE_partitionSpec = 82 + DorisParserRULE_partitionTable = 83 + DorisParserRULE_identityOrFunctionList = 84 + DorisParserRULE_identityOrFunction = 85 + DorisParserRULE_dataDesc = 86 + DorisParserRULE_statementScope = 87 + DorisParserRULE_buildMode = 88 + DorisParserRULE_refreshTrigger = 89 + DorisParserRULE_refreshSchedule = 90 + DorisParserRULE_refreshMethod = 91 + DorisParserRULE_mvPartition = 92 + DorisParserRULE_identifierOrText = 93 + DorisParserRULE_identifierOrTextOrAsterisk = 94 + DorisParserRULE_multipartIdentifierOrAsterisk = 95 + DorisParserRULE_identifierOrAsterisk = 96 + DorisParserRULE_userIdentify = 97 + DorisParserRULE_grantUserIdentify = 98 + DorisParserRULE_explain = 99 + DorisParserRULE_explainCommand = 100 + DorisParserRULE_planType = 101 + DorisParserRULE_replayCommand = 102 + DorisParserRULE_replayType = 103 + DorisParserRULE_mergeType = 104 + DorisParserRULE_preFilterClause = 105 + DorisParserRULE_deleteOnClause = 106 + DorisParserRULE_sequenceColClause = 107 + DorisParserRULE_colFromPath = 108 + DorisParserRULE_colMappingList = 109 + DorisParserRULE_mappingExpr = 110 + DorisParserRULE_withRemoteStorageSystem = 111 + DorisParserRULE_resourceDesc = 112 + DorisParserRULE_mysqlDataDesc = 113 + DorisParserRULE_skipLines = 114 + DorisParserRULE_outFileClause = 115 + DorisParserRULE_query = 116 + DorisParserRULE_queryTerm = 117 + DorisParserRULE_setQuantifier = 118 + DorisParserRULE_queryPrimary = 119 + DorisParserRULE_querySpecification = 120 + DorisParserRULE_cte = 121 + DorisParserRULE_aliasQuery = 122 + DorisParserRULE_columnAliases = 123 + DorisParserRULE_selectClause = 124 + DorisParserRULE_selectColumnClause = 125 + DorisParserRULE_whereClause = 126 + DorisParserRULE_fromClause = 127 + DorisParserRULE_intoClause = 128 + DorisParserRULE_bulkCollectClause = 129 + DorisParserRULE_tableRow = 130 + DorisParserRULE_relations = 131 + DorisParserRULE_relation = 132 + DorisParserRULE_joinRelation = 133 + DorisParserRULE_distributeType = 134 + DorisParserRULE_skewHint = 135 + DorisParserRULE_constantList = 136 + DorisParserRULE_relationHint = 137 + DorisParserRULE_expressionWithOrder = 138 + DorisParserRULE_aggClause = 139 + DorisParserRULE_groupingElement = 140 + DorisParserRULE_groupingSet = 141 + DorisParserRULE_havingClause = 142 + DorisParserRULE_qualifyClause = 143 + DorisParserRULE_selectHint = 144 + DorisParserRULE_hintStatement = 145 + DorisParserRULE_hintName = 146 + DorisParserRULE_hintAssignment = 147 + DorisParserRULE_updateAssignment = 148 + DorisParserRULE_updateAssignmentSeq = 149 + DorisParserRULE_lateralView = 150 + DorisParserRULE_queryOrganization = 151 + DorisParserRULE_sortClause = 152 + DorisParserRULE_sortItem = 153 + DorisParserRULE_limitClause = 154 + DorisParserRULE_partitionClause = 155 + DorisParserRULE_joinType = 156 + DorisParserRULE_joinCriteria = 157 + DorisParserRULE_identifierList = 158 + DorisParserRULE_identifierSeq = 159 + DorisParserRULE_optScanParams = 160 + DorisParserRULE_relationPrimary = 161 + DorisParserRULE_materializedViewName = 162 + DorisParserRULE_propertyClause = 163 + DorisParserRULE_propertyItemList = 164 + DorisParserRULE_propertyItem = 165 + DorisParserRULE_propertyKey = 166 + DorisParserRULE_propertyValue = 167 + DorisParserRULE_tableAlias = 168 + DorisParserRULE_multipartIdentifier = 169 + DorisParserRULE_simpleColumnDefs = 170 + DorisParserRULE_simpleColumnDef = 171 + DorisParserRULE_columnDefs = 172 + DorisParserRULE_columnDef = 173 + DorisParserRULE_indexDefs = 174 + DorisParserRULE_indexDef = 175 + DorisParserRULE_partitionsDef = 176 + DorisParserRULE_partitionDef = 177 + DorisParserRULE_lessThanPartitionDef = 178 + DorisParserRULE_fixedPartitionDef = 179 + DorisParserRULE_stepPartitionDef = 180 + DorisParserRULE_inPartitionDef = 181 + DorisParserRULE_partitionValueList = 182 + DorisParserRULE_partitionValueDef = 183 + DorisParserRULE_rollupDefs = 184 + DorisParserRULE_rollupDef = 185 + DorisParserRULE_aggTypeDef = 186 + DorisParserRULE_tabletList = 187 + DorisParserRULE_inlineTable = 188 + DorisParserRULE_namedExpression = 189 + DorisParserRULE_namedExpressionSeq = 190 + DorisParserRULE_expression = 191 + DorisParserRULE_funcExpression = 192 + DorisParserRULE_lambdaExpression = 193 + DorisParserRULE_booleanExpression = 194 + DorisParserRULE_rowConstructor = 195 + DorisParserRULE_rowConstructorItem = 196 + DorisParserRULE_predicate = 197 + DorisParserRULE_valueExpression = 198 + DorisParserRULE_primaryExpression = 199 + DorisParserRULE_exceptOrReplace = 200 + DorisParserRULE_castDataType = 201 + DorisParserRULE_functionCallExpression = 202 + DorisParserRULE_functionIdentifier = 203 + DorisParserRULE_functionNameIdentifier = 204 + DorisParserRULE_windowSpec = 205 + DorisParserRULE_windowFrame = 206 + DorisParserRULE_frameUnits = 207 + DorisParserRULE_frameBoundary = 208 + DorisParserRULE_qualifiedName = 209 + DorisParserRULE_specifiedPartition = 210 + DorisParserRULE_constant = 211 + DorisParserRULE_comparisonOperator = 212 + DorisParserRULE_booleanValue = 213 + DorisParserRULE_whenClause = 214 + DorisParserRULE_interval = 215 + DorisParserRULE_unitIdentifier = 216 + DorisParserRULE_dataTypeWithNullable = 217 + DorisParserRULE_dataType = 218 + DorisParserRULE_primitiveColType = 219 + DorisParserRULE_complexColTypeList = 220 + DorisParserRULE_complexColType = 221 + DorisParserRULE_variantTypeDefinitions = 222 + DorisParserRULE_variantSubColTypeList = 223 + DorisParserRULE_variantSubColType = 224 + DorisParserRULE_variantSubColMatchType = 225 + DorisParserRULE_commentSpec = 226 + DorisParserRULE_sample = 227 + DorisParserRULE_sampleMethod = 228 + DorisParserRULE_tableSnapshot = 229 + DorisParserRULE_errorCapturingIdentifier = 230 + DorisParserRULE_errorCapturingIdentifierExtra = 231 + DorisParserRULE_identifier = 232 + DorisParserRULE_strictIdentifier = 233 + DorisParserRULE_quotedIdentifier = 234 + DorisParserRULE_number = 235 + DorisParserRULE_nonReserved = 236 +) + +// IMultiStatementsContext is an interface to support dynamic dispatch. +type IMultiStatementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + AllStatement() []IStatementContext + Statement(i int) IStatementContext + + // IsMultiStatementsContext differentiates from other interfaces. + IsMultiStatementsContext() +} + +type MultiStatementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiStatementsContext() *MultiStatementsContext { + var p = new(MultiStatementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_multiStatements + return p +} + +func InitEmptyMultiStatementsContext(p *MultiStatementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_multiStatements +} + +func (*MultiStatementsContext) IsMultiStatementsContext() {} + +func NewMultiStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiStatementsContext { + var p = new(MultiStatementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_multiStatements + + return p +} + +func (s *MultiStatementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultiStatementsContext) EOF() antlr.TerminalNode { + return s.GetToken(DorisParserEOF, 0) +} + +func (s *MultiStatementsContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(DorisParserSEMICOLON) +} + +func (s *MultiStatementsContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSEMICOLON, i) +} + +func (s *MultiStatementsContext) AllStatement() []IStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementContext); ok { + len++ + } + } + + tst := make([]IStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementContext); ok { + tst[i] = t.(IStatementContext) + i++ + } + } + + return tst +} + +func (s *MultiStatementsContext) Statement(i int) IStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *MultiStatementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultiStatementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultiStatementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMultiStatements(s) + } +} + +func (s *MultiStatementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMultiStatements(s) + } +} + +func (s *MultiStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMultiStatements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MultiStatements() (localctx IMultiStatementsContext) { + localctx = NewMultiStatementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, DorisParserRULE_multiStatements) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(474) + p.Match(DorisParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&576461576943468548) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&343599482883) != 0) || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&52776558395405) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&18014401730709505) != 0) || ((int64((_la-278)) & ^0x3f) == 0 && ((int64(1)<<(_la-278))&16777249) != 0) || ((int64((_la-353)) & ^0x3f) == 0 && ((int64(1)<<(_la-353))&1243064553093202049) != 0) || ((int64((_la-419)) & ^0x3f) == 0 && ((int64(1)<<(_la-419))&3378867969474561) != 0) || ((int64((_la-499)) & ^0x3f) == 0 && ((int64(1)<<(_la-499))&279173975169) != 0) { + { + p.SetState(480) + p.Statement() + } + + } + p.SetState(491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == DorisParserSEMICOLON { + { + p.SetState(483) + p.Match(DorisParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(488) + p.Statement() + } + + } + p.SetState(493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserSEMICOLON { + { + p.SetState(494) + p.Match(DorisParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(500) + p.Match(DorisParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingleStatementContext is an interface to support dynamic dispatch. +type ISingleStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + Statement() IStatementContext + + // IsSingleStatementContext differentiates from other interfaces. + IsSingleStatementContext() +} + +type SingleStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySingleStatementContext() *SingleStatementContext { + var p = new(SingleStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_singleStatement + return p +} + +func InitEmptySingleStatementContext(p *SingleStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_singleStatement +} + +func (*SingleStatementContext) IsSingleStatementContext() {} + +func NewSingleStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SingleStatementContext { + var p = new(SingleStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_singleStatement + + return p +} + +func (s *SingleStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SingleStatementContext) EOF() antlr.TerminalNode { + return s.GetToken(DorisParserEOF, 0) +} + +func (s *SingleStatementContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(DorisParserSEMICOLON) +} + +func (s *SingleStatementContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSEMICOLON, i) +} + +func (s *SingleStatementContext) Statement() IStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *SingleStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SingleStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SingleStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSingleStatement(s) + } +} + +func (s *SingleStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSingleStatement(s) + } +} + +func (s *SingleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSingleStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SingleStatement() (localctx ISingleStatementContext) { + localctx = NewSingleStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, DorisParserRULE_singleStatement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(502) + p.Match(DorisParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&576461576943468548) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&343599482883) != 0) || ((int64((_la-133)) & ^0x3f) == 0 && ((int64(1)<<(_la-133))&52776558395405) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&18014401730709505) != 0) || ((int64((_la-278)) & ^0x3f) == 0 && ((int64(1)<<(_la-278))&16777249) != 0) || ((int64((_la-353)) & ^0x3f) == 0 && ((int64(1)<<(_la-353))&1243064553093202049) != 0) || ((int64((_la-419)) & ^0x3f) == 0 && ((int64(1)<<(_la-419))&3378867969474561) != 0) || ((int64((_la-499)) & ^0x3f) == 0 && ((int64(1)<<(_la-499))&279173975169) != 0) { + { + p.SetState(508) + p.Statement() + } + + } + p.SetState(514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserSEMICOLON { + { + p.SetState(511) + p.Match(DorisParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(517) + p.Match(DorisParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionWithEofContext is an interface to support dynamic dispatch. +type IExpressionWithEofContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + EOF() antlr.TerminalNode + + // IsExpressionWithEofContext differentiates from other interfaces. + IsExpressionWithEofContext() +} + +type ExpressionWithEofContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionWithEofContext() *ExpressionWithEofContext { + var p = new(ExpressionWithEofContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_expressionWithEof + return p +} + +func InitEmptyExpressionWithEofContext(p *ExpressionWithEofContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_expressionWithEof +} + +func (*ExpressionWithEofContext) IsExpressionWithEofContext() {} + +func NewExpressionWithEofContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionWithEofContext { + var p = new(ExpressionWithEofContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_expressionWithEof + + return p +} + +func (s *ExpressionWithEofContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionWithEofContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionWithEofContext) EOF() antlr.TerminalNode { + return s.GetToken(DorisParserEOF, 0) +} + +func (s *ExpressionWithEofContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionWithEofContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionWithEofContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExpressionWithEof(s) + } +} + +func (s *ExpressionWithEofContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExpressionWithEof(s) + } +} + +func (s *ExpressionWithEofContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExpressionWithEof(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ExpressionWithEof() (localctx IExpressionWithEofContext) { + localctx = NewExpressionWithEofContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, DorisParserRULE_expressionWithEof) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(519) + p.Expression() + } + { + p.SetState(520) + p.Match(DorisParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatementContext is an interface to support dynamic dispatch. +type IStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsStatementContext differentiates from other interfaces. + IsStatementContext() +} + +type StatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementContext() *StatementContext { + var p = new(StatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_statement + return p +} + +func InitEmptyStatementContext(p *StatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_statement +} + +func (*StatementContext) IsStatementContext() {} + +func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext { + var p = new(StatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_statement + + return p +} + +func (s *StatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementContext) CopyAll(ctx *StatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *StatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ShowCreateProcedureContext struct { + StatementContext + name IMultipartIdentifierContext +} + +func NewShowCreateProcedureContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateProcedureContext { + var p = new(ShowCreateProcedureContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *ShowCreateProcedureContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *ShowCreateProcedureContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *ShowCreateProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateProcedureContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateProcedureContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateProcedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(DorisParserPROCEDURE, 0) +} + +func (s *ShowCreateProcedureContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateProcedure(s) + } +} + +func (s *ShowCreateProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateProcedure(s) + } +} + +func (s *ShowCreateProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateProcedure(s) + + default: + return t.VisitChildren(s) + } +} + +type StatementBaseAliasContext struct { + StatementContext +} + +func NewStatementBaseAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StatementBaseAliasContext { + var p = new(StatementBaseAliasContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *StatementBaseAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementBaseAliasContext) StatementBase() IStatementBaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementBaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementBaseContext) +} + +func (s *StatementBaseAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStatementBaseAlias(s) + } +} + +func (s *StatementBaseAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStatementBaseAlias(s) + } +} + +func (s *StatementBaseAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStatementBaseAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowProcedureStatusContext struct { + StatementContext + pattern IValueExpressionContext +} + +func NewShowProcedureStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowProcedureStatusContext { + var p = new(ShowProcedureStatusContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *ShowProcedureStatusContext) GetPattern() IValueExpressionContext { return s.pattern } + +func (s *ShowProcedureStatusContext) SetPattern(v IValueExpressionContext) { s.pattern = v } + +func (s *ShowProcedureStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowProcedureStatusContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowProcedureStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *ShowProcedureStatusContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(DorisParserPROCEDURE, 0) +} + +func (s *ShowProcedureStatusContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *ShowProcedureStatusContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowProcedureStatusContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *ShowProcedureStatusContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ShowProcedureStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowProcedureStatus(s) + } +} + +func (s *ShowProcedureStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowProcedureStatus(s) + } +} + +func (s *ShowProcedureStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowProcedureStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateProcedureContext struct { + StatementContext + name IMultipartIdentifierContext +} + +func NewCreateProcedureContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateProcedureContext { + var p = new(CreateProcedureContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *CreateProcedureContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CreateProcedureContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CreateProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateProcedureContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CreateProcedureContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CreateProcedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(DorisParserPROCEDURE, 0) +} + +func (s *CreateProcedureContext) PROC() antlr.TerminalNode { + return s.GetToken(DorisParserPROC, 0) +} + +func (s *CreateProcedureContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateProcedureContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *CreateProcedureContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateProcedureContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *CreateProcedureContext) OR() antlr.TerminalNode { + return s.GetToken(DorisParserOR, 0) +} + +func (s *CreateProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateProcedure(s) + } +} + +func (s *CreateProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateProcedure(s) + } +} + +func (s *CreateProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateProcedure(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowConfigContext struct { + StatementContext + type_ antlr.Token + pattern IValueExpressionContext + backendId antlr.Token +} + +func NewShowConfigContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowConfigContext { + var p = new(ShowConfigContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *ShowConfigContext) GetType_() antlr.Token { return s.type_ } + +func (s *ShowConfigContext) GetBackendId() antlr.Token { return s.backendId } + +func (s *ShowConfigContext) SetType_(v antlr.Token) { s.type_ = v } + +func (s *ShowConfigContext) SetBackendId(v antlr.Token) { s.backendId = v } + +func (s *ShowConfigContext) GetPattern() IValueExpressionContext { return s.pattern } + +func (s *ShowConfigContext) SetPattern(v IValueExpressionContext) { s.pattern = v } + +func (s *ShowConfigContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowConfigContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowConfigContext) CONFIG() antlr.TerminalNode { + return s.GetToken(DorisParserCONFIG, 0) +} + +func (s *ShowConfigContext) FRONTEND() antlr.TerminalNode { + return s.GetToken(DorisParserFRONTEND, 0) +} + +func (s *ShowConfigContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *ShowConfigContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *ShowConfigContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowConfigContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowConfigContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ShowConfigContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowConfigContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowConfig(s) + } +} + +func (s *ShowConfigContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowConfig(s) + } +} + +func (s *ShowConfigContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowConfig(s) + + default: + return t.VisitChildren(s) + } +} + +type CallProcedureContext struct { + StatementContext + name IMultipartIdentifierContext +} + +func NewCallProcedureContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CallProcedureContext { + var p = new(CallProcedureContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *CallProcedureContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CallProcedureContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CallProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CallProcedureContext) CALL() antlr.TerminalNode { + return s.GetToken(DorisParserCALL, 0) +} + +func (s *CallProcedureContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CallProcedureContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CallProcedureContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CallProcedureContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CallProcedureContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CallProcedureContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CallProcedureContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CallProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCallProcedure(s) + } +} + +func (s *CallProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCallProcedure(s) + } +} + +func (s *CallProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCallProcedure(s) + + default: + return t.VisitChildren(s) + } +} + +type DropProcedureContext struct { + StatementContext + name IMultipartIdentifierContext +} + +func NewDropProcedureContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropProcedureContext { + var p = new(DropProcedureContext) + + InitEmptyStatementContext(&p.StatementContext) + p.parser = parser + p.CopyAll(ctx.(*StatementContext)) + + return p +} + +func (s *DropProcedureContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *DropProcedureContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *DropProcedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropProcedureContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropProcedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(DorisParserPROCEDURE, 0) +} + +func (s *DropProcedureContext) PROC() antlr.TerminalNode { + return s.GetToken(DorisParserPROC, 0) +} + +func (s *DropProcedureContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropProcedureContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropProcedureContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropProcedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropProcedure(s) + } +} + +func (s *DropProcedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropProcedure(s) + } +} + +func (s *DropProcedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropProcedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Statement() (localctx IStatementContext) { + localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, DorisParserRULE_statement) + var _la int + + var _alt int + + p.SetState(596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 19, p.GetParserRuleContext()) { + case 1: + localctx = NewStatementBaseAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(522) + p.StatementBase() + } + + case 2: + localctx = NewCallProcedureContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(523) + p.Match(DorisParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(524) + + var _x = p.MultipartIdentifier() + + localctx.(*CallProcedureContext).name = _x + } + { + p.SetState(525) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031699) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(526) + p.Expression() + } + p.SetState(531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(527) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(528) + p.Expression() + } + + p.SetState(533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(536) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewCreateProcedureContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + p.SetState(545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserALTER: + { + p.SetState(538) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCREATE: + { + p.SetState(539) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserOR { + { + p.SetState(540) + p.Match(DorisParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(541) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case DorisParserREPLACE: + { + p.SetState(544) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(547) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserPROC || _la == DorisParserPROCEDURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(548) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateProcedureContext).name = _x + } + { + p.SetState(549) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 1 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1+1 { + p.SetState(550) + p.MatchWildcard() + + } + p.SetState(555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(556) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 1 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1+1 { + p.SetState(557) + p.MatchWildcard() + + } + p.SetState(562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 4: + localctx = NewDropProcedureContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(563) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(564) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserPROC || _la == DorisParserPROCEDURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(565) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(566) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(569) + + var _x = p.MultipartIdentifier() + + localctx.(*DropProcedureContext).name = _x + } + + case 5: + localctx = NewShowProcedureStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(570) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(571) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFUNCTION || _la == DorisParserPROCEDURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(572) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case DorisParserLIKE: + { + p.SetState(573) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(574) + + var _x = p.valueExpression(0) + + localctx.(*ShowProcedureStatusContext).pattern = _x + } + + case DorisParserWHERE: + { + p.SetState(575) + p.WhereClause() + } + + case DorisParserEOF, DorisParserSEMICOLON: + + default: + } + + case 6: + localctx = NewShowCreateProcedureContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(578) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(579) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(580) + p.Match(DorisParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(581) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateProcedureContext).name = _x + } + + case 7: + localctx = NewShowConfigContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + p.SetState(583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserADMIN { + { + p.SetState(582) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(585) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(586) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ShowConfigContext).type_ = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBACKEND || _la == DorisParserFRONTEND) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ShowConfigContext).type_ = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(587) + p.Match(DorisParserCONFIG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(588) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(589) + + var _x = p.valueExpression(0) + + localctx.(*ShowConfigContext).pattern = _x + } + + } + p.SetState(594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(592) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(593) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowConfigContext).backendId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatementBaseContext is an interface to support dynamic dispatch. +type IStatementBaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsStatementBaseContext differentiates from other interfaces. + IsStatementBaseContext() +} + +type StatementBaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementBaseContext() *StatementBaseContext { + var p = new(StatementBaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_statementBase + return p +} + +func InitEmptyStatementBaseContext(p *StatementBaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_statementBase +} + +func (*StatementBaseContext) IsStatementBaseContext() {} + +func NewStatementBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementBaseContext { + var p = new(StatementBaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_statementBase + + return p +} + +func (s *StatementBaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementBaseContext) CopyAll(ctx *StatementBaseContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *StatementBaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SupportedSetStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedSetStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedSetStatementAliasContext { + var p = new(SupportedSetStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedSetStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedSetStatementAliasContext) SupportedSetStatement() ISupportedSetStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedSetStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedSetStatementContext) +} + +func (s *SupportedSetStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedSetStatementAlias(s) + } +} + +func (s *SupportedSetStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedSetStatementAlias(s) + } +} + +func (s *SupportedSetStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedSetStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedDmlStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedDmlStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedDmlStatementAliasContext { + var p = new(SupportedDmlStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedDmlStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedDmlStatementAliasContext) SupportedDmlStatement() ISupportedDmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedDmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedDmlStatementContext) +} + +func (s *SupportedDmlStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedDmlStatementAlias(s) + } +} + +func (s *SupportedDmlStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedDmlStatementAlias(s) + } +} + +func (s *SupportedDmlStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedDmlStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedLoadStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedLoadStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedLoadStatementAliasContext { + var p = new(SupportedLoadStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedLoadStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedLoadStatementAliasContext) SupportedLoadStatement() ISupportedLoadStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedLoadStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedLoadStatementContext) +} + +func (s *SupportedLoadStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedLoadStatementAlias(s) + } +} + +func (s *SupportedLoadStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedLoadStatementAlias(s) + } +} + +func (s *SupportedLoadStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedLoadStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedTransactionStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedTransactionStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedTransactionStatementAliasContext { + var p = new(SupportedTransactionStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedTransactionStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedTransactionStatementAliasContext) SupportedTransactionStatement() ISupportedTransactionStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedTransactionStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedTransactionStatementContext) +} + +func (s *SupportedTransactionStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedTransactionStatementAlias(s) + } +} + +func (s *SupportedTransactionStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedTransactionStatementAlias(s) + } +} + +func (s *SupportedTransactionStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedTransactionStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type ConstraintStatementAliasContext struct { + StatementBaseContext +} + +func NewConstraintStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstraintStatementAliasContext { + var p = new(ConstraintStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *ConstraintStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintStatementAliasContext) ConstraintStatement() IConstraintStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintStatementContext) +} + +func (s *ConstraintStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterConstraintStatementAlias(s) + } +} + +func (s *ConstraintStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitConstraintStatementAlias(s) + } +} + +func (s *ConstraintStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitConstraintStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedGrantRevokeStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedGrantRevokeStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedGrantRevokeStatementAliasContext { + var p = new(SupportedGrantRevokeStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedGrantRevokeStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedGrantRevokeStatementAliasContext) SupportedGrantRevokeStatement() ISupportedGrantRevokeStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedGrantRevokeStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedGrantRevokeStatementContext) +} + +func (s *SupportedGrantRevokeStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedGrantRevokeStatementAlias(s) + } +} + +func (s *SupportedGrantRevokeStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedGrantRevokeStatementAlias(s) + } +} + +func (s *SupportedGrantRevokeStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedGrantRevokeStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedKillStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedKillStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedKillStatementAliasContext { + var p = new(SupportedKillStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedKillStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedKillStatementAliasContext) SupportedKillStatement() ISupportedKillStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedKillStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedKillStatementContext) +} + +func (s *SupportedKillStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedKillStatementAlias(s) + } +} + +func (s *SupportedKillStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedKillStatementAlias(s) + } +} + +func (s *SupportedKillStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedKillStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedAlterStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedAlterStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedAlterStatementAliasContext { + var p = new(SupportedAlterStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedAlterStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedAlterStatementAliasContext) SupportedAlterStatement() ISupportedAlterStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedAlterStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedAlterStatementContext) +} + +func (s *SupportedAlterStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedAlterStatementAlias(s) + } +} + +func (s *SupportedAlterStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedAlterStatementAlias(s) + } +} + +func (s *SupportedAlterStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedAlterStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedCleanStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedCleanStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedCleanStatementAliasContext { + var p = new(SupportedCleanStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedCleanStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedCleanStatementAliasContext) SupportedCleanStatement() ISupportedCleanStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedCleanStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedCleanStatementContext) +} + +func (s *SupportedCleanStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedCleanStatementAlias(s) + } +} + +func (s *SupportedCleanStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedCleanStatementAlias(s) + } +} + +func (s *SupportedCleanStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedCleanStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedRecoverStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedRecoverStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedRecoverStatementAliasContext { + var p = new(SupportedRecoverStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedRecoverStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedRecoverStatementAliasContext) SupportedRecoverStatement() ISupportedRecoverStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedRecoverStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedRecoverStatementContext) +} + +func (s *SupportedRecoverStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedRecoverStatementAlias(s) + } +} + +func (s *SupportedRecoverStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedRecoverStatementAlias(s) + } +} + +func (s *SupportedRecoverStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedRecoverStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedUnsetStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedUnsetStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedUnsetStatementAliasContext { + var p = new(SupportedUnsetStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedUnsetStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedUnsetStatementAliasContext) SupportedUnsetStatement() ISupportedUnsetStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedUnsetStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedUnsetStatementContext) +} + +func (s *SupportedUnsetStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedUnsetStatementAlias(s) + } +} + +func (s *SupportedUnsetStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedUnsetStatementAlias(s) + } +} + +func (s *SupportedUnsetStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedUnsetStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedJobStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedJobStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedJobStatementAliasContext { + var p = new(SupportedJobStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedJobStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedJobStatementAliasContext) SupportedJobStatement() ISupportedJobStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedJobStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedJobStatementContext) +} + +func (s *SupportedJobStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedJobStatementAlias(s) + } +} + +func (s *SupportedJobStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedJobStatementAlias(s) + } +} + +func (s *SupportedJobStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedJobStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedUseStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedUseStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedUseStatementAliasContext { + var p = new(SupportedUseStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedUseStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedUseStatementAliasContext) SupportedUseStatement() ISupportedUseStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedUseStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedUseStatementContext) +} + +func (s *SupportedUseStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedUseStatementAlias(s) + } +} + +func (s *SupportedUseStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedUseStatementAlias(s) + } +} + +func (s *SupportedUseStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedUseStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type MaterializedViewStatementAliasContext struct { + StatementBaseContext +} + +func NewMaterializedViewStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MaterializedViewStatementAliasContext { + var p = new(MaterializedViewStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *MaterializedViewStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaterializedViewStatementAliasContext) MaterializedViewStatement() IMaterializedViewStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewStatementContext) +} + +func (s *MaterializedViewStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMaterializedViewStatementAlias(s) + } +} + +func (s *MaterializedViewStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMaterializedViewStatementAlias(s) + } +} + +func (s *MaterializedViewStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMaterializedViewStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type StatementDefaultContext struct { + StatementBaseContext +} + +func NewStatementDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StatementDefaultContext { + var p = new(StatementDefaultContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *StatementDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementDefaultContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *StatementDefaultContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *StatementDefaultContext) OutFileClause() IOutFileClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutFileClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOutFileClauseContext) +} + +func (s *StatementDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStatementDefault(s) + } +} + +func (s *StatementDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStatementDefault(s) + } +} + +func (s *StatementDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStatementDefault(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedAdminStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedAdminStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedAdminStatementAliasContext { + var p = new(SupportedAdminStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedAdminStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedAdminStatementAliasContext) SupportedAdminStatement() ISupportedAdminStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedAdminStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedAdminStatementContext) +} + +func (s *SupportedAdminStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedAdminStatementAlias(s) + } +} + +func (s *SupportedAdminStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedAdminStatementAlias(s) + } +} + +func (s *SupportedAdminStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedAdminStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedStatsStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedStatsStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedStatsStatementAliasContext { + var p = new(SupportedStatsStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedStatsStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedStatsStatementAliasContext) SupportedStatsStatement() ISupportedStatsStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedStatsStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedStatsStatementContext) +} + +func (s *SupportedStatsStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedStatsStatementAlias(s) + } +} + +func (s *SupportedStatsStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedStatsStatementAlias(s) + } +} + +func (s *SupportedStatsStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedStatsStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedDescribeStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedDescribeStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedDescribeStatementAliasContext { + var p = new(SupportedDescribeStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedDescribeStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedDescribeStatementAliasContext) SupportedDescribeStatement() ISupportedDescribeStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedDescribeStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedDescribeStatementContext) +} + +func (s *SupportedDescribeStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedDescribeStatementAlias(s) + } +} + +func (s *SupportedDescribeStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedDescribeStatementAlias(s) + } +} + +func (s *SupportedDescribeStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedDescribeStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedDropStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedDropStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedDropStatementAliasContext { + var p = new(SupportedDropStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedDropStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedDropStatementAliasContext) SupportedDropStatement() ISupportedDropStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedDropStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedDropStatementContext) +} + +func (s *SupportedDropStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedDropStatementAlias(s) + } +} + +func (s *SupportedDropStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedDropStatementAlias(s) + } +} + +func (s *SupportedDropStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedDropStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedCancelStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedCancelStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedCancelStatementAliasContext { + var p = new(SupportedCancelStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedCancelStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedCancelStatementAliasContext) SupportedCancelStatement() ISupportedCancelStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedCancelStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedCancelStatementContext) +} + +func (s *SupportedCancelStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedCancelStatementAlias(s) + } +} + +func (s *SupportedCancelStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedCancelStatementAlias(s) + } +} + +func (s *SupportedCancelStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedCancelStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedOtherStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedOtherStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedOtherStatementAliasContext { + var p = new(SupportedOtherStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedOtherStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedOtherStatementAliasContext) SupportedOtherStatement() ISupportedOtherStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedOtherStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedOtherStatementContext) +} + +func (s *SupportedOtherStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedOtherStatementAlias(s) + } +} + +func (s *SupportedOtherStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedOtherStatementAlias(s) + } +} + +func (s *SupportedOtherStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedOtherStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedCreateStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedCreateStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedCreateStatementAliasContext { + var p = new(SupportedCreateStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedCreateStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedCreateStatementAliasContext) SupportedCreateStatement() ISupportedCreateStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedCreateStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedCreateStatementContext) +} + +func (s *SupportedCreateStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedCreateStatementAlias(s) + } +} + +func (s *SupportedCreateStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedCreateStatementAlias(s) + } +} + +func (s *SupportedCreateStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedCreateStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedShowStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedShowStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedShowStatementAliasContext { + var p = new(SupportedShowStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedShowStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedShowStatementAliasContext) SupportedShowStatement() ISupportedShowStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedShowStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedShowStatementContext) +} + +func (s *SupportedShowStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedShowStatementAlias(s) + } +} + +func (s *SupportedShowStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedShowStatementAlias(s) + } +} + +func (s *SupportedShowStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedShowStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type SupportedRefreshStatementAliasContext struct { + StatementBaseContext +} + +func NewSupportedRefreshStatementAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SupportedRefreshStatementAliasContext { + var p = new(SupportedRefreshStatementAliasContext) + + InitEmptyStatementBaseContext(&p.StatementBaseContext) + p.parser = parser + p.CopyAll(ctx.(*StatementBaseContext)) + + return p +} + +func (s *SupportedRefreshStatementAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedRefreshStatementAliasContext) SupportedRefreshStatement() ISupportedRefreshStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedRefreshStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedRefreshStatementContext) +} + +func (s *SupportedRefreshStatementAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedRefreshStatementAlias(s) + } +} + +func (s *SupportedRefreshStatementAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedRefreshStatementAlias(s) + } +} + +func (s *SupportedRefreshStatementAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedRefreshStatementAlias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) StatementBase() (localctx IStatementBaseContext) { + localctx = NewStatementBaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, DorisParserRULE_statementBase) + var _la int + + p.SetState(628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 22, p.GetParserRuleContext()) { + case 1: + localctx = NewStatementDefaultContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0 { + { + p.SetState(598) + p.Explain() + } + + } + { + p.SetState(601) + p.Query() + } + p.SetState(603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINTO { + { + p.SetState(602) + p.OutFileClause() + } + + } + + case 2: + localctx = NewSupportedDmlStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(605) + p.SupportedDmlStatement() + } + + case 3: + localctx = NewSupportedCreateStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(606) + p.SupportedCreateStatement() + } + + case 4: + localctx = NewSupportedAlterStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(607) + p.SupportedAlterStatement() + } + + case 5: + localctx = NewMaterializedViewStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(608) + p.MaterializedViewStatement() + } + + case 6: + localctx = NewSupportedJobStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(609) + p.SupportedJobStatement() + } + + case 7: + localctx = NewConstraintStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(610) + p.ConstraintStatement() + } + + case 8: + localctx = NewSupportedCleanStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(611) + p.SupportedCleanStatement() + } + + case 9: + localctx = NewSupportedDescribeStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(612) + p.SupportedDescribeStatement() + } + + case 10: + localctx = NewSupportedDropStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(613) + p.SupportedDropStatement() + } + + case 11: + localctx = NewSupportedSetStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(614) + p.SupportedSetStatement() + } + + case 12: + localctx = NewSupportedUnsetStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(615) + p.SupportedUnsetStatement() + } + + case 13: + localctx = NewSupportedRefreshStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(616) + p.SupportedRefreshStatement() + } + + case 14: + localctx = NewSupportedShowStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(617) + p.SupportedShowStatement() + } + + case 15: + localctx = NewSupportedLoadStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(618) + p.SupportedLoadStatement() + } + + case 16: + localctx = NewSupportedCancelStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(619) + p.SupportedCancelStatement() + } + + case 17: + localctx = NewSupportedRecoverStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(620) + p.SupportedRecoverStatement() + } + + case 18: + localctx = NewSupportedAdminStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(621) + p.SupportedAdminStatement() + } + + case 19: + localctx = NewSupportedUseStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(622) + p.SupportedUseStatement() + } + + case 20: + localctx = NewSupportedOtherStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(623) + p.SupportedOtherStatement() + } + + case 21: + localctx = NewSupportedKillStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(624) + p.SupportedKillStatement() + } + + case 22: + localctx = NewSupportedStatsStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(625) + p.SupportedStatsStatement() + } + + case 23: + localctx = NewSupportedTransactionStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(626) + p.SupportedTransactionStatement() + } + + case 24: + localctx = NewSupportedGrantRevokeStatementAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(627) + p.SupportedGrantRevokeStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaterializedViewStatementContext is an interface to support dynamic dispatch. +type IMaterializedViewStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsMaterializedViewStatementContext differentiates from other interfaces. + IsMaterializedViewStatementContext() +} + +type MaterializedViewStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaterializedViewStatementContext() *MaterializedViewStatementContext { + var p = new(MaterializedViewStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_materializedViewStatement + return p +} + +func InitEmptyMaterializedViewStatementContext(p *MaterializedViewStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_materializedViewStatement +} + +func (*MaterializedViewStatementContext) IsMaterializedViewStatementContext() {} + +func NewMaterializedViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaterializedViewStatementContext { + var p = new(MaterializedViewStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_materializedViewStatement + + return p +} + +func (s *MaterializedViewStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaterializedViewStatementContext) CopyAll(ctx *MaterializedViewStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *MaterializedViewStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaterializedViewStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type RefreshMTMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext +} + +func NewRefreshMTMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RefreshMTMVContext { + var p = new(RefreshMTMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *RefreshMTMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *RefreshMTMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *RefreshMTMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshMTMVContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *RefreshMTMVContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *RefreshMTMVContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *RefreshMTMVContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RefreshMTMVContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *RefreshMTMVContext) COMPLETE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPLETE, 0) +} + +func (s *RefreshMTMVContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *RefreshMTMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshMTMV(s) + } +} + +func (s *RefreshMTMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshMTMV(s) + } +} + +func (s *RefreshMTMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshMTMV(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterMTMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext + newName IIdentifierContext + fileProperties IPropertyItemListContext +} + +func NewAlterMTMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterMTMVContext { + var p = new(AlterMTMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *AlterMTMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *AlterMTMVContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *AlterMTMVContext) GetFileProperties() IPropertyItemListContext { return s.fileProperties } + +func (s *AlterMTMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *AlterMTMVContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *AlterMTMVContext) SetFileProperties(v IPropertyItemListContext) { s.fileProperties = v } + +func (s *AlterMTMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterMTMVContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterMTMVContext) AllMATERIALIZED() []antlr.TerminalNode { + return s.GetTokens(DorisParserMATERIALIZED) +} + +func (s *AlterMTMVContext) MATERIALIZED(i int) antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, i) +} + +func (s *AlterMTMVContext) AllVIEW() []antlr.TerminalNode { + return s.GetTokens(DorisParserVIEW) +} + +func (s *AlterMTMVContext) VIEW(i int) antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, i) +} + +func (s *AlterMTMVContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterMTMVContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *AlterMTMVContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *AlterMTMVContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterMTMVContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *AlterMTMVContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *AlterMTMVContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterMTMVContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterMTMVContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterMTMVContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterMTMVContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterMTMVContext) RefreshMethod() IRefreshMethodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshMethodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshMethodContext) +} + +func (s *AlterMTMVContext) RefreshTrigger() IRefreshTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshTriggerContext) +} + +func (s *AlterMTMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterMTMV(s) + } +} + +func (s *AlterMTMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterMTMV(s) + } +} + +func (s *AlterMTMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterMTMV(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateMTMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext + cols ISimpleColumnDefsContext + keys IIdentifierListContext + hashKeys IIdentifierListContext +} + +func NewCreateMTMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateMTMVContext { + var p = new(CreateMTMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *CreateMTMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *CreateMTMVContext) GetCols() ISimpleColumnDefsContext { return s.cols } + +func (s *CreateMTMVContext) GetKeys() IIdentifierListContext { return s.keys } + +func (s *CreateMTMVContext) GetHashKeys() IIdentifierListContext { return s.hashKeys } + +func (s *CreateMTMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *CreateMTMVContext) SetCols(v ISimpleColumnDefsContext) { s.cols = v } + +func (s *CreateMTMVContext) SetKeys(v IIdentifierListContext) { s.keys = v } + +func (s *CreateMTMVContext) SetHashKeys(v IIdentifierListContext) { s.hashKeys = v } + +func (s *CreateMTMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateMTMVContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateMTMVContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *CreateMTMVContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *CreateMTMVContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *CreateMTMVContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateMTMVContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateMTMVContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateMTMVContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateMTMVContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *CreateMTMVContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *CreateMTMVContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *CreateMTMVContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *CreateMTMVContext) BuildMode() IBuildModeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuildModeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuildModeContext) +} + +func (s *CreateMTMVContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *CreateMTMVContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *CreateMTMVContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CreateMTMVContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateMTMVContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *CreateMTMVContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(DorisParserBY) +} + +func (s *CreateMTMVContext) BY(i int) antlr.TerminalNode { + return s.GetToken(DorisParserBY, i) +} + +func (s *CreateMTMVContext) MvPartition() IMvPartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMvPartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMvPartitionContext) +} + +func (s *CreateMTMVContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTED, 0) +} + +func (s *CreateMTMVContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateMTMVContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CreateMTMVContext) SimpleColumnDefs() ISimpleColumnDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleColumnDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleColumnDefsContext) +} + +func (s *CreateMTMVContext) AllIdentifierList() []IIdentifierListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierListContext); ok { + len++ + } + } + + tst := make([]IIdentifierListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierListContext); ok { + tst[i] = t.(IIdentifierListContext) + i++ + } + } + + return tst +} + +func (s *CreateMTMVContext) IdentifierList(i int) IIdentifierListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *CreateMTMVContext) HASH() antlr.TerminalNode { + return s.GetToken(DorisParserHASH, 0) +} + +func (s *CreateMTMVContext) RANDOM() antlr.TerminalNode { + return s.GetToken(DorisParserRANDOM, 0) +} + +func (s *CreateMTMVContext) RefreshMethod() IRefreshMethodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshMethodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshMethodContext) +} + +func (s *CreateMTMVContext) RefreshTrigger() IRefreshTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshTriggerContext) +} + +func (s *CreateMTMVContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(DorisParserDUPLICATE, 0) +} + +func (s *CreateMTMVContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(DorisParserBUCKETS, 0) +} + +func (s *CreateMTMVContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *CreateMTMVContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *CreateMTMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateMTMV(s) + } +} + +func (s *CreateMTMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateMTMV(s) + } +} + +func (s *CreateMTMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateMTMV(s) + + default: + return t.VisitChildren(s) + } +} + +type ResumeMTMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext +} + +func NewResumeMTMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ResumeMTMVContext { + var p = new(ResumeMTMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *ResumeMTMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *ResumeMTMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *ResumeMTMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResumeMTMVContext) RESUME() antlr.TerminalNode { + return s.GetToken(DorisParserRESUME, 0) +} + +func (s *ResumeMTMVContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *ResumeMTMVContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *ResumeMTMVContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *ResumeMTMVContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ResumeMTMVContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ResumeMTMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterResumeMTMV(s) + } +} + +func (s *ResumeMTMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitResumeMTMV(s) + } +} + +func (s *ResumeMTMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitResumeMTMV(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateMTMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext +} + +func NewShowCreateMTMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateMTMVContext { + var p = new(ShowCreateMTMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *ShowCreateMTMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *ShowCreateMTMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *ShowCreateMTMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateMTMVContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateMTMVContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateMTMVContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *ShowCreateMTMVContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *ShowCreateMTMVContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateMTMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateMTMV(s) + } +} + +func (s *ShowCreateMTMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateMTMV(s) + } +} + +func (s *ShowCreateMTMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateMTMV(s) + + default: + return t.VisitChildren(s) + } +} + +type DropMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext + tableName IMultipartIdentifierContext +} + +func NewDropMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropMVContext { + var p = new(DropMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *DropMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *DropMVContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *DropMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *DropMVContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *DropMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropMVContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropMVContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *DropMVContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *DropMVContext) AllMultipartIdentifier() []IMultipartIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + len++ + } + } + + tst := make([]IMultipartIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultipartIdentifierContext); ok { + tst[i] = t.(IMultipartIdentifierContext) + i++ + } + } + + return tst +} + +func (s *DropMVContext) MultipartIdentifier(i int) IMultipartIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropMVContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropMVContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropMVContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *DropMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropMV(s) + } +} + +func (s *DropMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropMV(s) + } +} + +func (s *DropMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropMV(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelMTMVTaskContext struct { + MaterializedViewStatementContext + taskId antlr.Token + mvName IMultipartIdentifierContext +} + +func NewCancelMTMVTaskContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelMTMVTaskContext { + var p = new(CancelMTMVTaskContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *CancelMTMVTaskContext) GetTaskId() antlr.Token { return s.taskId } + +func (s *CancelMTMVTaskContext) SetTaskId(v antlr.Token) { s.taskId = v } + +func (s *CancelMTMVTaskContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *CancelMTMVTaskContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *CancelMTMVTaskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelMTMVTaskContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelMTMVTaskContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *CancelMTMVTaskContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *CancelMTMVTaskContext) TASK() antlr.TerminalNode { + return s.GetToken(DorisParserTASK, 0) +} + +func (s *CancelMTMVTaskContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *CancelMTMVTaskContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *CancelMTMVTaskContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CancelMTMVTaskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelMTMVTask(s) + } +} + +func (s *CancelMTMVTaskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelMTMVTask(s) + } +} + +func (s *CancelMTMVTaskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelMTMVTask(s) + + default: + return t.VisitChildren(s) + } +} + +type PauseMTMVContext struct { + MaterializedViewStatementContext + mvName IMultipartIdentifierContext +} + +func NewPauseMTMVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PauseMTMVContext { + var p = new(PauseMTMVContext) + + InitEmptyMaterializedViewStatementContext(&p.MaterializedViewStatementContext) + p.parser = parser + p.CopyAll(ctx.(*MaterializedViewStatementContext)) + + return p +} + +func (s *PauseMTMVContext) GetMvName() IMultipartIdentifierContext { return s.mvName } + +func (s *PauseMTMVContext) SetMvName(v IMultipartIdentifierContext) { s.mvName = v } + +func (s *PauseMTMVContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PauseMTMVContext) PAUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPAUSE, 0) +} + +func (s *PauseMTMVContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *PauseMTMVContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *PauseMTMVContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *PauseMTMVContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *PauseMTMVContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *PauseMTMVContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPauseMTMV(s) + } +} + +func (s *PauseMTMVContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPauseMTMV(s) + } +} + +func (s *PauseMTMVContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPauseMTMV(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MaterializedViewStatement() (localctx IMaterializedViewStatementContext) { + localctx = NewMaterializedViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, DorisParserRULE_materializedViewStatement) + var _la int + + p.SetState(771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCREATE: + localctx = NewCreateMTMVContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(630) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(631) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(632) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(633) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(634) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(635) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(638) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateMTMVContext).mvName = _x + } + p.SetState(643) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 { + { + p.SetState(639) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(640) + + var _x = p.SimpleColumnDefs() + + localctx.(*CreateMTMVContext).cols = _x + } + { + p.SetState(641) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBUILD { + { + p.SetState(645) + p.BuildMode() + } + + } + p.SetState(655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserREFRESH { + { + p.SetState(648) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAUTO || _la == DorisParserCOMPLETE { + { + p.SetState(649) + p.RefreshMethod() + } + + } + p.SetState(653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(652) + p.RefreshTrigger() + } + + } + + } + p.SetState(662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDUPLICATE || _la == DorisParserKEY { + p.SetState(658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDUPLICATE { + { + p.SetState(657) + p.Match(DorisParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(660) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(661) + + var _x = p.IdentifierList() + + localctx.(*CreateMTMVContext).keys = _x + } + + } + p.SetState(666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(664) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(665) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION { + { + p.SetState(668) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(669) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(670) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(671) + p.MvPartition() + } + { + p.SetState(672) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDISTRIBUTED { + { + p.SetState(676) + p.Match(DorisParserDISTRIBUTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(677) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserHASH: + { + p.SetState(678) + p.Match(DorisParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(679) + + var _x = p.IdentifierList() + + localctx.(*CreateMTMVContext).hashKeys = _x + } + + case DorisParserRANDOM: + { + p.SetState(680) + p.Match(DorisParserRANDOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBUCKETS { + { + p.SetState(683) + p.Match(DorisParserBUCKETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(684) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAUTO || _la == DorisParserINTEGER_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + } + p.SetState(690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(689) + p.PropertyClause() + } + + } + p.SetState(693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(692) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(695) + p.Query() + } + + case DorisParserREFRESH: + localctx = NewRefreshMTMVContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(697) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(698) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(699) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(700) + + var _x = p.MultipartIdentifier() + + localctx.(*RefreshMTMVContext).mvName = _x + } + p.SetState(704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserPARTITION, DorisParserPARTITIONS, DorisParserTEMPORARY: + { + p.SetState(701) + p.PartitionSpec() + } + + case DorisParserCOMPLETE: + { + p.SetState(702) + p.Match(DorisParserCOMPLETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserAUTO: + { + p.SetState(703) + p.Match(DorisParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case DorisParserALTER: + localctx = NewAlterMTMVContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(706) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(707) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(708) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(709) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterMTMVContext).mvName = _x + } + p.SetState(733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserRENAME: + { + p.SetState(710) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(711) + + var _x = p.Identifier() + + localctx.(*AlterMTMVContext).newName = _x + } + + case DorisParserREFRESH: + { + p.SetState(712) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 39, p.GetParserRuleContext()) { + case 1: + { + p.SetState(713) + p.RefreshMethod() + } + + case 2: + { + p.SetState(714) + p.RefreshTrigger() + } + + case 3: + { + p.SetState(715) + p.RefreshMethod() + } + { + p.SetState(716) + p.RefreshTrigger() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case DorisParserREPLACE: + { + p.SetState(720) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(721) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(722) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(723) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(724) + + var _x = p.Identifier() + + localctx.(*AlterMTMVContext).newName = _x + } + p.SetState(726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(725) + p.PropertyClause() + } + + } + + case DorisParserSET: + { + p.SetState(728) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(729) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(730) + + var _x = p.PropertyItemList() + + localctx.(*AlterMTMVContext).fileProperties = _x + } + { + p.SetState(731) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case DorisParserDROP: + localctx = NewDropMVContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(735) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(736) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(737) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(738) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(739) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(742) + + var _x = p.MultipartIdentifier() + + localctx.(*DropMVContext).mvName = _x + } + p.SetState(745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(743) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(744) + + var _x = p.MultipartIdentifier() + + localctx.(*DropMVContext).tableName = _x + } + + } + + case DorisParserPAUSE: + localctx = NewPauseMTMVContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(747) + p.Match(DorisParserPAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(748) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(749) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(750) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(751) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(752) + + var _x = p.MultipartIdentifier() + + localctx.(*PauseMTMVContext).mvName = _x + } + + case DorisParserRESUME: + localctx = NewResumeMTMVContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(753) + p.Match(DorisParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(754) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(755) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(756) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(757) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(758) + + var _x = p.MultipartIdentifier() + + localctx.(*ResumeMTMVContext).mvName = _x + } + + case DorisParserCANCEL: + localctx = NewCancelMTMVTaskContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(759) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(760) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(761) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(762) + p.Match(DorisParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(763) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CancelMTMVTaskContext).taskId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(764) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(765) + + var _x = p.MultipartIdentifier() + + localctx.(*CancelMTMVTaskContext).mvName = _x + } + + case DorisParserSHOW: + localctx = NewShowCreateMTMVContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(766) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(767) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(768) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(769) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(770) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateMTMVContext).mvName = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedJobStatementContext is an interface to support dynamic dispatch. +type ISupportedJobStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedJobStatementContext differentiates from other interfaces. + IsSupportedJobStatementContext() +} + +type SupportedJobStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedJobStatementContext() *SupportedJobStatementContext { + var p = new(SupportedJobStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedJobStatement + return p +} + +func InitEmptySupportedJobStatementContext(p *SupportedJobStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedJobStatement +} + +func (*SupportedJobStatementContext) IsSupportedJobStatementContext() {} + +func NewSupportedJobStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedJobStatementContext { + var p = new(SupportedJobStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedJobStatement + + return p +} + +func (s *SupportedJobStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedJobStatementContext) CopyAll(ctx *SupportedJobStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedJobStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedJobStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CancelJobTaskContext struct { + SupportedJobStatementContext + jobNameKey IIdentifierContext + jobNameValue antlr.Token + taskIdKey IIdentifierContext + taskIdValue antlr.Token +} + +func NewCancelJobTaskContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelJobTaskContext { + var p = new(CancelJobTaskContext) + + InitEmptySupportedJobStatementContext(&p.SupportedJobStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedJobStatementContext)) + + return p +} + +func (s *CancelJobTaskContext) GetJobNameValue() antlr.Token { return s.jobNameValue } + +func (s *CancelJobTaskContext) GetTaskIdValue() antlr.Token { return s.taskIdValue } + +func (s *CancelJobTaskContext) SetJobNameValue(v antlr.Token) { s.jobNameValue = v } + +func (s *CancelJobTaskContext) SetTaskIdValue(v antlr.Token) { s.taskIdValue = v } + +func (s *CancelJobTaskContext) GetJobNameKey() IIdentifierContext { return s.jobNameKey } + +func (s *CancelJobTaskContext) GetTaskIdKey() IIdentifierContext { return s.taskIdKey } + +func (s *CancelJobTaskContext) SetJobNameKey(v IIdentifierContext) { s.jobNameKey = v } + +func (s *CancelJobTaskContext) SetTaskIdKey(v IIdentifierContext) { s.taskIdKey = v } + +func (s *CancelJobTaskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelJobTaskContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelJobTaskContext) TASK() antlr.TerminalNode { + return s.GetToken(DorisParserTASK, 0) +} + +func (s *CancelJobTaskContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *CancelJobTaskContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(DorisParserEQ) +} + +func (s *CancelJobTaskContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(DorisParserEQ, i) +} + +func (s *CancelJobTaskContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *CancelJobTaskContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CancelJobTaskContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CancelJobTaskContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CancelJobTaskContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *CancelJobTaskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelJobTask(s) + } +} + +func (s *CancelJobTaskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelJobTask(s) + } +} + +func (s *CancelJobTaskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelJobTask(s) + + default: + return t.VisitChildren(s) + } +} + +type ResumeJobContext struct { + SupportedJobStatementContext + jobNameKey IIdentifierContext + jobNameValue antlr.Token +} + +func NewResumeJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ResumeJobContext { + var p = new(ResumeJobContext) + + InitEmptySupportedJobStatementContext(&p.SupportedJobStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedJobStatementContext)) + + return p +} + +func (s *ResumeJobContext) GetJobNameValue() antlr.Token { return s.jobNameValue } + +func (s *ResumeJobContext) SetJobNameValue(v antlr.Token) { s.jobNameValue = v } + +func (s *ResumeJobContext) GetJobNameKey() IIdentifierContext { return s.jobNameKey } + +func (s *ResumeJobContext) SetJobNameKey(v IIdentifierContext) { s.jobNameKey = v } + +func (s *ResumeJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResumeJobContext) RESUME() antlr.TerminalNode { + return s.GetToken(DorisParserRESUME, 0) +} + +func (s *ResumeJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *ResumeJobContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *ResumeJobContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *ResumeJobContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ResumeJobContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ResumeJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterResumeJob(s) + } +} + +func (s *ResumeJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitResumeJob(s) + } +} + +func (s *ResumeJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitResumeJob(s) + + default: + return t.VisitChildren(s) + } +} + +type DropJobContext struct { + SupportedJobStatementContext + jobNameKey IIdentifierContext + jobNameValue antlr.Token +} + +func NewDropJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropJobContext { + var p = new(DropJobContext) + + InitEmptySupportedJobStatementContext(&p.SupportedJobStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedJobStatementContext)) + + return p +} + +func (s *DropJobContext) GetJobNameValue() antlr.Token { return s.jobNameValue } + +func (s *DropJobContext) SetJobNameValue(v antlr.Token) { s.jobNameValue = v } + +func (s *DropJobContext) GetJobNameKey() IIdentifierContext { return s.jobNameKey } + +func (s *DropJobContext) SetJobNameKey(v IIdentifierContext) { s.jobNameKey = v } + +func (s *DropJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropJobContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *DropJobContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *DropJobContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *DropJobContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropJobContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropJobContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropJobContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *DropJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropJob(s) + } +} + +func (s *DropJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropJob(s) + } +} + +func (s *DropJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropJob(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateScheduledJobContext struct { + SupportedJobStatementContext + label IMultipartIdentifierContext + timeInterval antlr.Token + timeUnit IIdentifierContext + startTime antlr.Token + endsTime antlr.Token + atTime antlr.Token +} + +func NewCreateScheduledJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateScheduledJobContext { + var p = new(CreateScheduledJobContext) + + InitEmptySupportedJobStatementContext(&p.SupportedJobStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedJobStatementContext)) + + return p +} + +func (s *CreateScheduledJobContext) GetTimeInterval() antlr.Token { return s.timeInterval } + +func (s *CreateScheduledJobContext) GetStartTime() antlr.Token { return s.startTime } + +func (s *CreateScheduledJobContext) GetEndsTime() antlr.Token { return s.endsTime } + +func (s *CreateScheduledJobContext) GetAtTime() antlr.Token { return s.atTime } + +func (s *CreateScheduledJobContext) SetTimeInterval(v antlr.Token) { s.timeInterval = v } + +func (s *CreateScheduledJobContext) SetStartTime(v antlr.Token) { s.startTime = v } + +func (s *CreateScheduledJobContext) SetEndsTime(v antlr.Token) { s.endsTime = v } + +func (s *CreateScheduledJobContext) SetAtTime(v antlr.Token) { s.atTime = v } + +func (s *CreateScheduledJobContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *CreateScheduledJobContext) GetTimeUnit() IIdentifierContext { return s.timeUnit } + +func (s *CreateScheduledJobContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *CreateScheduledJobContext) SetTimeUnit(v IIdentifierContext) { s.timeUnit = v } + +func (s *CreateScheduledJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateScheduledJobContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateScheduledJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *CreateScheduledJobContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *CreateScheduledJobContext) DO() antlr.TerminalNode { + return s.GetToken(DorisParserDO, 0) +} + +func (s *CreateScheduledJobContext) SupportedDmlStatement() ISupportedDmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedDmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedDmlStatementContext) +} + +func (s *CreateScheduledJobContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateScheduledJobContext) STREAMING() antlr.TerminalNode { + return s.GetToken(DorisParserSTREAMING, 0) +} + +func (s *CreateScheduledJobContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEDULE, 0) +} + +func (s *CreateScheduledJobContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateScheduledJobContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *CreateScheduledJobContext) EVERY() antlr.TerminalNode { + return s.GetToken(DorisParserEVERY, 0) +} + +func (s *CreateScheduledJobContext) AT() antlr.TerminalNode { + return s.GetToken(DorisParserAT, 0) +} + +func (s *CreateScheduledJobContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *CreateScheduledJobContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateScheduledJobContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_TIMESTAMP, 0) +} + +func (s *CreateScheduledJobContext) STARTS() antlr.TerminalNode { + return s.GetToken(DorisParserSTARTS, 0) +} + +func (s *CreateScheduledJobContext) ENDS() antlr.TerminalNode { + return s.GetToken(DorisParserENDS, 0) +} + +func (s *CreateScheduledJobContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *CreateScheduledJobContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *CreateScheduledJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateScheduledJob(s) + } +} + +func (s *CreateScheduledJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateScheduledJob(s) + } +} + +func (s *CreateScheduledJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateScheduledJob(s) + + default: + return t.VisitChildren(s) + } +} + +type PauseJobContext struct { + SupportedJobStatementContext + jobNameKey IIdentifierContext + jobNameValue antlr.Token +} + +func NewPauseJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PauseJobContext { + var p = new(PauseJobContext) + + InitEmptySupportedJobStatementContext(&p.SupportedJobStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedJobStatementContext)) + + return p +} + +func (s *PauseJobContext) GetJobNameValue() antlr.Token { return s.jobNameValue } + +func (s *PauseJobContext) SetJobNameValue(v antlr.Token) { s.jobNameValue = v } + +func (s *PauseJobContext) GetJobNameKey() IIdentifierContext { return s.jobNameKey } + +func (s *PauseJobContext) SetJobNameKey(v IIdentifierContext) { s.jobNameKey = v } + +func (s *PauseJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PauseJobContext) PAUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPAUSE, 0) +} + +func (s *PauseJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *PauseJobContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *PauseJobContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *PauseJobContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PauseJobContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *PauseJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPauseJob(s) + } +} + +func (s *PauseJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPauseJob(s) + } +} + +func (s *PauseJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPauseJob(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterJobContext struct { + SupportedJobStatementContext + jobName IMultipartIdentifierContext +} + +func NewAlterJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterJobContext { + var p = new(AlterJobContext) + + InitEmptySupportedJobStatementContext(&p.SupportedJobStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedJobStatementContext)) + + return p +} + +func (s *AlterJobContext) GetJobName() IMultipartIdentifierContext { return s.jobName } + +func (s *AlterJobContext) SetJobName(v IMultipartIdentifierContext) { s.jobName = v } + +func (s *AlterJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterJobContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *AlterJobContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterJobContext) SupportedDmlStatement() ISupportedDmlStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupportedDmlStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupportedDmlStatementContext) +} + +func (s *AlterJobContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterJob(s) + } +} + +func (s *AlterJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterJob(s) + } +} + +func (s *AlterJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterJob(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedJobStatement() (localctx ISupportedJobStatementContext) { + localctx = NewSupportedJobStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, DorisParserRULE_supportedJobStatement) + var _la int + + p.SetState(857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCREATE: + localctx = NewCreateScheduledJobContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(773) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(774) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(775) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateScheduledJobContext).label = _x + } + p.SetState(777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(776) + p.PropertyClause() + } + + } + { + p.SetState(779) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSTREAMING: + { + p.SetState(780) + p.Match(DorisParserSTREAMING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSCHEDULE: + { + p.SetState(781) + p.Match(DorisParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserEVERY: + { + p.SetState(782) + p.Match(DorisParserEVERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(783) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CreateScheduledJobContext).timeInterval = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(784) + + var _x = p.Identifier() + + localctx.(*CreateScheduledJobContext).timeUnit = _x + } + p.SetState(790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTARTS { + { + p.SetState(785) + p.Match(DorisParserSTARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSTRING_LITERAL: + { + p.SetState(786) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CreateScheduledJobContext).startTime = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCURRENT_TIMESTAMP: + { + p.SetState(787) + p.Match(DorisParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserENDS { + { + p.SetState(792) + p.Match(DorisParserENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(793) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CreateScheduledJobContext).endsTime = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case DorisParserAT: + { + p.SetState(796) + p.Match(DorisParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSTRING_LITERAL: + { + p.SetState(797) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CreateScheduledJobContext).atTime = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCURRENT_TIMESTAMP: + { + p.SetState(798) + p.Match(DorisParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(805) + p.CommentSpec() + } + + } + { + p.SetState(808) + p.Match(DorisParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(809) + p.SupportedDmlStatement() + } + + case DorisParserPAUSE: + localctx = NewPauseJobContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(811) + p.Match(DorisParserPAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(812) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(813) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(814) + + var _x = p.Identifier() + + localctx.(*PauseJobContext).jobNameKey = _x + } + + { + p.SetState(815) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(816) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*PauseJobContext).jobNameValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserALTER: + localctx = NewAlterJobContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(818) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(819) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(820) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterJobContext).jobName = _x + } + + p.SetState(826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) { + case 1: + { + p.SetState(821) + p.PropertyClause() + } + + case 2: + { + p.SetState(822) + p.SupportedDmlStatement() + } + + case 3: + { + p.SetState(823) + p.PropertyClause() + } + { + p.SetState(824) + p.SupportedDmlStatement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case DorisParserDROP: + localctx = NewDropJobContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(828) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(829) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(830) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(831) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(834) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(835) + + var _x = p.Identifier() + + localctx.(*DropJobContext).jobNameKey = _x + } + + { + p.SetState(836) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(837) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropJobContext).jobNameValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserRESUME: + localctx = NewResumeJobContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(839) + p.Match(DorisParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(840) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(841) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(842) + + var _x = p.Identifier() + + localctx.(*ResumeJobContext).jobNameKey = _x + } + + { + p.SetState(843) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(844) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ResumeJobContext).jobNameValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCANCEL: + localctx = NewCancelJobTaskContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(846) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(847) + p.Match(DorisParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(848) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(849) + + var _x = p.Identifier() + + localctx.(*CancelJobTaskContext).jobNameKey = _x + } + + { + p.SetState(850) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(851) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CancelJobTaskContext).jobNameValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(852) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(853) + + var _x = p.Identifier() + + localctx.(*CancelJobTaskContext).taskIdKey = _x + } + + { + p.SetState(854) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(855) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CancelJobTaskContext).taskIdValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintStatementContext is an interface to support dynamic dispatch. +type IConstraintStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsConstraintStatementContext differentiates from other interfaces. + IsConstraintStatementContext() +} + +type ConstraintStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraintStatementContext() *ConstraintStatementContext { + var p = new(ConstraintStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constraintStatement + return p +} + +func InitEmptyConstraintStatementContext(p *ConstraintStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constraintStatement +} + +func (*ConstraintStatementContext) IsConstraintStatementContext() {} + +func NewConstraintStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintStatementContext { + var p = new(ConstraintStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_constraintStatement + + return p +} + +func (s *ConstraintStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintStatementContext) CopyAll(ctx *ConstraintStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ConstraintStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ShowConstraintContext struct { + ConstraintStatementContext + table IMultipartIdentifierContext +} + +func NewShowConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowConstraintContext { + var p = new(ShowConstraintContext) + + InitEmptyConstraintStatementContext(&p.ConstraintStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ConstraintStatementContext)) + + return p +} + +func (s *ShowConstraintContext) GetTable() IMultipartIdentifierContext { return s.table } + +func (s *ShowConstraintContext) SetTable(v IMultipartIdentifierContext) { s.table = v } + +func (s *ShowConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowConstraintContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowConstraintContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(DorisParserCONSTRAINTS, 0) +} + +func (s *ShowConstraintContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowConstraintContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowConstraint(s) + } +} + +func (s *ShowConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowConstraint(s) + } +} + +func (s *ShowConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowConstraint(s) + + default: + return t.VisitChildren(s) + } +} + +type DropConstraintContext struct { + ConstraintStatementContext + table IMultipartIdentifierContext + constraintName IErrorCapturingIdentifierContext +} + +func NewDropConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropConstraintContext { + var p = new(DropConstraintContext) + + InitEmptyConstraintStatementContext(&p.ConstraintStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ConstraintStatementContext)) + + return p +} + +func (s *DropConstraintContext) GetTable() IMultipartIdentifierContext { return s.table } + +func (s *DropConstraintContext) GetConstraintName() IErrorCapturingIdentifierContext { + return s.constraintName +} + +func (s *DropConstraintContext) SetTable(v IMultipartIdentifierContext) { s.table = v } + +func (s *DropConstraintContext) SetConstraintName(v IErrorCapturingIdentifierContext) { + s.constraintName = v +} + +func (s *DropConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropConstraintContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *DropConstraintContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *DropConstraintContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(DorisParserCONSTRAINT, 0) +} + +func (s *DropConstraintContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropConstraintContext) ErrorCapturingIdentifier() IErrorCapturingIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierContext) +} + +func (s *DropConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropConstraint(s) + } +} + +func (s *DropConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropConstraint(s) + } +} + +func (s *DropConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropConstraint(s) + + default: + return t.VisitChildren(s) + } +} + +type AddConstraintContext struct { + ConstraintStatementContext + table IMultipartIdentifierContext + constraintName IErrorCapturingIdentifierContext +} + +func NewAddConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddConstraintContext { + var p = new(AddConstraintContext) + + InitEmptyConstraintStatementContext(&p.ConstraintStatementContext) + p.parser = parser + p.CopyAll(ctx.(*ConstraintStatementContext)) + + return p +} + +func (s *AddConstraintContext) GetTable() IMultipartIdentifierContext { return s.table } + +func (s *AddConstraintContext) GetConstraintName() IErrorCapturingIdentifierContext { + return s.constraintName +} + +func (s *AddConstraintContext) SetTable(v IMultipartIdentifierContext) { s.table = v } + +func (s *AddConstraintContext) SetConstraintName(v IErrorCapturingIdentifierContext) { + s.constraintName = v +} + +func (s *AddConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddConstraintContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AddConstraintContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AddConstraintContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddConstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(DorisParserCONSTRAINT, 0) +} + +func (s *AddConstraintContext) Constraint() IConstraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintContext) +} + +func (s *AddConstraintContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AddConstraintContext) ErrorCapturingIdentifier() IErrorCapturingIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierContext) +} + +func (s *AddConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddConstraint(s) + } +} + +func (s *AddConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddConstraint(s) + } +} + +func (s *AddConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddConstraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ConstraintStatement() (localctx IConstraintStatementContext) { + localctx = NewConstraintStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, DorisParserRULE_constraintStatement) + p.SetState(878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 56, p.GetParserRuleContext()) { + case 1: + localctx = NewAddConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(859) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(860) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(861) + + var _x = p.MultipartIdentifier() + + localctx.(*AddConstraintContext).table = _x + } + { + p.SetState(862) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(863) + p.Match(DorisParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(864) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*AddConstraintContext).constraintName = _x + } + { + p.SetState(865) + p.Constraint() + } + + case 2: + localctx = NewDropConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(867) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(868) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(869) + + var _x = p.MultipartIdentifier() + + localctx.(*DropConstraintContext).table = _x + } + { + p.SetState(870) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(871) + p.Match(DorisParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(872) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*DropConstraintContext).constraintName = _x + } + + case 3: + localctx = NewShowConstraintContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(874) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(875) + p.Match(DorisParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(876) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(877) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowConstraintContext).table = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptSpecBranchContext is an interface to support dynamic dispatch. +type IOptSpecBranchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // Getter signatures + ATSIGN() antlr.TerminalNode + BRANCH() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsOptSpecBranchContext differentiates from other interfaces. + IsOptSpecBranchContext() +} + +type OptSpecBranchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext +} + +func NewEmptyOptSpecBranchContext() *OptSpecBranchContext { + var p = new(OptSpecBranchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optSpecBranch + return p +} + +func InitEmptyOptSpecBranchContext(p *OptSpecBranchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optSpecBranch +} + +func (*OptSpecBranchContext) IsOptSpecBranchContext() {} + +func NewOptSpecBranchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptSpecBranchContext { + var p = new(OptSpecBranchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_optSpecBranch + + return p +} + +func (s *OptSpecBranchContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptSpecBranchContext) GetName() IIdentifierContext { return s.name } + +func (s *OptSpecBranchContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *OptSpecBranchContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *OptSpecBranchContext) BRANCH() antlr.TerminalNode { + return s.GetToken(DorisParserBRANCH, 0) +} + +func (s *OptSpecBranchContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *OptSpecBranchContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *OptSpecBranchContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *OptSpecBranchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptSpecBranchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptSpecBranchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterOptSpecBranch(s) + } +} + +func (s *OptSpecBranchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitOptSpecBranch(s) + } +} + +func (s *OptSpecBranchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitOptSpecBranch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) OptSpecBranch() (localctx IOptSpecBranchContext) { + localctx = NewOptSpecBranchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, DorisParserRULE_optSpecBranch) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(880) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(881) + p.Match(DorisParserBRANCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(882) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(883) + + var _x = p.Identifier() + + localctx.(*OptSpecBranchContext).name = _x + } + { + p.SetState(884) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedDmlStatementContext is an interface to support dynamic dispatch. +type ISupportedDmlStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedDmlStatementContext differentiates from other interfaces. + IsSupportedDmlStatementContext() +} + +type SupportedDmlStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedDmlStatementContext() *SupportedDmlStatementContext { + var p = new(SupportedDmlStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedDmlStatement + return p +} + +func InitEmptySupportedDmlStatementContext(p *SupportedDmlStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedDmlStatement +} + +func (*SupportedDmlStatementContext) IsSupportedDmlStatementContext() {} + +func NewSupportedDmlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedDmlStatementContext { + var p = new(SupportedDmlStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedDmlStatement + + return p +} + +func (s *SupportedDmlStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedDmlStatementContext) CopyAll(ctx *SupportedDmlStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedDmlStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedDmlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type InsertTableContext struct { + SupportedDmlStatementContext + tableName IMultipartIdentifierContext + tableId antlr.Token + labelName IIdentifierContext + cols IIdentifierListContext + hints IIdentifierSeqContext +} + +func NewInsertTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InsertTableContext { + var p = new(InsertTableContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *InsertTableContext) GetTableId() antlr.Token { return s.tableId } + +func (s *InsertTableContext) SetTableId(v antlr.Token) { s.tableId = v } + +func (s *InsertTableContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *InsertTableContext) GetLabelName() IIdentifierContext { return s.labelName } + +func (s *InsertTableContext) GetCols() IIdentifierListContext { return s.cols } + +func (s *InsertTableContext) GetHints() IIdentifierSeqContext { return s.hints } + +func (s *InsertTableContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *InsertTableContext) SetLabelName(v IIdentifierContext) { s.labelName = v } + +func (s *InsertTableContext) SetCols(v IIdentifierListContext) { s.cols = v } + +func (s *InsertTableContext) SetHints(v IIdentifierSeqContext) { s.hints = v } + +func (s *InsertTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertTableContext) INSERT() antlr.TerminalNode { + return s.GetToken(DorisParserINSERT, 0) +} + +func (s *InsertTableContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *InsertTableContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *InsertTableContext) OVERWRITE() antlr.TerminalNode { + return s.GetToken(DorisParserOVERWRITE, 0) +} + +func (s *InsertTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *InsertTableContext) DORIS_INTERNAL_TABLE_ID() antlr.TerminalNode { + return s.GetToken(DorisParserDORIS_INTERNAL_TABLE_ID, 0) +} + +func (s *InsertTableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *InsertTableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *InsertTableContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *InsertTableContext) Cte() ICteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICteContext) +} + +func (s *InsertTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *InsertTableContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *InsertTableContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *InsertTableContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *InsertTableContext) LABEL() antlr.TerminalNode { + return s.GetToken(DorisParserLABEL, 0) +} + +func (s *InsertTableContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *InsertTableContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *InsertTableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *InsertTableContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *InsertTableContext) IdentifierSeq() IIdentifierSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierSeqContext) +} + +func (s *InsertTableContext) OptSpecBranch() IOptSpecBranchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptSpecBranchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptSpecBranchContext) +} + +func (s *InsertTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterInsertTable(s) + } +} + +func (s *InsertTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitInsertTable(s) + } +} + +func (s *InsertTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitInsertTable(s) + + default: + return t.VisitChildren(s) + } +} + +type LoadContext struct { + SupportedDmlStatementContext + lableName IMultipartIdentifierContext + _dataDesc IDataDescContext + dataDescs []IDataDescContext +} + +func NewLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LoadContext { + var p = new(LoadContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *LoadContext) GetLableName() IMultipartIdentifierContext { return s.lableName } + +func (s *LoadContext) Get_dataDesc() IDataDescContext { return s._dataDesc } + +func (s *LoadContext) SetLableName(v IMultipartIdentifierContext) { s.lableName = v } + +func (s *LoadContext) Set_dataDesc(v IDataDescContext) { s._dataDesc = v } + +func (s *LoadContext) GetDataDescs() []IDataDescContext { return s.dataDescs } + +func (s *LoadContext) SetDataDescs(v []IDataDescContext) { s.dataDescs = v } + +func (s *LoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *LoadContext) LABEL() antlr.TerminalNode { + return s.GetToken(DorisParserLABEL, 0) +} + +func (s *LoadContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *LoadContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *LoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *LoadContext) AllDataDesc() []IDataDescContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataDescContext); ok { + len++ + } + } + + tst := make([]IDataDescContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataDescContext); ok { + tst[i] = t.(IDataDescContext) + i++ + } + } + + return tst +} + +func (s *LoadContext) DataDesc(i int) IDataDescContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataDescContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataDescContext) +} + +func (s *LoadContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *LoadContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *LoadContext) WithRemoteStorageSystem() IWithRemoteStorageSystemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithRemoteStorageSystemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithRemoteStorageSystemContext) +} + +func (s *LoadContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *LoadContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *LoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLoad(s) + } +} + +func (s *LoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLoad(s) + } +} + +func (s *LoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type CopyIntoContext struct { + SupportedDmlStatementContext + name IMultipartIdentifierContext + columns IIdentifierListContext + properties IPropertyClauseContext +} + +func NewCopyIntoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CopyIntoContext { + var p = new(CopyIntoContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *CopyIntoContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CopyIntoContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *CopyIntoContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CopyIntoContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CopyIntoContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *CopyIntoContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CopyIntoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CopyIntoContext) COPY() antlr.TerminalNode { + return s.GetToken(DorisParserCOPY, 0) +} + +func (s *CopyIntoContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *CopyIntoContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(DorisParserFROM) +} + +func (s *CopyIntoContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(DorisParserFROM, i) +} + +func (s *CopyIntoContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CopyIntoContext) StageAndPattern() IStageAndPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStageAndPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStageAndPatternContext) +} + +func (s *CopyIntoContext) SelectHint() ISelectHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectHintContext) +} + +func (s *CopyIntoContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *CopyIntoContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CopyIntoContext) SELECT() antlr.TerminalNode { + return s.GetToken(DorisParserSELECT, 0) +} + +func (s *CopyIntoContext) SelectColumnClause() ISelectColumnClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectColumnClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectColumnClauseContext) +} + +func (s *CopyIntoContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CopyIntoContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CopyIntoContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *CopyIntoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCopyInto(s) + } +} + +func (s *CopyIntoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCopyInto(s) + } +} + +func (s *CopyIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCopyInto(s) + + default: + return t.VisitChildren(s) + } +} + +type UpdateContext struct { + SupportedDmlStatementContext + tableName IMultipartIdentifierContext +} + +func NewUpdateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UpdateContext { + var p = new(UpdateContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *UpdateContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *UpdateContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *UpdateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdateContext) UPDATE() antlr.TerminalNode { + return s.GetToken(DorisParserUPDATE, 0) +} + +func (s *UpdateContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *UpdateContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *UpdateContext) UpdateAssignmentSeq() IUpdateAssignmentSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdateAssignmentSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdateAssignmentSeqContext) +} + +func (s *UpdateContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *UpdateContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *UpdateContext) Cte() ICteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICteContext) +} + +func (s *UpdateContext) FromClause() IFromClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromClauseContext) +} + +func (s *UpdateContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *UpdateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUpdate(s) + } +} + +func (s *UpdateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUpdate(s) + } +} + +func (s *UpdateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUpdate(s) + + default: + return t.VisitChildren(s) + } +} + +type TruncateTableContext struct { + SupportedDmlStatementContext +} + +func NewTruncateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TruncateTableContext { + var p = new(TruncateTableContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *TruncateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TruncateTableContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(DorisParserTRUNCATE, 0) +} + +func (s *TruncateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *TruncateTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *TruncateTableContext) SpecifiedPartition() ISpecifiedPartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecifiedPartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpecifiedPartitionContext) +} + +func (s *TruncateTableContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *TruncateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTruncateTable(s) + } +} + +func (s *TruncateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTruncateTable(s) + } +} + +func (s *TruncateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTruncateTable(s) + + default: + return t.VisitChildren(s) + } +} + +type ReplayContext struct { + SupportedDmlStatementContext +} + +func NewReplayContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplayContext { + var p = new(ReplayContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *ReplayContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplayContext) ReplayCommand() IReplayCommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplayCommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplayCommandContext) +} + +func (s *ReplayContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplay(s) + } +} + +func (s *ReplayContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplay(s) + } +} + +func (s *ReplayContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplay(s) + + default: + return t.VisitChildren(s) + } +} + +type DeleteContext struct { + SupportedDmlStatementContext + tableName IMultipartIdentifierContext +} + +func NewDeleteContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DeleteContext { + var p = new(DeleteContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *DeleteContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *DeleteContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *DeleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeleteContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *DeleteContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *DeleteContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *DeleteContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DeleteContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *DeleteContext) Cte() ICteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICteContext) +} + +func (s *DeleteContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *DeleteContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *DeleteContext) Relations() IRelationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationsContext) +} + +func (s *DeleteContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *DeleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDelete(s) + } +} + +func (s *DeleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDelete(s) + } +} + +func (s *DeleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDelete(s) + + default: + return t.VisitChildren(s) + } +} + +type MergeIntoContext struct { + SupportedDmlStatementContext + targetTable IMultipartIdentifierContext + srcRelation IRelationPrimaryContext +} + +func NewMergeIntoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MergeIntoContext { + var p = new(MergeIntoContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *MergeIntoContext) GetTargetTable() IMultipartIdentifierContext { return s.targetTable } + +func (s *MergeIntoContext) GetSrcRelation() IRelationPrimaryContext { return s.srcRelation } + +func (s *MergeIntoContext) SetTargetTable(v IMultipartIdentifierContext) { s.targetTable = v } + +func (s *MergeIntoContext) SetSrcRelation(v IRelationPrimaryContext) { s.srcRelation = v } + +func (s *MergeIntoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MergeIntoContext) MERGE() antlr.TerminalNode { + return s.GetToken(DorisParserMERGE, 0) +} + +func (s *MergeIntoContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *MergeIntoContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *MergeIntoContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *MergeIntoContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MergeIntoContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *MergeIntoContext) RelationPrimary() IRelationPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationPrimaryContext) +} + +func (s *MergeIntoContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *MergeIntoContext) Cte() ICteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICteContext) +} + +func (s *MergeIntoContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *MergeIntoContext) AllMergeMatchedClause() []IMergeMatchedClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMergeMatchedClauseContext); ok { + len++ + } + } + + tst := make([]IMergeMatchedClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMergeMatchedClauseContext); ok { + tst[i] = t.(IMergeMatchedClauseContext) + i++ + } + } + + return tst +} + +func (s *MergeIntoContext) MergeMatchedClause(i int) IMergeMatchedClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMergeMatchedClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMergeMatchedClauseContext) +} + +func (s *MergeIntoContext) AllMergeNotMatchedClause() []IMergeNotMatchedClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMergeNotMatchedClauseContext); ok { + len++ + } + } + + tst := make([]IMergeNotMatchedClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMergeNotMatchedClauseContext); ok { + tst[i] = t.(IMergeNotMatchedClauseContext) + i++ + } + } + + return tst +} + +func (s *MergeIntoContext) MergeNotMatchedClause(i int) IMergeNotMatchedClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMergeNotMatchedClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMergeNotMatchedClauseContext) +} + +func (s *MergeIntoContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *MergeIntoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMergeInto(s) + } +} + +func (s *MergeIntoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMergeInto(s) + } +} + +func (s *MergeIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMergeInto(s) + + default: + return t.VisitChildren(s) + } +} + +type ExportContext struct { + SupportedDmlStatementContext + tableName IMultipartIdentifierContext + partition IIdentifierListContext + filePath antlr.Token +} + +func NewExportContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExportContext { + var p = new(ExportContext) + + InitEmptySupportedDmlStatementContext(&p.SupportedDmlStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDmlStatementContext)) + + return p +} + +func (s *ExportContext) GetFilePath() antlr.Token { return s.filePath } + +func (s *ExportContext) SetFilePath(v antlr.Token) { s.filePath = v } + +func (s *ExportContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ExportContext) GetPartition() IIdentifierListContext { return s.partition } + +func (s *ExportContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ExportContext) SetPartition(v IIdentifierListContext) { s.partition = v } + +func (s *ExportContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExportContext) EXPORT() antlr.TerminalNode { + return s.GetToken(DorisParserEXPORT, 0) +} + +func (s *ExportContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ExportContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *ExportContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ExportContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ExportContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *ExportContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *ExportContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ExportContext) WithRemoteStorageSystem() IWithRemoteStorageSystemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithRemoteStorageSystemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithRemoteStorageSystemContext) +} + +func (s *ExportContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ExportContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExport(s) + } +} + +func (s *ExportContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExport(s) + } +} + +func (s *ExportContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExport(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedDmlStatement() (localctx ISupportedDmlStatementContext) { + localctx = NewSupportedDmlStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, DorisParserRULE_supportedDmlStatement) + var _la int + + p.SetState(1064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 96, p.GetParserRuleContext()) { + case 1: + localctx = NewInsertTableContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0 { + { + p.SetState(886) + p.Explain() + } + + } + p.SetState(890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(889) + p.Cte() + } + + } + { + p.SetState(892) + p.Match(DorisParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserINTO: + { + p.SetState(893) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserOVERWRITE: + { + p.SetState(894) + p.Match(DorisParserOVERWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(895) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 61, p.GetParserRuleContext()) { + case 1: + { + p.SetState(898) + + var _x = p.MultipartIdentifier() + + localctx.(*InsertTableContext).tableName = _x + } + p.SetState(900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserATSIGN { + { + p.SetState(899) + p.OptSpecBranch() + } + + } + + case 2: + { + p.SetState(902) + p.Match(DorisParserDORIS_INTERNAL_TABLE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(903) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(904) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*InsertTableContext).tableId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(905) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(908) + p.PartitionSpec() + } + + } + p.SetState(914) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 { + { + p.SetState(911) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(912) + p.Match(DorisParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(913) + + var _x = p.Identifier() + + localctx.(*InsertTableContext).labelName = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(917) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 { + { + p.SetState(916) + + var _x = p.IdentifierList() + + localctx.(*InsertTableContext).cols = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_BRACKET { + { + p.SetState(919) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(920) + + var _x = p.IdentifierSeq() + + localctx.(*InsertTableContext).hints = _x + } + { + p.SetState(921) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(925) + p.Query() + } + + case 2: + localctx = NewUpdateContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0 { + { + p.SetState(926) + p.Explain() + } + + } + p.SetState(930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(929) + p.Cte() + } + + } + { + p.SetState(932) + p.Match(DorisParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(933) + + var _x = p.MultipartIdentifier() + + localctx.(*UpdateContext).tableName = _x + } + { + p.SetState(934) + p.TableAlias() + } + { + p.SetState(935) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(936) + p.UpdateAssignmentSeq() + } + p.SetState(938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(937) + p.FromClause() + } + + } + p.SetState(941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(940) + p.WhereClause() + } + + } + + case 3: + localctx = NewDeleteContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + p.SetState(944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0 { + { + p.SetState(943) + p.Explain() + } + + } + p.SetState(947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(946) + p.Cte() + } + + } + { + p.SetState(949) + p.Match(DorisParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(950) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(951) + + var _x = p.MultipartIdentifier() + + localctx.(*DeleteContext).tableName = _x + } + p.SetState(953) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 { + { + p.SetState(952) + p.PartitionSpec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(955) + p.TableAlias() + } + p.SetState(958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserUSING { + { + p.SetState(956) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(957) + p.Relations() + } + + } + p.SetState(961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(960) + p.WhereClause() + } + + } + + case 4: + localctx = NewMergeIntoContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + p.SetState(964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0 { + { + p.SetState(963) + p.Explain() + } + + } + p.SetState(967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(966) + p.Cte() + } + + } + { + p.SetState(969) + p.Match(DorisParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(970) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(971) + + var _x = p.MultipartIdentifier() + + localctx.(*MergeIntoContext).targetTable = _x + } + p.SetState(976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816275535981) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + p.SetState(973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(972) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(975) + p.Identifier() + } + + } + { + p.SetState(978) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(979) + + var _x = p.RelationPrimary() + + localctx.(*MergeIntoContext).srcRelation = _x + } + { + p.SetState(980) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(981) + p.Expression() + } + p.SetState(984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == DorisParserWHEN { + p.SetState(984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 79, p.GetParserRuleContext()) { + case 1: + { + p.SetState(982) + p.MergeMatchedClause() + } + + case 2: + { + p.SetState(983) + p.MergeNotMatchedClause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 5: + localctx = NewLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(988) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(989) + p.Match(DorisParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(990) + + var _x = p.MultipartIdentifier() + + localctx.(*LoadContext).lableName = _x + } + { + p.SetState(991) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(992) + + var _x = p.DataDesc() + + localctx.(*LoadContext)._dataDesc = _x + } + localctx.(*LoadContext).dataDescs = append(localctx.(*LoadContext).dataDescs, localctx.(*LoadContext)._dataDesc) + p.SetState(997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(993) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(994) + + var _x = p.DataDesc() + + localctx.(*LoadContext)._dataDesc = _x + } + localctx.(*LoadContext).dataDescs = append(localctx.(*LoadContext).dataDescs, localctx.(*LoadContext)._dataDesc) + + p.SetState(999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1000) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(1001) + p.WithRemoteStorageSystem() + } + + } + p.SetState(1005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1004) + p.PropertyClause() + } + + } + p.SetState(1008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1007) + p.CommentSpec() + } + + } + + case 6: + localctx = NewExportContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1010) + p.Match(DorisParserEXPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1011) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1012) + + var _x = p.MultipartIdentifier() + + localctx.(*ExportContext).tableName = _x + } + p.SetState(1015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION { + { + p.SetState(1013) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1014) + + var _x = p.IdentifierList() + + localctx.(*ExportContext).partition = _x + } + + } + p.SetState(1018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(1017) + p.WhereClause() + } + + } + { + p.SetState(1020) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1021) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ExportContext).filePath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1022) + p.PropertyClause() + } + + } + p.SetState(1026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(1025) + p.WithRemoteStorageSystem() + } + + } + + case 7: + localctx = NewReplayContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1028) + p.ReplayCommand() + } + + case 8: + localctx = NewCopyIntoContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1029) + p.Match(DorisParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1030) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1032) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 89, p.GetParserRuleContext()) == 1 { + { + p.SetState(1031) + p.SelectHint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1034) + + var _x = p.MultipartIdentifier() + + localctx.(*CopyIntoContext).name = _x + } + p.SetState(1036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(1035) + + var _x = p.IdentifierList() + + localctx.(*CopyIntoContext).columns = _x + } + + } + { + p.SetState(1038) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserATSIGN: + { + p.SetState(1039) + p.StageAndPattern() + } + + case DorisParserLEFT_PAREN: + { + p.SetState(1040) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1041) + p.Match(DorisParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1042) + p.SelectColumnClause() + } + { + p.SetState(1043) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1044) + p.StageAndPattern() + } + p.SetState(1046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(1045) + p.WhereClause() + } + + } + { + p.SetState(1048) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(1053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1052) + + var _x = p.PropertyClause() + + localctx.(*CopyIntoContext).properties = _x + } + + } + + case 9: + localctx = NewTruncateTableContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1055) + p.Match(DorisParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1056) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1057) + p.MultipartIdentifier() + } + p.SetState(1059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(1058) + p.SpecifiedPartition() + } + + } + p.SetState(1062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(1061) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMergeMatchedClauseContext is an interface to support dynamic dispatch. +type IMergeMatchedClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCasePredicate returns the casePredicate rule contexts. + GetCasePredicate() IExpressionContext + + // SetCasePredicate sets the casePredicate rule contexts. + SetCasePredicate(IExpressionContext) + + // Getter signatures + WHEN() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + UpdateAssignmentSeq() IUpdateAssignmentSeqContext + DELETE() antlr.TerminalNode + AND() antlr.TerminalNode + Expression() IExpressionContext + + // IsMergeMatchedClauseContext differentiates from other interfaces. + IsMergeMatchedClauseContext() +} + +type MergeMatchedClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + casePredicate IExpressionContext +} + +func NewEmptyMergeMatchedClauseContext() *MergeMatchedClauseContext { + var p = new(MergeMatchedClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mergeMatchedClause + return p +} + +func InitEmptyMergeMatchedClauseContext(p *MergeMatchedClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mergeMatchedClause +} + +func (*MergeMatchedClauseContext) IsMergeMatchedClauseContext() {} + +func NewMergeMatchedClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergeMatchedClauseContext { + var p = new(MergeMatchedClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_mergeMatchedClause + + return p +} + +func (s *MergeMatchedClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *MergeMatchedClauseContext) GetCasePredicate() IExpressionContext { return s.casePredicate } + +func (s *MergeMatchedClauseContext) SetCasePredicate(v IExpressionContext) { s.casePredicate = v } + +func (s *MergeMatchedClauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(DorisParserWHEN, 0) +} + +func (s *MergeMatchedClauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(DorisParserMATCHED, 0) +} + +func (s *MergeMatchedClauseContext) THEN() antlr.TerminalNode { + return s.GetToken(DorisParserTHEN, 0) +} + +func (s *MergeMatchedClauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(DorisParserUPDATE, 0) +} + +func (s *MergeMatchedClauseContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *MergeMatchedClauseContext) UpdateAssignmentSeq() IUpdateAssignmentSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdateAssignmentSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdateAssignmentSeqContext) +} + +func (s *MergeMatchedClauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *MergeMatchedClauseContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *MergeMatchedClauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MergeMatchedClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MergeMatchedClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MergeMatchedClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMergeMatchedClause(s) + } +} + +func (s *MergeMatchedClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMergeMatchedClause(s) + } +} + +func (s *MergeMatchedClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMergeMatchedClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MergeMatchedClause() (localctx IMergeMatchedClauseContext) { + localctx = NewMergeMatchedClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, DorisParserRULE_mergeMatchedClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1066) + p.Match(DorisParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1067) + p.Match(DorisParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAND { + { + p.SetState(1068) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1069) + + var _x = p.Expression() + + localctx.(*MergeMatchedClauseContext).casePredicate = _x + } + + } + { + p.SetState(1072) + p.Match(DorisParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserUPDATE: + { + p.SetState(1073) + p.Match(DorisParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1074) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1075) + p.UpdateAssignmentSeq() + } + + case DorisParserDELETE: + { + p.SetState(1076) + p.Match(DorisParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMergeNotMatchedClauseContext is an interface to support dynamic dispatch. +type IMergeNotMatchedClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCasePredicate returns the casePredicate rule contexts. + GetCasePredicate() IExpressionContext + + // GetCols returns the cols rule contexts. + GetCols() IIdentifierListContext + + // SetCasePredicate sets the casePredicate rule contexts. + SetCasePredicate(IExpressionContext) + + // SetCols sets the cols rule contexts. + SetCols(IIdentifierListContext) + + // Getter signatures + WHEN() antlr.TerminalNode + NOT() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + INSERT() antlr.TerminalNode + VALUES() antlr.TerminalNode + RowConstructor() IRowConstructorContext + AND() antlr.TerminalNode + Expression() IExpressionContext + IdentifierList() IIdentifierListContext + + // IsMergeNotMatchedClauseContext differentiates from other interfaces. + IsMergeNotMatchedClauseContext() +} + +type MergeNotMatchedClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + casePredicate IExpressionContext + cols IIdentifierListContext +} + +func NewEmptyMergeNotMatchedClauseContext() *MergeNotMatchedClauseContext { + var p = new(MergeNotMatchedClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mergeNotMatchedClause + return p +} + +func InitEmptyMergeNotMatchedClauseContext(p *MergeNotMatchedClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mergeNotMatchedClause +} + +func (*MergeNotMatchedClauseContext) IsMergeNotMatchedClauseContext() {} + +func NewMergeNotMatchedClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergeNotMatchedClauseContext { + var p = new(MergeNotMatchedClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_mergeNotMatchedClause + + return p +} + +func (s *MergeNotMatchedClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *MergeNotMatchedClauseContext) GetCasePredicate() IExpressionContext { return s.casePredicate } + +func (s *MergeNotMatchedClauseContext) GetCols() IIdentifierListContext { return s.cols } + +func (s *MergeNotMatchedClauseContext) SetCasePredicate(v IExpressionContext) { s.casePredicate = v } + +func (s *MergeNotMatchedClauseContext) SetCols(v IIdentifierListContext) { s.cols = v } + +func (s *MergeNotMatchedClauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(DorisParserWHEN, 0) +} + +func (s *MergeNotMatchedClauseContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *MergeNotMatchedClauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(DorisParserMATCHED, 0) +} + +func (s *MergeNotMatchedClauseContext) THEN() antlr.TerminalNode { + return s.GetToken(DorisParserTHEN, 0) +} + +func (s *MergeNotMatchedClauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(DorisParserINSERT, 0) +} + +func (s *MergeNotMatchedClauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(DorisParserVALUES, 0) +} + +func (s *MergeNotMatchedClauseContext) RowConstructor() IRowConstructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowConstructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowConstructorContext) +} + +func (s *MergeNotMatchedClauseContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *MergeNotMatchedClauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MergeNotMatchedClauseContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *MergeNotMatchedClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MergeNotMatchedClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MergeNotMatchedClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMergeNotMatchedClause(s) + } +} + +func (s *MergeNotMatchedClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMergeNotMatchedClause(s) + } +} + +func (s *MergeNotMatchedClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMergeNotMatchedClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MergeNotMatchedClause() (localctx IMergeNotMatchedClauseContext) { + localctx = NewMergeNotMatchedClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, DorisParserRULE_mergeNotMatchedClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1079) + p.Match(DorisParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1080) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1081) + p.Match(DorisParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAND { + { + p.SetState(1082) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1083) + + var _x = p.Expression() + + localctx.(*MergeNotMatchedClauseContext).casePredicate = _x + } + + } + { + p.SetState(1086) + p.Match(DorisParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1087) + p.Match(DorisParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(1088) + + var _x = p.IdentifierList() + + localctx.(*MergeNotMatchedClauseContext).cols = _x + } + + } + { + p.SetState(1091) + p.Match(DorisParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1092) + p.RowConstructor() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedCreateStatementContext is an interface to support dynamic dispatch. +type ISupportedCreateStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedCreateStatementContext differentiates from other interfaces. + IsSupportedCreateStatementContext() +} + +type SupportedCreateStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedCreateStatementContext() *SupportedCreateStatementContext { + var p = new(SupportedCreateStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedCreateStatement + return p +} + +func InitEmptySupportedCreateStatementContext(p *SupportedCreateStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedCreateStatement +} + +func (*SupportedCreateStatementContext) IsSupportedCreateStatementContext() {} + +func NewSupportedCreateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedCreateStatementContext { + var p = new(SupportedCreateStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedCreateStatement + + return p +} + +func (s *SupportedCreateStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedCreateStatementContext) CopyAll(ctx *SupportedCreateStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedCreateStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedCreateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CreateTableContext struct { + SupportedCreateStatementContext + name IMultipartIdentifierContext + ctasCols IIdentifierListContext + engine IIdentifierContext + keys IIdentifierListContext + clusterKeys IIdentifierListContext + partition IPartitionTableContext + hashKeys IIdentifierListContext + autoBucket antlr.Token + properties IPropertyClauseContext + extProperties IPropertyClauseContext +} + +func NewCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateTableContext { + var p = new(CreateTableContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateTableContext) GetAutoBucket() antlr.Token { return s.autoBucket } + +func (s *CreateTableContext) SetAutoBucket(v antlr.Token) { s.autoBucket = v } + +func (s *CreateTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CreateTableContext) GetCtasCols() IIdentifierListContext { return s.ctasCols } + +func (s *CreateTableContext) GetEngine() IIdentifierContext { return s.engine } + +func (s *CreateTableContext) GetKeys() IIdentifierListContext { return s.keys } + +func (s *CreateTableContext) GetClusterKeys() IIdentifierListContext { return s.clusterKeys } + +func (s *CreateTableContext) GetPartition() IPartitionTableContext { return s.partition } + +func (s *CreateTableContext) GetHashKeys() IIdentifierListContext { return s.hashKeys } + +func (s *CreateTableContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateTableContext) GetExtProperties() IPropertyClauseContext { return s.extProperties } + +func (s *CreateTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CreateTableContext) SetCtasCols(v IIdentifierListContext) { s.ctasCols = v } + +func (s *CreateTableContext) SetEngine(v IIdentifierContext) { s.engine = v } + +func (s *CreateTableContext) SetKeys(v IIdentifierListContext) { s.keys = v } + +func (s *CreateTableContext) SetClusterKeys(v IIdentifierListContext) { s.clusterKeys = v } + +func (s *CreateTableContext) SetPartition(v IPartitionTableContext) { s.partition = v } + +func (s *CreateTableContext) SetHashKeys(v IIdentifierListContext) { s.hashKeys = v } + +func (s *CreateTableContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateTableContext) SetExtProperties(v IPropertyClauseContext) { s.extProperties = v } + +func (s *CreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTableContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *CreateTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateTableContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateTableContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateTableContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateTableContext) ENGINE() antlr.TerminalNode { + return s.GetToken(DorisParserENGINE, 0) +} + +func (s *CreateTableContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *CreateTableContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *CreateTableContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CreateTableContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateTableContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTED, 0) +} + +func (s *CreateTableContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(DorisParserBY) +} + +func (s *CreateTableContext) BY(i int) antlr.TerminalNode { + return s.GetToken(DorisParserBY, i) +} + +func (s *CreateTableContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *CreateTableContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *CreateTableContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *CreateTableContext) RollupDefs() IRollupDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollupDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollupDefsContext) +} + +func (s *CreateTableContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *CreateTableContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *CreateTableContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *CreateTableContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *CreateTableContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(DorisParserEXTERNAL, 0) +} + +func (s *CreateTableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *CreateTableContext) ColumnDefs() IColumnDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefsContext) +} + +func (s *CreateTableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateTableContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(DorisParserAGGREGATE, 0) +} + +func (s *CreateTableContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(DorisParserUNIQUE, 0) +} + +func (s *CreateTableContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(DorisParserDUPLICATE, 0) +} + +func (s *CreateTableContext) AllIdentifierList() []IIdentifierListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierListContext); ok { + len++ + } + } + + tst := make([]IIdentifierListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierListContext); ok { + tst[i] = t.(IIdentifierListContext) + i++ + } + } + + return tst +} + +func (s *CreateTableContext) IdentifierList(i int) IIdentifierListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *CreateTableContext) PartitionTable() IPartitionTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionTableContext) +} + +func (s *CreateTableContext) AllPropertyClause() []IPropertyClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPropertyClauseContext); ok { + len++ + } + } + + tst := make([]IPropertyClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPropertyClauseContext); ok { + tst[i] = t.(IPropertyClauseContext) + i++ + } + } + + return tst +} + +func (s *CreateTableContext) PropertyClause(i int) IPropertyClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateTableContext) HASH() antlr.TerminalNode { + return s.GetToken(DorisParserHASH, 0) +} + +func (s *CreateTableContext) RANDOM() antlr.TerminalNode { + return s.GetToken(DorisParserRANDOM, 0) +} + +func (s *CreateTableContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *CreateTableContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(DorisParserBUCKETS, 0) +} + +func (s *CreateTableContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CreateTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CreateTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CreateTableContext) IndexDefs() IIndexDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexDefsContext) +} + +func (s *CreateTableContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *CreateTableContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *CreateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateTable(s) + } +} + +func (s *CreateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateTable(s) + } +} + +func (s *CreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateTable(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateWorkloadPolicyContext struct { + SupportedCreateStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewCreateWorkloadPolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateWorkloadPolicyContext { + var p = new(CreateWorkloadPolicyContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateWorkloadPolicyContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *CreateWorkloadPolicyContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateWorkloadPolicyContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *CreateWorkloadPolicyContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateWorkloadPolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateWorkloadPolicyContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateWorkloadPolicyContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *CreateWorkloadPolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *CreateWorkloadPolicyContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CreateWorkloadPolicyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateWorkloadPolicyContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateWorkloadPolicyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateWorkloadPolicyContext) CONDITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserCONDITIONS, 0) +} + +func (s *CreateWorkloadPolicyContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *CreateWorkloadPolicyContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *CreateWorkloadPolicyContext) WorkloadPolicyConditions() IWorkloadPolicyConditionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkloadPolicyConditionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkloadPolicyConditionsContext) +} + +func (s *CreateWorkloadPolicyContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *CreateWorkloadPolicyContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *CreateWorkloadPolicyContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(DorisParserACTIONS, 0) +} + +func (s *CreateWorkloadPolicyContext) WorkloadPolicyActions() IWorkloadPolicyActionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkloadPolicyActionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWorkloadPolicyActionsContext) +} + +func (s *CreateWorkloadPolicyContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateWorkloadPolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateWorkloadPolicy(s) + } +} + +func (s *CreateWorkloadPolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateWorkloadPolicy(s) + } +} + +func (s *CreateWorkloadPolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateWorkloadPolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateResourceContext struct { + SupportedCreateStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewCreateResourceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateResourceContext { + var p = new(CreateResourceContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateResourceContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *CreateResourceContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateResourceContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *CreateResourceContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateResourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateResourceContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateResourceContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *CreateResourceContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CreateResourceContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(DorisParserEXTERNAL, 0) +} + +func (s *CreateResourceContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateResourceContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateResourceContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateResourceContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateResourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateResource(s) + } +} + +func (s *CreateResourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateResource(s) + } +} + +func (s *CreateResourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateResource(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateWorkloadGroupContext struct { + SupportedCreateStatementContext + name IIdentifierOrTextContext + computeGroup IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewCreateWorkloadGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateWorkloadGroupContext { + var p = new(CreateWorkloadGroupContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateWorkloadGroupContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *CreateWorkloadGroupContext) GetComputeGroup() IIdentifierOrTextContext { + return s.computeGroup +} + +func (s *CreateWorkloadGroupContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateWorkloadGroupContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *CreateWorkloadGroupContext) SetComputeGroup(v IIdentifierOrTextContext) { s.computeGroup = v } + +func (s *CreateWorkloadGroupContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateWorkloadGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateWorkloadGroupContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateWorkloadGroupContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *CreateWorkloadGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *CreateWorkloadGroupContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *CreateWorkloadGroupContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CreateWorkloadGroupContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateWorkloadGroupContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateWorkloadGroupContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateWorkloadGroupContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *CreateWorkloadGroupContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateWorkloadGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateWorkloadGroup(s) + } +} + +func (s *CreateWorkloadGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateWorkloadGroup(s) + } +} + +func (s *CreateWorkloadGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateWorkloadGroup(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateDictionaryContext struct { + SupportedCreateStatementContext + name IMultipartIdentifierContext + source IMultipartIdentifierContext + layoutType IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateDictionaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateDictionaryContext { + var p = new(CreateDictionaryContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateDictionaryContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CreateDictionaryContext) GetSource() IMultipartIdentifierContext { return s.source } + +func (s *CreateDictionaryContext) GetLayoutType() IIdentifierContext { return s.layoutType } + +func (s *CreateDictionaryContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateDictionaryContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CreateDictionaryContext) SetSource(v IMultipartIdentifierContext) { s.source = v } + +func (s *CreateDictionaryContext) SetLayoutType(v IIdentifierContext) { s.layoutType = v } + +func (s *CreateDictionaryContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateDictionaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateDictionaryContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateDictionaryContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARY, 0) +} + +func (s *CreateDictionaryContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *CreateDictionaryContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *CreateDictionaryContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *CreateDictionaryContext) DictionaryColumnDefs() IDictionaryColumnDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDictionaryColumnDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDictionaryColumnDefsContext) +} + +func (s *CreateDictionaryContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *CreateDictionaryContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *CreateDictionaryContext) LAYOUT() antlr.TerminalNode { + return s.GetToken(DorisParserLAYOUT, 0) +} + +func (s *CreateDictionaryContext) AllMultipartIdentifier() []IMultipartIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + len++ + } + } + + tst := make([]IMultipartIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultipartIdentifierContext); ok { + tst[i] = t.(IMultipartIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CreateDictionaryContext) MultipartIdentifier(i int) IMultipartIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateDictionaryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateDictionaryContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateDictionaryContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateDictionaryContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateDictionaryContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateDictionaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateDictionary(s) + } +} + +func (s *CreateDictionaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateDictionary(s) + } +} + +func (s *CreateDictionaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateDictionary(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateTableLikeContext struct { + SupportedCreateStatementContext + name IMultipartIdentifierContext + existedTable IMultipartIdentifierContext + rollupNames IIdentifierListContext +} + +func NewCreateTableLikeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateTableLikeContext { + var p = new(CreateTableLikeContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateTableLikeContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CreateTableLikeContext) GetExistedTable() IMultipartIdentifierContext { return s.existedTable } + +func (s *CreateTableLikeContext) GetRollupNames() IIdentifierListContext { return s.rollupNames } + +func (s *CreateTableLikeContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CreateTableLikeContext) SetExistedTable(v IMultipartIdentifierContext) { s.existedTable = v } + +func (s *CreateTableLikeContext) SetRollupNames(v IIdentifierListContext) { s.rollupNames = v } + +func (s *CreateTableLikeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTableLikeContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateTableLikeContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *CreateTableLikeContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *CreateTableLikeContext) AllMultipartIdentifier() []IMultipartIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + len++ + } + } + + tst := make([]IMultipartIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultipartIdentifierContext); ok { + tst[i] = t.(IMultipartIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CreateTableLikeContext) MultipartIdentifier(i int) IMultipartIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateTableLikeContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateTableLikeContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateTableLikeContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateTableLikeContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *CreateTableLikeContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *CreateTableLikeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(DorisParserEXTERNAL, 0) +} + +func (s *CreateTableLikeContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *CreateTableLikeContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *CreateTableLikeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateTableLike(s) + } +} + +func (s *CreateTableLikeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateTableLike(s) + } +} + +func (s *CreateTableLikeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateTableLike(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateRoleContext struct { + SupportedCreateStatementContext + name IIdentifierOrTextContext +} + +func NewCreateRoleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateRoleContext { + var p = new(CreateRoleContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateRoleContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *CreateRoleContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *CreateRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRoleContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateRoleContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *CreateRoleContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CreateRoleContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateRoleContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateRoleContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateRoleContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CreateRoleContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateRole(s) + } +} + +func (s *CreateRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateRole(s) + } +} + +func (s *CreateRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateRole(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateStageContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateStageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateStageContext { + var p = new(CreateStageContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateStageContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateStageContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateStageContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateStageContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateStageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateStageContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateStageContext) STAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGE, 0) +} + +func (s *CreateStageContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateStageContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateStageContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateStageContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateStageContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateStageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateStage(s) + } +} + +func (s *CreateStageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateStage(s) + } +} + +func (s *CreateStageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateStage(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateIndexAnalyzerContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateIndexAnalyzerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateIndexAnalyzerContext { + var p = new(CreateIndexAnalyzerContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateIndexAnalyzerContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateIndexAnalyzerContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateIndexAnalyzerContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateIndexAnalyzerContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateIndexAnalyzerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexAnalyzerContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateIndexAnalyzerContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *CreateIndexAnalyzerContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *CreateIndexAnalyzerContext) ANALYZER() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZER, 0) +} + +func (s *CreateIndexAnalyzerContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateIndexAnalyzerContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateIndexAnalyzerContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateIndexAnalyzerContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateIndexAnalyzerContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateIndexAnalyzerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateIndexAnalyzer(s) + } +} + +func (s *CreateIndexAnalyzerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateIndexAnalyzer(s) + } +} + +func (s *CreateIndexAnalyzerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateIndexAnalyzer(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateIndexTokenizerContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateIndexTokenizerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateIndexTokenizerContext { + var p = new(CreateIndexTokenizerContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateIndexTokenizerContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateIndexTokenizerContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateIndexTokenizerContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateIndexTokenizerContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateIndexTokenizerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexTokenizerContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateIndexTokenizerContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *CreateIndexTokenizerContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *CreateIndexTokenizerContext) TOKENIZER() antlr.TerminalNode { + return s.GetToken(DorisParserTOKENIZER, 0) +} + +func (s *CreateIndexTokenizerContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateIndexTokenizerContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateIndexTokenizerContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateIndexTokenizerContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateIndexTokenizerContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateIndexTokenizerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateIndexTokenizer(s) + } +} + +func (s *CreateIndexTokenizerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateIndexTokenizer(s) + } +} + +func (s *CreateIndexTokenizerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateIndexTokenizer(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateFileContext struct { + SupportedCreateStatementContext + name antlr.Token + database IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateFileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateFileContext { + var p = new(CreateFileContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateFileContext) GetName() antlr.Token { return s.name } + +func (s *CreateFileContext) SetName(v antlr.Token) { s.name = v } + +func (s *CreateFileContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CreateFileContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateFileContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CreateFileContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateFileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateFileContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateFileContext) FILE() antlr.TerminalNode { + return s.GetToken(DorisParserFILE, 0) +} + +func (s *CreateFileContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateFileContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateFileContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CreateFileContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CreateFileContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateFileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateFile(s) + } +} + +func (s *CreateFileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateFile(s) + } +} + +func (s *CreateFileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateFile(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateRowPolicyContext struct { + SupportedCreateStatementContext + name IIdentifierContext + table IMultipartIdentifierContext + type_ antlr.Token + user IUserIdentifyContext + roleName IIdentifierOrTextContext +} + +func NewCreateRowPolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateRowPolicyContext { + var p = new(CreateRowPolicyContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateRowPolicyContext) GetType_() antlr.Token { return s.type_ } + +func (s *CreateRowPolicyContext) SetType_(v antlr.Token) { s.type_ = v } + +func (s *CreateRowPolicyContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateRowPolicyContext) GetTable() IMultipartIdentifierContext { return s.table } + +func (s *CreateRowPolicyContext) GetUser() IUserIdentifyContext { return s.user } + +func (s *CreateRowPolicyContext) GetRoleName() IIdentifierOrTextContext { return s.roleName } + +func (s *CreateRowPolicyContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateRowPolicyContext) SetTable(v IMultipartIdentifierContext) { s.table = v } + +func (s *CreateRowPolicyContext) SetUser(v IUserIdentifyContext) { s.user = v } + +func (s *CreateRowPolicyContext) SetRoleName(v IIdentifierOrTextContext) { s.roleName = v } + +func (s *CreateRowPolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRowPolicyContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateRowPolicyContext) ROW() antlr.TerminalNode { + return s.GetToken(DorisParserROW, 0) +} + +func (s *CreateRowPolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *CreateRowPolicyContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *CreateRowPolicyContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CreateRowPolicyContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *CreateRowPolicyContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *CreateRowPolicyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CreateRowPolicyContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *CreateRowPolicyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CreateRowPolicyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateRowPolicyContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateRowPolicyContext) RESTRICTIVE() antlr.TerminalNode { + return s.GetToken(DorisParserRESTRICTIVE, 0) +} + +func (s *CreateRowPolicyContext) PERMISSIVE() antlr.TerminalNode { + return s.GetToken(DorisParserPERMISSIVE, 0) +} + +func (s *CreateRowPolicyContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *CreateRowPolicyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateRowPolicyContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateRowPolicyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateRowPolicyContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *CreateRowPolicyContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CreateRowPolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateRowPolicy(s) + } +} + +func (s *CreateRowPolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateRowPolicy(s) + } +} + +func (s *CreateRowPolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateRowPolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateEncryptkeyContext struct { + SupportedCreateStatementContext +} + +func NewCreateEncryptkeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateEncryptkeyContext { + var p = new(CreateEncryptkeyContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateEncryptkeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateEncryptkeyContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateEncryptkeyContext) ENCRYPTKEY() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTKEY, 0) +} + +func (s *CreateEncryptkeyContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateEncryptkeyContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CreateEncryptkeyContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateEncryptkeyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateEncryptkeyContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateEncryptkeyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateEncryptkeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateEncryptkey(s) + } +} + +func (s *CreateEncryptkeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateEncryptkey(s) + } +} + +func (s *CreateEncryptkeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateEncryptkey(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateIndexCharFilterContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateIndexCharFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateIndexCharFilterContext { + var p = new(CreateIndexCharFilterContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateIndexCharFilterContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateIndexCharFilterContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateIndexCharFilterContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateIndexCharFilterContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateIndexCharFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexCharFilterContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateIndexCharFilterContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *CreateIndexCharFilterContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *CreateIndexCharFilterContext) CHAR_FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR_FILTER, 0) +} + +func (s *CreateIndexCharFilterContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateIndexCharFilterContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateIndexCharFilterContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateIndexCharFilterContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateIndexCharFilterContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateIndexCharFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateIndexCharFilter(s) + } +} + +func (s *CreateIndexCharFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateIndexCharFilter(s) + } +} + +func (s *CreateIndexCharFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateIndexCharFilter(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateViewContext struct { + SupportedCreateStatementContext + name IMultipartIdentifierContext + cols ISimpleColumnDefsContext +} + +func NewCreateViewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateViewContext { + var p = new(CreateViewContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateViewContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CreateViewContext) GetCols() ISimpleColumnDefsContext { return s.cols } + +func (s *CreateViewContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CreateViewContext) SetCols(v ISimpleColumnDefsContext) { s.cols = v } + +func (s *CreateViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateViewContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *CreateViewContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *CreateViewContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateViewContext) OR() antlr.TerminalNode { + return s.GetToken(DorisParserOR, 0) +} + +func (s *CreateViewContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *CreateViewContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateViewContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateViewContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateViewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CreateViewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CreateViewContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CreateViewContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateViewContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CreateViewContext) SimpleColumnDefs() ISimpleColumnDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleColumnDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleColumnDefsContext) +} + +func (s *CreateViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateView(s) + } +} + +func (s *CreateViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateView(s) + } +} + +func (s *CreateViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateView(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateStorageVaultContext struct { + SupportedCreateStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewCreateStorageVaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateStorageVaultContext { + var p = new(CreateStorageVaultContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateStorageVaultContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *CreateStorageVaultContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateStorageVaultContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *CreateStorageVaultContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateStorageVaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateStorageVaultContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateStorageVaultContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *CreateStorageVaultContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *CreateStorageVaultContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CreateStorageVaultContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateStorageVaultContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateStorageVaultContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateStorageVaultContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateStorageVaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateStorageVault(s) + } +} + +func (s *CreateStorageVaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateStorageVault(s) + } +} + +func (s *CreateStorageVaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateStorageVault(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateUserDefineFunctionContext struct { + SupportedCreateStatementContext + returnType IDataTypeContext + intermediateType IDataTypeContext + properties IPropertyClauseContext +} + +func NewCreateUserDefineFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateUserDefineFunctionContext { + var p = new(CreateUserDefineFunctionContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateUserDefineFunctionContext) GetReturnType() IDataTypeContext { return s.returnType } + +func (s *CreateUserDefineFunctionContext) GetIntermediateType() IDataTypeContext { + return s.intermediateType +} + +func (s *CreateUserDefineFunctionContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateUserDefineFunctionContext) SetReturnType(v IDataTypeContext) { s.returnType = v } + +func (s *CreateUserDefineFunctionContext) SetIntermediateType(v IDataTypeContext) { + s.intermediateType = v +} + +func (s *CreateUserDefineFunctionContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateUserDefineFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUserDefineFunctionContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateUserDefineFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *CreateUserDefineFunctionContext) FunctionIdentifier() IFunctionIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionIdentifierContext) +} + +func (s *CreateUserDefineFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CreateUserDefineFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CreateUserDefineFunctionContext) RETURNS() antlr.TerminalNode { + return s.GetToken(DorisParserRETURNS, 0) +} + +func (s *CreateUserDefineFunctionContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *CreateUserDefineFunctionContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *CreateUserDefineFunctionContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *CreateUserDefineFunctionContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateUserDefineFunctionContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateUserDefineFunctionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateUserDefineFunctionContext) FunctionArguments() IFunctionArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgumentsContext) +} + +func (s *CreateUserDefineFunctionContext) INTERMEDIATE() antlr.TerminalNode { + return s.GetToken(DorisParserINTERMEDIATE, 0) +} + +func (s *CreateUserDefineFunctionContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *CreateUserDefineFunctionContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(DorisParserAGGREGATE, 0) +} + +func (s *CreateUserDefineFunctionContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateUserDefineFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateUserDefineFunction(s) + } +} + +func (s *CreateUserDefineFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateUserDefineFunction(s) + } +} + +func (s *CreateUserDefineFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateUserDefineFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateStoragePolicyContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateStoragePolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateStoragePolicyContext { + var p = new(CreateStoragePolicyContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateStoragePolicyContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateStoragePolicyContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateStoragePolicyContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateStoragePolicyContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateStoragePolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateStoragePolicyContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateStoragePolicyContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *CreateStoragePolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *CreateStoragePolicyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateStoragePolicyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateStoragePolicyContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateStoragePolicyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateStoragePolicyContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateStoragePolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateStoragePolicy(s) + } +} + +func (s *CreateStoragePolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateStoragePolicy(s) + } +} + +func (s *CreateStoragePolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateStoragePolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateIndexContext struct { + SupportedCreateStatementContext + name IIdentifierContext + tableName IMultipartIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateIndexContext { + var p = new(CreateIndexContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateIndexContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateIndexContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *CreateIndexContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateIndexContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateIndexContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *CreateIndexContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *CreateIndexContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *CreateIndexContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *CreateIndexContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateIndexContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateIndexContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateIndexContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateIndexContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateIndexContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *CreateIndexContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CreateIndexContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateIndexContext) BITMAP() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP, 0) +} + +func (s *CreateIndexContext) NGRAM_BF() antlr.TerminalNode { + return s.GetToken(DorisParserNGRAM_BF, 0) +} + +func (s *CreateIndexContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *CreateIndexContext) ANN() antlr.TerminalNode { + return s.GetToken(DorisParserANN, 0) +} + +func (s *CreateIndexContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateIndex(s) + } +} + +func (s *CreateIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateIndex(s) + } +} + +func (s *CreateIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateIndex(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateRepositoryContext struct { + SupportedCreateStatementContext + name IIdentifierContext +} + +func NewCreateRepositoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateRepositoryContext { + var p = new(CreateRepositoryContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateRepositoryContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateRepositoryContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateRepositoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRepositoryContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateRepositoryContext) REPOSITORY() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORY, 0) +} + +func (s *CreateRepositoryContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *CreateRepositoryContext) StorageBackend() IStorageBackendContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorageBackendContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorageBackendContext) +} + +func (s *CreateRepositoryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateRepositoryContext) READ() antlr.TerminalNode { + return s.GetToken(DorisParserREAD, 0) +} + +func (s *CreateRepositoryContext) ONLY() antlr.TerminalNode { + return s.GetToken(DorisParserONLY, 0) +} + +func (s *CreateRepositoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateRepository(s) + } +} + +func (s *CreateRepositoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateRepository(s) + } +} + +func (s *CreateRepositoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateRepository(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateDatabaseContext struct { + SupportedCreateStatementContext + name IMultipartIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateDatabaseContext { + var p = new(CreateDatabaseContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateDatabaseContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *CreateDatabaseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateDatabaseContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *CreateDatabaseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateDatabaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *CreateDatabaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEMA, 0) +} + +func (s *CreateDatabaseContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateDatabaseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateDatabaseContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateDatabaseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateDatabaseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateDatabase(s) + } +} + +func (s *CreateDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateDatabase(s) + } +} + +func (s *CreateDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +type BuildIndexContext struct { + SupportedCreateStatementContext + name IIdentifierContext + tableName IMultipartIdentifierContext +} + +func NewBuildIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BuildIndexContext { + var p = new(BuildIndexContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *BuildIndexContext) GetName() IIdentifierContext { return s.name } + +func (s *BuildIndexContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *BuildIndexContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *BuildIndexContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *BuildIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BuildIndexContext) BUILD() antlr.TerminalNode { + return s.GetToken(DorisParserBUILD, 0) +} + +func (s *BuildIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *BuildIndexContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *BuildIndexContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *BuildIndexContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *BuildIndexContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *BuildIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBuildIndex(s) + } +} + +func (s *BuildIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBuildIndex(s) + } +} + +func (s *BuildIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBuildIndex(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateUserContext struct { + SupportedCreateStatementContext + role antlr.Token +} + +func NewCreateUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateUserContext { + var p = new(CreateUserContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateUserContext) GetRole() antlr.Token { return s.role } + +func (s *CreateUserContext) SetRole(v antlr.Token) { s.role = v } + +func (s *CreateUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUserContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateUserContext) USER() antlr.TerminalNode { + return s.GetToken(DorisParserUSER, 0) +} + +func (s *CreateUserContext) GrantUserIdentify() IGrantUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantUserIdentifyContext) +} + +func (s *CreateUserContext) PasswordOption() IPasswordOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPasswordOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPasswordOptionContext) +} + +func (s *CreateUserContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateUserContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateUserContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateUserContext) SUPERUSER() antlr.TerminalNode { + return s.GetToken(DorisParserSUPERUSER, 0) +} + +func (s *CreateUserContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *CreateUserContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *CreateUserContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *CreateUserContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateUser(s) + } +} + +func (s *CreateUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateUser(s) + } +} + +func (s *CreateUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateUser(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateCatalogContext struct { + SupportedCreateStatementContext + catalogName IIdentifierContext + resourceName IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateCatalogContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateCatalogContext { + var p = new(CreateCatalogContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateCatalogContext) GetCatalogName() IIdentifierContext { return s.catalogName } + +func (s *CreateCatalogContext) GetResourceName() IIdentifierContext { return s.resourceName } + +func (s *CreateCatalogContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateCatalogContext) SetCatalogName(v IIdentifierContext) { s.catalogName = v } + +func (s *CreateCatalogContext) SetResourceName(v IIdentifierContext) { s.resourceName = v } + +func (s *CreateCatalogContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateCatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateCatalogContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateCatalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *CreateCatalogContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CreateCatalogContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateCatalogContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateCatalogContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateCatalogContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateCatalogContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *CreateCatalogContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *CreateCatalogContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CreateCatalogContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CreateCatalogContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateCatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateCatalog(s) + } +} + +func (s *CreateCatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateCatalog(s) + } +} + +func (s *CreateCatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateCatalog(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateAliasFunctionContext struct { + SupportedCreateStatementContext + parameters IIdentifierSeqContext +} + +func NewCreateAliasFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateAliasFunctionContext { + var p = new(CreateAliasFunctionContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateAliasFunctionContext) GetParameters() IIdentifierSeqContext { return s.parameters } + +func (s *CreateAliasFunctionContext) SetParameters(v IIdentifierSeqContext) { s.parameters = v } + +func (s *CreateAliasFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateAliasFunctionContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateAliasFunctionContext) ALIAS() antlr.TerminalNode { + return s.GetToken(DorisParserALIAS, 0) +} + +func (s *CreateAliasFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *CreateAliasFunctionContext) FunctionIdentifier() IFunctionIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionIdentifierContext) +} + +func (s *CreateAliasFunctionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *CreateAliasFunctionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *CreateAliasFunctionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *CreateAliasFunctionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *CreateAliasFunctionContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *CreateAliasFunctionContext) PARAMETER() antlr.TerminalNode { + return s.GetToken(DorisParserPARAMETER, 0) +} + +func (s *CreateAliasFunctionContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CreateAliasFunctionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CreateAliasFunctionContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *CreateAliasFunctionContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateAliasFunctionContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateAliasFunctionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateAliasFunctionContext) FunctionArguments() IFunctionArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgumentsContext) +} + +func (s *CreateAliasFunctionContext) IdentifierSeq() IIdentifierSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierSeqContext) +} + +func (s *CreateAliasFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateAliasFunction(s) + } +} + +func (s *CreateAliasFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateAliasFunction(s) + } +} + +func (s *CreateAliasFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateAliasFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateSqlBlockRuleContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateSqlBlockRuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateSqlBlockRuleContext { + var p = new(CreateSqlBlockRuleContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateSqlBlockRuleContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateSqlBlockRuleContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateSqlBlockRuleContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateSqlBlockRuleContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateSqlBlockRuleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateSqlBlockRuleContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateSqlBlockRuleContext) SQL_BLOCK_RULE() antlr.TerminalNode { + return s.GetToken(DorisParserSQL_BLOCK_RULE, 0) +} + +func (s *CreateSqlBlockRuleContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateSqlBlockRuleContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateSqlBlockRuleContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateSqlBlockRuleContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateSqlBlockRuleContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateSqlBlockRuleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateSqlBlockRule(s) + } +} + +func (s *CreateSqlBlockRuleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateSqlBlockRule(s) + } +} + +func (s *CreateSqlBlockRuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateSqlBlockRule(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateIndexTokenFilterContext struct { + SupportedCreateStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewCreateIndexTokenFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateIndexTokenFilterContext { + var p = new(CreateIndexTokenFilterContext) + + InitEmptySupportedCreateStatementContext(&p.SupportedCreateStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCreateStatementContext)) + + return p +} + +func (s *CreateIndexTokenFilterContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateIndexTokenFilterContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *CreateIndexTokenFilterContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateIndexTokenFilterContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *CreateIndexTokenFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexTokenFilterContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateIndexTokenFilterContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *CreateIndexTokenFilterContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *CreateIndexTokenFilterContext) TOKEN_FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserTOKEN_FILTER, 0) +} + +func (s *CreateIndexTokenFilterContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateIndexTokenFilterContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateIndexTokenFilterContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateIndexTokenFilterContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateIndexTokenFilterContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateIndexTokenFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateIndexTokenFilter(s) + } +} + +func (s *CreateIndexTokenFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateIndexTokenFilter(s) + } +} + +func (s *CreateIndexTokenFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateIndexTokenFilter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedCreateStatement() (localctx ISupportedCreateStatementContext) { + localctx = NewSupportedCreateStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, DorisParserRULE_supportedCreateStatement) + var _la int + + p.SetState(1601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 190, p.GetParserRuleContext()) { + case 1: + localctx = NewCreateTableContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1094) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEXTERNAL || _la == DorisParserTEMPORARY { + { + p.SetState(1095) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserEXTERNAL || _la == DorisParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1098) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1099) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1100) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1101) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1104) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateTableContext).name = _x + } + p.SetState(1119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 106, p.GetParserRuleContext()) { + case 1: + p.SetState(1106) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 { + { + p.SetState(1105) + + var _x = p.IdentifierList() + + localctx.(*CreateTableContext).ctasCols = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(1108) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1109) + p.ColumnDefs() + } + p.SetState(1112) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 104, p.GetParserRuleContext()) == 1 { + { + p.SetState(1110) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1111) + p.IndexDefs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMA { + { + p.SetState(1114) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1117) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(1124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserENGINE { + { + p.SetState(1121) + p.Match(DorisParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1122) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1123) + + var _x = p.Identifier() + + localctx.(*CreateTableContext).engine = _x + } + + } + p.SetState(1134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAGGREGATE || _la == DorisParserDUPLICATE || _la == DorisParserUNIQUE { + { + p.SetState(1126) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAGGREGATE || _la == DorisParserDUPLICATE || _la == DorisParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1127) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1128) + + var _x = p.IdentifierList() + + localctx.(*CreateTableContext).keys = _x + } + p.SetState(1132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCLUSTER { + { + p.SetState(1129) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1130) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1131) + + var _x = p.IdentifierList() + + localctx.(*CreateTableContext).clusterKeys = _x + } + + } + + } + p.SetState(1138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1136) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1137) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAUTO || _la == DorisParserPARTITION { + { + p.SetState(1140) + + var _x = p.PartitionTable() + + localctx.(*CreateTableContext).partition = _x + } + + } + p.SetState(1157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDISTRIBUTED { + { + p.SetState(1143) + p.Match(DorisParserDISTRIBUTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1144) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserHASH: + { + p.SetState(1145) + p.Match(DorisParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1146) + + var _x = p.IdentifierList() + + localctx.(*CreateTableContext).hashKeys = _x + } + + case DorisParserRANDOM: + { + p.SetState(1147) + p.Match(DorisParserRANDOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(1155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBUCKETS { + { + p.SetState(1150) + p.Match(DorisParserBUCKETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserINTEGER_VALUE: + { + p.SetState(1151) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserAUTO: + { + p.SetState(1152) + + var _m = p.Match(DorisParserAUTO) + + localctx.(*CreateTableContext).autoBucket = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + } + p.SetState(1164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserROLLUP { + { + p.SetState(1159) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1160) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1161) + p.RollupDefs() + } + { + p.SetState(1162) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1166) + + var _x = p.PropertyClause() + + localctx.(*CreateTableContext).properties = _x + } + + } + p.SetState(1171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBROKER { + { + p.SetState(1169) + p.Match(DorisParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1170) + + var _x = p.PropertyClause() + + localctx.(*CreateTableContext).extProperties = _x + } + + } + p.SetState(1177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN || _la == DorisParserAS || _la == DorisParserSELECT || _la == DorisParserVALUES || _la == DorisParserWITH { + p.SetState(1174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(1173) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1176) + p.Query() + } + + } + + case 2: + localctx = NewCreateViewContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1179) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserOR { + { + p.SetState(1180) + p.Match(DorisParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1181) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1184) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1185) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1186) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1187) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1190) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateViewContext).name = _x + } + p.SetState(1195) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 { + { + p.SetState(1191) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1192) + + var _x = p.SimpleColumnDefs() + + localctx.(*CreateViewContext).cols = _x + } + { + p.SetState(1193) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1197) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1198) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(1201) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1204) + p.Query() + } + + case 3: + localctx = NewCreateFileContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1206) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1207) + p.Match(DorisParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1208) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CreateFileContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(1209) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1210) + + var _x = p.Identifier() + + localctx.(*CreateFileContext).database = _x + } + + } + { + p.SetState(1213) + + var _x = p.PropertyClause() + + localctx.(*CreateFileContext).properties = _x + } + + case 4: + localctx = NewCreateTableLikeContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1214) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEXTERNAL || _la == DorisParserTEMPORARY { + { + p.SetState(1215) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserEXTERNAL || _la == DorisParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1218) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1219) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1220) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1221) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1224) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateTableLikeContext).name = _x + } + { + p.SetState(1225) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1226) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateTableLikeContext).existedTable = _x + } + p.SetState(1232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(1227) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1228) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(1229) + + var _x = p.IdentifierList() + + localctx.(*CreateTableLikeContext).rollupNames = _x + } + + } + + } + + case 5: + localctx = NewCreateRoleContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1234) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1235) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1236) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1237) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1238) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1241) + + var _x = p.IdentifierOrText() + + localctx.(*CreateRoleContext).name = _x + } + p.SetState(1244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1242) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1243) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + localctx = NewCreateWorkloadGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1246) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1247) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1248) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1249) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1250) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1251) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1254) + + var _x = p.IdentifierOrText() + + localctx.(*CreateWorkloadGroupContext).name = _x + } + p.SetState(1257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(1255) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1256) + + var _x = p.IdentifierOrText() + + localctx.(*CreateWorkloadGroupContext).computeGroup = _x + } + + } + p.SetState(1260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1259) + + var _x = p.PropertyClause() + + localctx.(*CreateWorkloadGroupContext).properties = _x + } + + } + + case 7: + localctx = NewCreateCatalogContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1262) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1263) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1264) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1265) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1266) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1269) + + var _x = p.Identifier() + + localctx.(*CreateCatalogContext).catalogName = _x + } + p.SetState(1273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(1270) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1271) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1272) + + var _x = p.Identifier() + + localctx.(*CreateCatalogContext).resourceName = _x + } + + } + p.SetState(1277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1275) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1276) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1279) + + var _x = p.PropertyClause() + + localctx.(*CreateCatalogContext).properties = _x + } + + } + + case 8: + localctx = NewCreateRowPolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1282) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1283) + p.Match(DorisParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1284) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1285) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1286) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1287) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1290) + + var _x = p.Identifier() + + localctx.(*CreateRowPolicyContext).name = _x + } + { + p.SetState(1291) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1292) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateRowPolicyContext).table = _x + } + { + p.SetState(1293) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1294) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*CreateRowPolicyContext).type_ = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserPERMISSIVE || _la == DorisParserRESTRICTIVE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*CreateRowPolicyContext).type_ = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1295) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(1296) + + var _x = p.UserIdentify() + + localctx.(*CreateRowPolicyContext).user = _x + } + + case DorisParserROLE: + { + p.SetState(1297) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1298) + + var _x = p.IdentifierOrText() + + localctx.(*CreateRowPolicyContext).roleName = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1301) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1302) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1303) + p.booleanExpression(0) + } + { + p.SetState(1304) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewCreateStoragePolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1306) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1307) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1308) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1309) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1310) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1311) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1314) + + var _x = p.Identifier() + + localctx.(*CreateStoragePolicyContext).name = _x + } + p.SetState(1316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1315) + + var _x = p.PropertyClause() + + localctx.(*CreateStoragePolicyContext).properties = _x + } + + } + + case 10: + localctx = NewBuildIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1318) + p.Match(DorisParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1319) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(1320) + + var _x = p.Identifier() + + localctx.(*BuildIndexContext).name = _x + } + + } + { + p.SetState(1323) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1324) + + var _x = p.MultipartIdentifier() + + localctx.(*BuildIndexContext).tableName = _x + } + p.SetState(1326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(1325) + p.PartitionSpec() + } + + } + + case 11: + localctx = NewCreateIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1328) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1329) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1330) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1331) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1332) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1335) + + var _x = p.Identifier() + + localctx.(*CreateIndexContext).name = _x + } + { + p.SetState(1336) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1337) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateIndexContext).tableName = _x + } + { + p.SetState(1338) + p.IdentifierList() + } + p.SetState(1341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserUSING { + { + p.SetState(1339) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1340) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBITMAP || _la == DorisParserINVERTED || _la == DorisParserNGRAM_BF || _la == DorisParserANN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1343) + + var _x = p.PropertyClause() + + localctx.(*CreateIndexContext).properties = _x + } + + } + p.SetState(1348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1346) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1347) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 12: + localctx = NewCreateWorkloadPolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1350) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1351) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1352) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1353) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1354) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1355) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1358) + + var _x = p.IdentifierOrText() + + localctx.(*CreateWorkloadPolicyContext).name = _x + } + p.SetState(1364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCONDITIONS { + { + p.SetState(1359) + p.Match(DorisParserCONDITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1360) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1361) + p.WorkloadPolicyConditions() + } + { + p.SetState(1362) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserACTIONS { + { + p.SetState(1366) + p.Match(DorisParserACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1367) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1368) + p.WorkloadPolicyActions() + } + { + p.SetState(1369) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1373) + + var _x = p.PropertyClause() + + localctx.(*CreateWorkloadPolicyContext).properties = _x + } + + } + + case 13: + localctx = NewCreateSqlBlockRuleContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1376) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1377) + p.Match(DorisParserSQL_BLOCK_RULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1378) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1379) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1380) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1383) + + var _x = p.Identifier() + + localctx.(*CreateSqlBlockRuleContext).name = _x + } + p.SetState(1385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1384) + + var _x = p.PropertyClause() + + localctx.(*CreateSqlBlockRuleContext).properties = _x + } + + } + + case 14: + localctx = NewCreateEncryptkeyContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1387) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1388) + p.Match(DorisParserENCRYPTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1389) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1390) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1391) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1394) + p.MultipartIdentifier() + } + { + p.SetState(1395) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1396) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewCreateUserDefineFunctionContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1398) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(1399) + p.StatementScope() + } + + } + p.SetState(1403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAGGREGATE || _la == DorisParserTABLES { + { + p.SetState(1402) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAGGREGATE || _la == DorisParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1405) + p.Match(DorisParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1409) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 159, p.GetParserRuleContext()) == 1 { + { + p.SetState(1406) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1407) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1408) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1411) + p.FunctionIdentifier() + } + { + p.SetState(1412) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&9152335059222592) != 0) || ((int64((_la-72)) & ^0x3f) == 0 && ((int64(1)<<(_la-72))&254418194574344193) != 0) || _la == DorisParserDOUBLE || _la == DorisParserFLOAT || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&9208814108673) != 0) || _la == DorisParserMAP || _la == DorisParserQUANTILE_STATE || ((int64((_la-446)) & ^0x3f) == 0 && ((int64(1)<<(_la-446))&5634997485569) != 0) || ((int64((_la-520)) & ^0x3f) == 0 && ((int64(1)<<(_la-520))&19) != 0) { + { + p.SetState(1413) + p.FunctionArguments() + } + + } + { + p.SetState(1416) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1417) + p.Match(DorisParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1418) + + var _x = p.DataType() + + localctx.(*CreateUserDefineFunctionContext).returnType = _x + } + p.SetState(1421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINTERMEDIATE { + { + p.SetState(1419) + p.Match(DorisParserINTERMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1420) + + var _x = p.DataType() + + localctx.(*CreateUserDefineFunctionContext).intermediateType = _x + } + + } + p.SetState(1424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1423) + + var _x = p.PropertyClause() + + localctx.(*CreateUserDefineFunctionContext).properties = _x + } + + } + + case 16: + localctx = NewCreateAliasFunctionContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1426) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(1427) + p.StatementScope() + } + + } + { + p.SetState(1430) + p.Match(DorisParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1431) + p.Match(DorisParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1435) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 164, p.GetParserRuleContext()) == 1 { + { + p.SetState(1432) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1433) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1434) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1437) + p.FunctionIdentifier() + } + { + p.SetState(1438) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&9152335059222592) != 0) || ((int64((_la-72)) & ^0x3f) == 0 && ((int64(1)<<(_la-72))&254418194574344193) != 0) || _la == DorisParserDOUBLE || _la == DorisParserFLOAT || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&9208814108673) != 0) || _la == DorisParserMAP || _la == DorisParserQUANTILE_STATE || ((int64((_la-446)) & ^0x3f) == 0 && ((int64(1)<<(_la-446))&5634997485569) != 0) || ((int64((_la-520)) & ^0x3f) == 0 && ((int64(1)<<(_la-520))&19) != 0) { + { + p.SetState(1439) + p.FunctionArguments() + } + + } + { + p.SetState(1442) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1443) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1444) + p.Match(DorisParserPARAMETER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1445) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(1446) + + var _x = p.IdentifierSeq() + + localctx.(*CreateAliasFunctionContext).parameters = _x + } + + } + { + p.SetState(1449) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1450) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1451) + p.Expression() + } + + case 17: + localctx = NewCreateUserContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1453) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1454) + p.Match(DorisParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1455) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1456) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1457) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1460) + p.GrantUserIdentify() + } + p.SetState(1465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case DorisParserSUPERUSER: + { + p.SetState(1461) + p.Match(DorisParserSUPERUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDEFAULT: + { + p.SetState(1462) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1463) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1464) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CreateUserContext).role = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserEOF, DorisParserSEMICOLON, DorisParserACCOUNT_LOCK, DorisParserACCOUNT_UNLOCK, DorisParserCOMMENT, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE: + + default: + } + { + p.SetState(1467) + p.PasswordOption() + } + p.SetState(1469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1468) + p.CommentSpec() + } + + } + + case 18: + localctx = NewCreateDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1471) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1472) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDATABASE || _la == DorisParserSCHEMA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1473) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1474) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1475) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1478) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateDatabaseContext).name = _x + } + p.SetState(1480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1479) + + var _x = p.PropertyClause() + + localctx.(*CreateDatabaseContext).properties = _x + } + + } + + case 19: + localctx = NewCreateRepositoryContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1482) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserREAD { + { + p.SetState(1483) + p.Match(DorisParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1484) + p.Match(DorisParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1487) + p.Match(DorisParserREPOSITORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1488) + + var _x = p.Identifier() + + localctx.(*CreateRepositoryContext).name = _x + } + { + p.SetState(1489) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1490) + p.StorageBackend() + } + + case 20: + localctx = NewCreateResourceContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(1492) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEXTERNAL { + { + p.SetState(1493) + p.Match(DorisParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1496) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1497) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1498) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1499) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1502) + + var _x = p.IdentifierOrText() + + localctx.(*CreateResourceContext).name = _x + } + p.SetState(1504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1503) + + var _x = p.PropertyClause() + + localctx.(*CreateResourceContext).properties = _x + } + + } + + case 21: + localctx = NewCreateDictionaryContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(1506) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1507) + p.Match(DorisParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1508) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1509) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1510) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1513) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateDictionaryContext).name = _x + } + { + p.SetState(1514) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1515) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateDictionaryContext).source = _x + } + { + p.SetState(1516) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1517) + p.DictionaryColumnDefs() + } + { + p.SetState(1518) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1519) + p.Match(DorisParserLAYOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1520) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1521) + + var _x = p.Identifier() + + localctx.(*CreateDictionaryContext).layoutType = _x + } + { + p.SetState(1522) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1523) + + var _x = p.PropertyClause() + + localctx.(*CreateDictionaryContext).properties = _x + } + + } + + case 22: + localctx = NewCreateStageContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(1526) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1527) + p.Match(DorisParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1528) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1529) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1530) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1533) + + var _x = p.Identifier() + + localctx.(*CreateStageContext).name = _x + } + p.SetState(1535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1534) + + var _x = p.PropertyClause() + + localctx.(*CreateStageContext).properties = _x + } + + } + + case 23: + localctx = NewCreateStorageVaultContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(1537) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1538) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1539) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1540) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1541) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1542) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1545) + + var _x = p.IdentifierOrText() + + localctx.(*CreateStorageVaultContext).name = _x + } + p.SetState(1547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1546) + + var _x = p.PropertyClause() + + localctx.(*CreateStorageVaultContext).properties = _x + } + + } + + case 24: + localctx = NewCreateIndexAnalyzerContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(1549) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1550) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1551) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1552) + p.Match(DorisParserANALYZER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1553) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1554) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1555) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1558) + + var _x = p.Identifier() + + localctx.(*CreateIndexAnalyzerContext).name = _x + } + p.SetState(1560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1559) + + var _x = p.PropertyClause() + + localctx.(*CreateIndexAnalyzerContext).properties = _x + } + + } + + case 25: + localctx = NewCreateIndexTokenizerContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(1562) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1563) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1564) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1565) + p.Match(DorisParserTOKENIZER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1566) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1567) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1568) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1571) + + var _x = p.Identifier() + + localctx.(*CreateIndexTokenizerContext).name = _x + } + p.SetState(1573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1572) + + var _x = p.PropertyClause() + + localctx.(*CreateIndexTokenizerContext).properties = _x + } + + } + + case 26: + localctx = NewCreateIndexTokenFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(1575) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1576) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1577) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1578) + p.Match(DorisParserTOKEN_FILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1579) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1580) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1581) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1584) + + var _x = p.Identifier() + + localctx.(*CreateIndexTokenFilterContext).name = _x + } + p.SetState(1586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1585) + + var _x = p.PropertyClause() + + localctx.(*CreateIndexTokenFilterContext).properties = _x + } + + } + + case 27: + localctx = NewCreateIndexCharFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 27) + { + p.SetState(1588) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1589) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1590) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1591) + p.Match(DorisParserCHAR_FILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1592) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1593) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1594) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1597) + + var _x = p.Identifier() + + localctx.(*CreateIndexCharFilterContext).name = _x + } + p.SetState(1599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1598) + + var _x = p.PropertyClause() + + localctx.(*CreateIndexCharFilterContext).properties = _x + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDictionaryColumnDefsContext is an interface to support dynamic dispatch. +type IDictionaryColumnDefsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDictionaryColumnDef() []IDictionaryColumnDefContext + DictionaryColumnDef(i int) IDictionaryColumnDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDictionaryColumnDefsContext differentiates from other interfaces. + IsDictionaryColumnDefsContext() +} + +type DictionaryColumnDefsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDictionaryColumnDefsContext() *DictionaryColumnDefsContext { + var p = new(DictionaryColumnDefsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dictionaryColumnDefs + return p +} + +func InitEmptyDictionaryColumnDefsContext(p *DictionaryColumnDefsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dictionaryColumnDefs +} + +func (*DictionaryColumnDefsContext) IsDictionaryColumnDefsContext() {} + +func NewDictionaryColumnDefsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictionaryColumnDefsContext { + var p = new(DictionaryColumnDefsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dictionaryColumnDefs + + return p +} + +func (s *DictionaryColumnDefsContext) GetParser() antlr.Parser { return s.parser } + +func (s *DictionaryColumnDefsContext) AllDictionaryColumnDef() []IDictionaryColumnDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDictionaryColumnDefContext); ok { + len++ + } + } + + tst := make([]IDictionaryColumnDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDictionaryColumnDefContext); ok { + tst[i] = t.(IDictionaryColumnDefContext) + i++ + } + } + + return tst +} + +func (s *DictionaryColumnDefsContext) DictionaryColumnDef(i int) IDictionaryColumnDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDictionaryColumnDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDictionaryColumnDefContext) +} + +func (s *DictionaryColumnDefsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *DictionaryColumnDefsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *DictionaryColumnDefsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DictionaryColumnDefsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DictionaryColumnDefsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDictionaryColumnDefs(s) + } +} + +func (s *DictionaryColumnDefsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDictionaryColumnDefs(s) + } +} + +func (s *DictionaryColumnDefsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDictionaryColumnDefs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DictionaryColumnDefs() (localctx IDictionaryColumnDefsContext) { + localctx = NewDictionaryColumnDefsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, DorisParserRULE_dictionaryColumnDefs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1603) + p.DictionaryColumnDef() + } + p.SetState(1608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(1604) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1605) + p.DictionaryColumnDef() + } + + p.SetState(1610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDictionaryColumnDefContext is an interface to support dynamic dispatch. +type IDictionaryColumnDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetColumnType returns the columnType token. + GetColumnType() antlr.Token + + // SetColumnType sets the columnType token. + SetColumnType(antlr.Token) + + // GetColName returns the colName rule contexts. + GetColName() IIdentifierContext + + // SetColName sets the colName rule contexts. + SetColName(IIdentifierContext) + + // Getter signatures + Identifier() IIdentifierContext + KEY() antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsDictionaryColumnDefContext differentiates from other interfaces. + IsDictionaryColumnDefContext() +} + +type DictionaryColumnDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + colName IIdentifierContext + columnType antlr.Token +} + +func NewEmptyDictionaryColumnDefContext() *DictionaryColumnDefContext { + var p = new(DictionaryColumnDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dictionaryColumnDef + return p +} + +func InitEmptyDictionaryColumnDefContext(p *DictionaryColumnDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dictionaryColumnDef +} + +func (*DictionaryColumnDefContext) IsDictionaryColumnDefContext() {} + +func NewDictionaryColumnDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DictionaryColumnDefContext { + var p = new(DictionaryColumnDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dictionaryColumnDef + + return p +} + +func (s *DictionaryColumnDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *DictionaryColumnDefContext) GetColumnType() antlr.Token { return s.columnType } + +func (s *DictionaryColumnDefContext) SetColumnType(v antlr.Token) { s.columnType = v } + +func (s *DictionaryColumnDefContext) GetColName() IIdentifierContext { return s.colName } + +func (s *DictionaryColumnDefContext) SetColName(v IIdentifierContext) { s.colName = v } + +func (s *DictionaryColumnDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DictionaryColumnDefContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *DictionaryColumnDefContext) VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserVALUE, 0) +} + +func (s *DictionaryColumnDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DictionaryColumnDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DictionaryColumnDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDictionaryColumnDef(s) + } +} + +func (s *DictionaryColumnDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDictionaryColumnDef(s) + } +} + +func (s *DictionaryColumnDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDictionaryColumnDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DictionaryColumnDef() (localctx IDictionaryColumnDefContext) { + localctx = NewDictionaryColumnDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, DorisParserRULE_dictionaryColumnDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1611) + + var _x = p.Identifier() + + localctx.(*DictionaryColumnDefContext).colName = _x + } + { + p.SetState(1612) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*DictionaryColumnDefContext).columnType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserKEY || _la == DorisParserVALUE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*DictionaryColumnDefContext).columnType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedAlterStatementContext is an interface to support dynamic dispatch. +type ISupportedAlterStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedAlterStatementContext differentiates from other interfaces. + IsSupportedAlterStatementContext() +} + +type SupportedAlterStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedAlterStatementContext() *SupportedAlterStatementContext { + var p = new(SupportedAlterStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedAlterStatement + return p +} + +func InitEmptySupportedAlterStatementContext(p *SupportedAlterStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedAlterStatement +} + +func (*SupportedAlterStatementContext) IsSupportedAlterStatementContext() {} + +func NewSupportedAlterStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedAlterStatementContext { + var p = new(SupportedAlterStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedAlterStatement + + return p +} + +func (s *SupportedAlterStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedAlterStatementContext) CopyAll(ctx *SupportedAlterStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedAlterStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedAlterStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type AlterSystemRenameComputeGroupContext struct { + SupportedAlterStatementContext + name IIdentifierContext + newName IIdentifierContext +} + +func NewAlterSystemRenameComputeGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterSystemRenameComputeGroupContext { + var p = new(AlterSystemRenameComputeGroupContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterSystemRenameComputeGroupContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterSystemRenameComputeGroupContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *AlterSystemRenameComputeGroupContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterSystemRenameComputeGroupContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *AlterSystemRenameComputeGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSystemRenameComputeGroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterSystemRenameComputeGroupContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(DorisParserSYSTEM, 0) +} + +func (s *AlterSystemRenameComputeGroupContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *AlterSystemRenameComputeGroupContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, 0) +} + +func (s *AlterSystemRenameComputeGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *AlterSystemRenameComputeGroupContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *AlterSystemRenameComputeGroupContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterSystemRenameComputeGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterSystemRenameComputeGroup(s) + } +} + +func (s *AlterSystemRenameComputeGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterSystemRenameComputeGroup(s) + } +} + +func (s *AlterSystemRenameComputeGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterSystemRenameComputeGroup(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterCatalogRenameContext struct { + SupportedAlterStatementContext + name IIdentifierContext + newName IIdentifierContext +} + +func NewAlterCatalogRenameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterCatalogRenameContext { + var p = new(AlterCatalogRenameContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterCatalogRenameContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterCatalogRenameContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *AlterCatalogRenameContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterCatalogRenameContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *AlterCatalogRenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterCatalogRenameContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterCatalogRenameContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *AlterCatalogRenameContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *AlterCatalogRenameContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *AlterCatalogRenameContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterCatalogRenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterCatalogRename(s) + } +} + +func (s *AlterCatalogRenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterCatalogRename(s) + } +} + +func (s *AlterCatalogRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterCatalogRename(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterDatabaseSetQuotaContext struct { + SupportedAlterStatementContext + name IIdentifierContext + quota IIdentifierContext +} + +func NewAlterDatabaseSetQuotaContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterDatabaseSetQuotaContext { + var p = new(AlterDatabaseSetQuotaContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterDatabaseSetQuotaContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterDatabaseSetQuotaContext) GetQuota() IIdentifierContext { return s.quota } + +func (s *AlterDatabaseSetQuotaContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterDatabaseSetQuotaContext) SetQuota(v IIdentifierContext) { s.quota = v } + +func (s *AlterDatabaseSetQuotaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterDatabaseSetQuotaContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterDatabaseSetQuotaContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *AlterDatabaseSetQuotaContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterDatabaseSetQuotaContext) QUOTA() antlr.TerminalNode { + return s.GetToken(DorisParserQUOTA, 0) +} + +func (s *AlterDatabaseSetQuotaContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *AlterDatabaseSetQuotaContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterDatabaseSetQuotaContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *AlterDatabaseSetQuotaContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *AlterDatabaseSetQuotaContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(DorisParserTRANSACTION, 0) +} + +func (s *AlterDatabaseSetQuotaContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *AlterDatabaseSetQuotaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterDatabaseSetQuota(s) + } +} + +func (s *AlterDatabaseSetQuotaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterDatabaseSetQuota(s) + } +} + +func (s *AlterDatabaseSetQuotaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterDatabaseSetQuota(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterStorageVaultContext struct { + SupportedAlterStatementContext + name IMultipartIdentifierContext + properties IPropertyClauseContext +} + +func NewAlterStorageVaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterStorageVaultContext { + var p = new(AlterStorageVaultContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterStorageVaultContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterStorageVaultContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterStorageVaultContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterStorageVaultContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterStorageVaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterStorageVaultContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterStorageVaultContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *AlterStorageVaultContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *AlterStorageVaultContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterStorageVaultContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterStorageVaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterStorageVault(s) + } +} + +func (s *AlterStorageVaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterStorageVault(s) + } +} + +func (s *AlterStorageVaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterStorageVault(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterComputeGroupContext struct { + SupportedAlterStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewAlterComputeGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterComputeGroupContext { + var p = new(AlterComputeGroupContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterComputeGroupContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *AlterComputeGroupContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterComputeGroupContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *AlterComputeGroupContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterComputeGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterComputeGroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterComputeGroupContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, 0) +} + +func (s *AlterComputeGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *AlterComputeGroupContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AlterComputeGroupContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterComputeGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterComputeGroup(s) + } +} + +func (s *AlterComputeGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterComputeGroup(s) + } +} + +func (s *AlterComputeGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterComputeGroup(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterUserContext struct { + SupportedAlterStatementContext +} + +func NewAlterUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterUserContext { + var p = new(AlterUserContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterUserContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterUserContext) USER() antlr.TerminalNode { + return s.GetToken(DorisParserUSER, 0) +} + +func (s *AlterUserContext) GrantUserIdentify() IGrantUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantUserIdentifyContext) +} + +func (s *AlterUserContext) PasswordOption() IPasswordOptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPasswordOptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPasswordOptionContext) +} + +func (s *AlterUserContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *AlterUserContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *AlterUserContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *AlterUserContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AlterUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterUser(s) + } +} + +func (s *AlterUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterUser(s) + } +} + +func (s *AlterUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterUser(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterWorkloadPolicyContext struct { + SupportedAlterStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewAlterWorkloadPolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterWorkloadPolicyContext { + var p = new(AlterWorkloadPolicyContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterWorkloadPolicyContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *AlterWorkloadPolicyContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterWorkloadPolicyContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *AlterWorkloadPolicyContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterWorkloadPolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterWorkloadPolicyContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterWorkloadPolicyContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *AlterWorkloadPolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *AlterWorkloadPolicyContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AlterWorkloadPolicyContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterWorkloadPolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterWorkloadPolicy(s) + } +} + +func (s *AlterWorkloadPolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterWorkloadPolicy(s) + } +} + +func (s *AlterWorkloadPolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterWorkloadPolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterDatabaseRenameContext struct { + SupportedAlterStatementContext + name IIdentifierContext + newName IIdentifierContext +} + +func NewAlterDatabaseRenameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterDatabaseRenameContext { + var p = new(AlterDatabaseRenameContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterDatabaseRenameContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterDatabaseRenameContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *AlterDatabaseRenameContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterDatabaseRenameContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *AlterDatabaseRenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterDatabaseRenameContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterDatabaseRenameContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *AlterDatabaseRenameContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *AlterDatabaseRenameContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *AlterDatabaseRenameContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterDatabaseRenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterDatabaseRename(s) + } +} + +func (s *AlterDatabaseRenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterDatabaseRename(s) + } +} + +func (s *AlterDatabaseRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterDatabaseRename(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterDatabasePropertiesContext struct { + SupportedAlterStatementContext + name IIdentifierContext +} + +func NewAlterDatabasePropertiesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterDatabasePropertiesContext { + var p = new(AlterDatabasePropertiesContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterDatabasePropertiesContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterDatabasePropertiesContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterDatabasePropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterDatabasePropertiesContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterDatabasePropertiesContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *AlterDatabasePropertiesContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterDatabasePropertiesContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *AlterDatabasePropertiesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterDatabasePropertiesContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterDatabasePropertiesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterDatabasePropertiesContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterDatabasePropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterDatabaseProperties(s) + } +} + +func (s *AlterDatabasePropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterDatabaseProperties(s) + } +} + +func (s *AlterDatabasePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterDatabaseProperties(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterViewContext struct { + SupportedAlterStatementContext + name IMultipartIdentifierContext + cols ISimpleColumnDefsContext +} + +func NewAlterViewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterViewContext { + var p = new(AlterViewContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterViewContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterViewContext) GetCols() ISimpleColumnDefsContext { return s.cols } + +func (s *AlterViewContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterViewContext) SetCols(v ISimpleColumnDefsContext) { s.cols = v } + +func (s *AlterViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterViewContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *AlterViewContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterViewContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *AlterViewContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *AlterViewContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *AlterViewContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *AlterViewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterViewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterViewContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *AlterViewContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AlterViewContext) SimpleColumnDefs() ISimpleColumnDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleColumnDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpleColumnDefsContext) +} + +func (s *AlterViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterView(s) + } +} + +func (s *AlterViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterView(s) + } +} + +func (s *AlterViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterView(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterSqlBlockRuleContext struct { + SupportedAlterStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewAlterSqlBlockRuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterSqlBlockRuleContext { + var p = new(AlterSqlBlockRuleContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterSqlBlockRuleContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterSqlBlockRuleContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterSqlBlockRuleContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterSqlBlockRuleContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterSqlBlockRuleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSqlBlockRuleContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterSqlBlockRuleContext) SQL_BLOCK_RULE() antlr.TerminalNode { + return s.GetToken(DorisParserSQL_BLOCK_RULE, 0) +} + +func (s *AlterSqlBlockRuleContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterSqlBlockRuleContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterSqlBlockRuleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterSqlBlockRule(s) + } +} + +func (s *AlterSqlBlockRuleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterSqlBlockRule(s) + } +} + +func (s *AlterSqlBlockRuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterSqlBlockRule(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterTableAddRollupContext struct { + SupportedAlterStatementContext + tableName IMultipartIdentifierContext +} + +func NewAlterTableAddRollupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterTableAddRollupContext { + var p = new(AlterTableAddRollupContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterTableAddRollupContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *AlterTableAddRollupContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *AlterTableAddRollupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableAddRollupContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterTableAddRollupContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterTableAddRollupContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AlterTableAddRollupContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *AlterTableAddRollupContext) AllAddRollupClause() []IAddRollupClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAddRollupClauseContext); ok { + len++ + } + } + + tst := make([]IAddRollupClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAddRollupClauseContext); ok { + tst[i] = t.(IAddRollupClauseContext) + i++ + } + } + + return tst +} + +func (s *AlterTableAddRollupContext) AddRollupClause(i int) IAddRollupClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAddRollupClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAddRollupClauseContext) +} + +func (s *AlterTableAddRollupContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterTableAddRollupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AlterTableAddRollupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AlterTableAddRollupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterTableAddRollup(s) + } +} + +func (s *AlterTableAddRollupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterTableAddRollup(s) + } +} + +func (s *AlterTableAddRollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterTableAddRollup(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterRepositoryContext struct { + SupportedAlterStatementContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewAlterRepositoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterRepositoryContext { + var p = new(AlterRepositoryContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterRepositoryContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterRepositoryContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterRepositoryContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterRepositoryContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterRepositoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterRepositoryContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterRepositoryContext) REPOSITORY() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORY, 0) +} + +func (s *AlterRepositoryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterRepositoryContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterRepositoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterRepository(s) + } +} + +func (s *AlterRepositoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterRepository(s) + } +} + +func (s *AlterRepositoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterRepository(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterSystemContext struct { + SupportedAlterStatementContext +} + +func NewAlterSystemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterSystemContext { + var p = new(AlterSystemContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterSystemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSystemContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterSystemContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(DorisParserSYSTEM, 0) +} + +func (s *AlterSystemContext) AlterSystemClause() IAlterSystemClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterSystemClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterSystemClauseContext) +} + +func (s *AlterSystemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterSystem(s) + } +} + +func (s *AlterSystemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterSystem(s) + } +} + +func (s *AlterSystemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterSystem(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterWorkloadGroupContext struct { + SupportedAlterStatementContext + name IIdentifierOrTextContext + computeGroup IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewAlterWorkloadGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterWorkloadGroupContext { + var p = new(AlterWorkloadGroupContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterWorkloadGroupContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *AlterWorkloadGroupContext) GetComputeGroup() IIdentifierOrTextContext { return s.computeGroup } + +func (s *AlterWorkloadGroupContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterWorkloadGroupContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *AlterWorkloadGroupContext) SetComputeGroup(v IIdentifierOrTextContext) { s.computeGroup = v } + +func (s *AlterWorkloadGroupContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterWorkloadGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterWorkloadGroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterWorkloadGroupContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *AlterWorkloadGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *AlterWorkloadGroupContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *AlterWorkloadGroupContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AlterWorkloadGroupContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *AlterWorkloadGroupContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterWorkloadGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterWorkloadGroup(s) + } +} + +func (s *AlterWorkloadGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterWorkloadGroup(s) + } +} + +func (s *AlterWorkloadGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterWorkloadGroup(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterTableDropRollupContext struct { + SupportedAlterStatementContext + tableName IMultipartIdentifierContext +} + +func NewAlterTableDropRollupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterTableDropRollupContext { + var p = new(AlterTableDropRollupContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterTableDropRollupContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *AlterTableDropRollupContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *AlterTableDropRollupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableDropRollupContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterTableDropRollupContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterTableDropRollupContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *AlterTableDropRollupContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *AlterTableDropRollupContext) AllDropRollupClause() []IDropRollupClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDropRollupClauseContext); ok { + len++ + } + } + + tst := make([]IDropRollupClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDropRollupClauseContext); ok { + tst[i] = t.(IDropRollupClauseContext) + i++ + } + } + + return tst +} + +func (s *AlterTableDropRollupContext) DropRollupClause(i int) IDropRollupClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropRollupClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDropRollupClauseContext) +} + +func (s *AlterTableDropRollupContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterTableDropRollupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AlterTableDropRollupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AlterTableDropRollupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterTableDropRollup(s) + } +} + +func (s *AlterTableDropRollupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterTableDropRollup(s) + } +} + +func (s *AlterTableDropRollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterTableDropRollup(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterTablePropertiesContext struct { + SupportedAlterStatementContext + name IMultipartIdentifierContext +} + +func NewAlterTablePropertiesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterTablePropertiesContext { + var p = new(AlterTablePropertiesContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterTablePropertiesContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterTablePropertiesContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterTablePropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTablePropertiesContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterTablePropertiesContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterTablePropertiesContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterTablePropertiesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterTablePropertiesContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterTablePropertiesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterTablePropertiesContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterTablePropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterTableProperties(s) + } +} + +func (s *AlterTablePropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterTableProperties(s) + } +} + +func (s *AlterTablePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterTableProperties(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterRoleContext struct { + SupportedAlterStatementContext + role IIdentifierOrTextContext +} + +func NewAlterRoleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterRoleContext { + var p = new(AlterRoleContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterRoleContext) GetRole() IIdentifierOrTextContext { return s.role } + +func (s *AlterRoleContext) SetRole(v IIdentifierOrTextContext) { s.role = v } + +func (s *AlterRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterRoleContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterRoleContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *AlterRoleContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *AlterRoleContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AlterRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterRole(s) + } +} + +func (s *AlterRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterRole(s) + } +} + +func (s *AlterRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterRole(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterCatalogPropertiesContext struct { + SupportedAlterStatementContext + name IIdentifierContext +} + +func NewAlterCatalogPropertiesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterCatalogPropertiesContext { + var p = new(AlterCatalogPropertiesContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterCatalogPropertiesContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterCatalogPropertiesContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterCatalogPropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterCatalogPropertiesContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterCatalogPropertiesContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *AlterCatalogPropertiesContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterCatalogPropertiesContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *AlterCatalogPropertiesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterCatalogPropertiesContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterCatalogPropertiesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterCatalogPropertiesContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterCatalogPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterCatalogProperties(s) + } +} + +func (s *AlterCatalogPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterCatalogProperties(s) + } +} + +func (s *AlterCatalogPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterCatalogProperties(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterCatalogCommentContext struct { + SupportedAlterStatementContext + name IIdentifierContext + comment antlr.Token +} + +func NewAlterCatalogCommentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterCatalogCommentContext { + var p = new(AlterCatalogCommentContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterCatalogCommentContext) GetComment() antlr.Token { return s.comment } + +func (s *AlterCatalogCommentContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *AlterCatalogCommentContext) GetName() IIdentifierContext { return s.name } + +func (s *AlterCatalogCommentContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *AlterCatalogCommentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterCatalogCommentContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterCatalogCommentContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *AlterCatalogCommentContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *AlterCatalogCommentContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *AlterCatalogCommentContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterCatalogCommentContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AlterCatalogCommentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterCatalogComment(s) + } +} + +func (s *AlterCatalogCommentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterCatalogComment(s) + } +} + +func (s *AlterCatalogCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterCatalogComment(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterStoragePolicyContext struct { + SupportedAlterStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewAlterStoragePolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterStoragePolicyContext { + var p = new(AlterStoragePolicyContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterStoragePolicyContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *AlterStoragePolicyContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterStoragePolicyContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *AlterStoragePolicyContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterStoragePolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterStoragePolicyContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterStoragePolicyContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *AlterStoragePolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *AlterStoragePolicyContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AlterStoragePolicyContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterStoragePolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterStoragePolicy(s) + } +} + +func (s *AlterStoragePolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterStoragePolicy(s) + } +} + +func (s *AlterStoragePolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterStoragePolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterResourceContext struct { + SupportedAlterStatementContext + name IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewAlterResourceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterResourceContext { + var p = new(AlterResourceContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterResourceContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *AlterResourceContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterResourceContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *AlterResourceContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterResourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterResourceContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterResourceContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *AlterResourceContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AlterResourceContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterResourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterResource(s) + } +} + +func (s *AlterResourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterResource(s) + } +} + +func (s *AlterResourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterResource(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterRoutineLoadContext struct { + SupportedAlterStatementContext + name IMultipartIdentifierContext + properties IPropertyClauseContext + type_ IIdentifierContext +} + +func NewAlterRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterRoutineLoadContext { + var p = new(AlterRoutineLoadContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterRoutineLoadContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterRoutineLoadContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterRoutineLoadContext) GetType_() IIdentifierContext { return s.type_ } + +func (s *AlterRoutineLoadContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterRoutineLoadContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterRoutineLoadContext) SetType_(v IIdentifierContext) { s.type_ = v } + +func (s *AlterRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterRoutineLoadContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *AlterRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *AlterRoutineLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *AlterRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterRoutineLoadContext) AllLoadProperty() []ILoadPropertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILoadPropertyContext); ok { + len++ + } + } + + tst := make([]ILoadPropertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILoadPropertyContext); ok { + tst[i] = t.(ILoadPropertyContext) + i++ + } + } + + return tst +} + +func (s *AlterRoutineLoadContext) LoadProperty(i int) ILoadPropertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadPropertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILoadPropertyContext) +} + +func (s *AlterRoutineLoadContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *AlterRoutineLoadContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterRoutineLoadContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterRoutineLoadContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterRoutineLoadContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterRoutineLoadContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterRoutineLoadContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AlterRoutineLoadContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AlterRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterRoutineLoad(s) + } +} + +func (s *AlterRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterRoutineLoad(s) + } +} + +func (s *AlterRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterTableContext struct { + SupportedAlterStatementContext + tableName IMultipartIdentifierContext +} + +func NewAlterTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterTableContext { + var p = new(AlterTableContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterTableContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *AlterTableContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *AlterTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterTableContext) AllAlterTableClause() []IAlterTableClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlterTableClauseContext); ok { + len++ + } + } + + tst := make([]IAlterTableClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlterTableClauseContext); ok { + tst[i] = t.(IAlterTableClauseContext) + i++ + } + } + + return tst +} + +func (s *AlterTableContext) AlterTableClause(i int) IAlterTableClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableClauseContext) +} + +func (s *AlterTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AlterTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AlterTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterTable(s) + } +} + +func (s *AlterTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterTable(s) + } +} + +func (s *AlterTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterTable(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterColocateGroupContext struct { + SupportedAlterStatementContext + name IMultipartIdentifierContext +} + +func NewAlterColocateGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterColocateGroupContext { + var p = new(AlterColocateGroupContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterColocateGroupContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterColocateGroupContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterColocateGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterColocateGroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterColocateGroupContext) COLOCATE() antlr.TerminalNode { + return s.GetToken(DorisParserCOLOCATE, 0) +} + +func (s *AlterColocateGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *AlterColocateGroupContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterColocateGroupContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterColocateGroupContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterColocateGroupContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterColocateGroupContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterColocateGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterColocateGroup(s) + } +} + +func (s *AlterColocateGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterColocateGroup(s) + } +} + +func (s *AlterColocateGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterColocateGroup(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterTableExecuteContext struct { + SupportedAlterStatementContext + tableName IMultipartIdentifierContext + actionName IIdentifierContext + whereExpression IBooleanExpressionContext +} + +func NewAlterTableExecuteContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterTableExecuteContext { + var p = new(AlterTableExecuteContext) + + InitEmptySupportedAlterStatementContext(&p.SupportedAlterStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAlterStatementContext)) + + return p +} + +func (s *AlterTableExecuteContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *AlterTableExecuteContext) GetActionName() IIdentifierContext { return s.actionName } + +func (s *AlterTableExecuteContext) GetWhereExpression() IBooleanExpressionContext { + return s.whereExpression +} + +func (s *AlterTableExecuteContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *AlterTableExecuteContext) SetActionName(v IIdentifierContext) { s.actionName = v } + +func (s *AlterTableExecuteContext) SetWhereExpression(v IBooleanExpressionContext) { + s.whereExpression = v +} + +func (s *AlterTableExecuteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableExecuteContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterTableExecuteContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterTableExecuteContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(DorisParserEXECUTE, 0) +} + +func (s *AlterTableExecuteContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterTableExecuteContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterTableExecuteContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterTableExecuteContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterTableExecuteContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterTableExecuteContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *AlterTableExecuteContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *AlterTableExecuteContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *AlterTableExecuteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterTableExecute(s) + } +} + +func (s *AlterTableExecuteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterTableExecute(s) + } +} + +func (s *AlterTableExecuteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterTableExecute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedAlterStatement() (localctx ISupportedAlterStatementContext) { + localctx = NewSupportedAlterStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, DorisParserRULE_supportedAlterStatement) + var _la int + + p.SetState(1860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 215, p.GetParserRuleContext()) { + case 1: + localctx = NewAlterSystemContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1614) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1615) + p.Match(DorisParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1616) + p.AlterSystemClause() + } + + case 2: + localctx = NewAlterViewContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1617) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1618) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1619) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterViewContext).name = _x + } + p.SetState(1634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserMODIFY: + { + p.SetState(1620) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1621) + p.CommentSpec() + } + + case DorisParserLEFT_PAREN, DorisParserAS, DorisParserCOMMENT: + p.SetState(1626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(1622) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1623) + + var _x = p.SimpleColumnDefs() + + localctx.(*AlterViewContext).cols = _x + } + { + p.SetState(1624) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1628) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1629) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1632) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1633) + p.Query() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + localctx = NewAlterCatalogRenameContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1636) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1637) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1638) + + var _x = p.Identifier() + + localctx.(*AlterCatalogRenameContext).name = _x + } + { + p.SetState(1639) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1640) + + var _x = p.Identifier() + + localctx.(*AlterCatalogRenameContext).newName = _x + } + + case 4: + localctx = NewAlterRoleContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1642) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1643) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1644) + + var _x = p.IdentifierOrText() + + localctx.(*AlterRoleContext).role = _x + } + { + p.SetState(1645) + p.CommentSpec() + } + + case 5: + localctx = NewAlterStorageVaultContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1647) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1648) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1649) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1650) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterStorageVaultContext).name = _x + } + { + p.SetState(1651) + + var _x = p.PropertyClause() + + localctx.(*AlterStorageVaultContext).properties = _x + } + + case 6: + localctx = NewAlterWorkloadGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1653) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1654) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1655) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1656) + + var _x = p.IdentifierOrText() + + localctx.(*AlterWorkloadGroupContext).name = _x + } + p.SetState(1659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(1657) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1658) + + var _x = p.IdentifierOrText() + + localctx.(*AlterWorkloadGroupContext).computeGroup = _x + } + + } + p.SetState(1662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1661) + + var _x = p.PropertyClause() + + localctx.(*AlterWorkloadGroupContext).properties = _x + } + + } + + case 7: + localctx = NewAlterComputeGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1664) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1665) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1666) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1667) + + var _x = p.IdentifierOrText() + + localctx.(*AlterComputeGroupContext).name = _x + } + p.SetState(1669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1668) + + var _x = p.PropertyClause() + + localctx.(*AlterComputeGroupContext).properties = _x + } + + } + + case 8: + localctx = NewAlterCatalogPropertiesContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1671) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1672) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1673) + + var _x = p.Identifier() + + localctx.(*AlterCatalogPropertiesContext).name = _x + } + { + p.SetState(1674) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1675) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1676) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1677) + p.PropertyItemList() + } + { + p.SetState(1678) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewAlterWorkloadPolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1680) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1681) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1682) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1683) + + var _x = p.IdentifierOrText() + + localctx.(*AlterWorkloadPolicyContext).name = _x + } + p.SetState(1685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1684) + + var _x = p.PropertyClause() + + localctx.(*AlterWorkloadPolicyContext).properties = _x + } + + } + + case 10: + localctx = NewAlterSqlBlockRuleContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1687) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1688) + p.Match(DorisParserSQL_BLOCK_RULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1689) + + var _x = p.Identifier() + + localctx.(*AlterSqlBlockRuleContext).name = _x + } + p.SetState(1691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1690) + + var _x = p.PropertyClause() + + localctx.(*AlterSqlBlockRuleContext).properties = _x + } + + } + + case 11: + localctx = NewAlterCatalogCommentContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1693) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1694) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1695) + + var _x = p.Identifier() + + localctx.(*AlterCatalogCommentContext).name = _x + } + { + p.SetState(1696) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1697) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1698) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AlterCatalogCommentContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewAlterDatabaseRenameContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1700) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1701) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1702) + + var _x = p.Identifier() + + localctx.(*AlterDatabaseRenameContext).name = _x + } + { + p.SetState(1703) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1704) + + var _x = p.Identifier() + + localctx.(*AlterDatabaseRenameContext).newName = _x + } + + case 13: + localctx = NewAlterStoragePolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1706) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1707) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1708) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1709) + + var _x = p.IdentifierOrText() + + localctx.(*AlterStoragePolicyContext).name = _x + } + { + p.SetState(1710) + + var _x = p.PropertyClause() + + localctx.(*AlterStoragePolicyContext).properties = _x + } + + case 14: + localctx = NewAlterTableContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1712) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1713) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1714) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterTableContext).tableName = _x + } + { + p.SetState(1715) + p.AlterTableClause() + } + p.SetState(1720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(1716) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1717) + p.AlterTableClause() + } + + p.SetState(1722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 15: + localctx = NewAlterTableExecuteContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1723) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1724) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1725) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterTableExecuteContext).tableName = _x + } + { + p.SetState(1726) + p.Match(DorisParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1727) + + var _x = p.Identifier() + + localctx.(*AlterTableExecuteContext).actionName = _x + } + { + p.SetState(1728) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-7)) & ^0x3f) == 0 && ((int64(1)<<(_la-7))&-4071395127667384755) != 0) || ((int64((_la-71)) & ^0x3f) == 0 && ((int64(1)<<(_la-71))&-6386157293049745705) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485008317210093361) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-2666703833553702093) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439307733023) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605691481683905) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1183912064503058687) != 0) { + { + p.SetState(1729) + p.PropertyItemList() + } + + } + { + p.SetState(1732) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(1733) + p.PartitionSpec() + } + + } + p.SetState(1738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(1736) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1737) + + var _x = p.booleanExpression(0) + + localctx.(*AlterTableExecuteContext).whereExpression = _x + } + + } + + case 16: + localctx = NewAlterTableAddRollupContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1740) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1741) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1742) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterTableAddRollupContext).tableName = _x + } + { + p.SetState(1743) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1744) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1745) + p.AddRollupClause() + } + p.SetState(1750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(1746) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1747) + p.AddRollupClause() + } + + p.SetState(1752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 17: + localctx = NewAlterTableDropRollupContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1753) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1754) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1755) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterTableDropRollupContext).tableName = _x + } + { + p.SetState(1756) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1757) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1758) + p.DropRollupClause() + } + p.SetState(1763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(1759) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1760) + p.DropRollupClause() + } + + p.SetState(1765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 18: + localctx = NewAlterTablePropertiesContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1766) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1767) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1768) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterTablePropertiesContext).name = _x + } + { + p.SetState(1769) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1770) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1771) + p.PropertyItemList() + } + { + p.SetState(1772) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + localctx = NewAlterDatabaseSetQuotaContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1774) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1775) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1776) + + var _x = p.Identifier() + + localctx.(*AlterDatabaseSetQuotaContext).name = _x + } + { + p.SetState(1777) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1778) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDATA || _la == DorisParserREPLICA || _la == DorisParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1779) + p.Match(DorisParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(1780) + + var _x = p.Identifier() + + localctx.(*AlterDatabaseSetQuotaContext).quota = _x + } + + case DorisParserINTEGER_VALUE: + { + p.SetState(1781) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 20: + localctx = NewAlterDatabasePropertiesContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(1784) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1785) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1786) + + var _x = p.Identifier() + + localctx.(*AlterDatabasePropertiesContext).name = _x + } + { + p.SetState(1787) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1788) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1789) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1790) + p.PropertyItemList() + } + { + p.SetState(1791) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + localctx = NewAlterSystemRenameComputeGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(1793) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1794) + p.Match(DorisParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1795) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1796) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1797) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1798) + + var _x = p.Identifier() + + localctx.(*AlterSystemRenameComputeGroupContext).name = _x + } + { + p.SetState(1799) + + var _x = p.Identifier() + + localctx.(*AlterSystemRenameComputeGroupContext).newName = _x + } + + case 22: + localctx = NewAlterResourceContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(1801) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1802) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1803) + + var _x = p.IdentifierOrText() + + localctx.(*AlterResourceContext).name = _x + } + p.SetState(1805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1804) + + var _x = p.PropertyClause() + + localctx.(*AlterResourceContext).properties = _x + } + + } + + case 23: + localctx = NewAlterRepositoryContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(1807) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1808) + p.Match(DorisParserREPOSITORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1809) + + var _x = p.Identifier() + + localctx.(*AlterRepositoryContext).name = _x + } + p.SetState(1811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1810) + + var _x = p.PropertyClause() + + localctx.(*AlterRepositoryContext).properties = _x + } + + } + + case 24: + localctx = NewAlterRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(1813) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1814) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1815) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1816) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1817) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterRoutineLoadContext).name = _x + } + p.SetState(1826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOLUMNS || _la == DorisParserDELETE || ((int64((_la-338)) & ^0x3f) == 0 && ((int64(1)<<(_la-338))&1073742209) != 0) || _la == DorisParserTEMPORARY || _la == DorisParserWHERE { + { + p.SetState(1818) + p.LoadProperty() + } + p.SetState(1823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(1819) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1820) + p.LoadProperty() + } + + p.SetState(1825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(1829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(1828) + + var _x = p.PropertyClause() + + localctx.(*AlterRoutineLoadContext).properties = _x + } + + } + p.SetState(1837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(1831) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1832) + + var _x = p.Identifier() + + localctx.(*AlterRoutineLoadContext).type_ = _x + } + { + p.SetState(1833) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1834) + p.PropertyItemList() + } + { + p.SetState(1835) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 25: + localctx = NewAlterColocateGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(1839) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1840) + p.Match(DorisParserCOLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1841) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1842) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterColocateGroupContext).name = _x + } + { + p.SetState(1843) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1844) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1845) + p.PropertyItemList() + } + { + p.SetState(1846) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + localctx = NewAlterUserContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(1848) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1849) + p.Match(DorisParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1850) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1851) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1854) + p.GrantUserIdentify() + } + { + p.SetState(1855) + p.PasswordOption() + } + p.SetState(1858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(1856) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1857) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedDropStatementContext is an interface to support dynamic dispatch. +type ISupportedDropStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedDropStatementContext differentiates from other interfaces. + IsSupportedDropStatementContext() +} + +type SupportedDropStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedDropStatementContext() *SupportedDropStatementContext { + var p = new(SupportedDropStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedDropStatement + return p +} + +func InitEmptySupportedDropStatementContext(p *SupportedDropStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedDropStatement +} + +func (*SupportedDropStatementContext) IsSupportedDropStatementContext() {} + +func NewSupportedDropStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedDropStatementContext { + var p = new(SupportedDropStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedDropStatement + + return p +} + +func (s *SupportedDropStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedDropStatementContext) CopyAll(ctx *SupportedDropStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedDropStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedDropStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DropUserContext struct { + SupportedDropStatementContext +} + +func NewDropUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropUserContext { + var p = new(DropUserContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropUserContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropUserContext) USER() antlr.TerminalNode { + return s.GetToken(DorisParserUSER, 0) +} + +func (s *DropUserContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *DropUserContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropUserContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropUser(s) + } +} + +func (s *DropUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropUser(s) + } +} + +func (s *DropUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropUser(s) + + default: + return t.VisitChildren(s) + } +} + +type DropDatabaseContext struct { + SupportedDropStatementContext + name IMultipartIdentifierContext +} + +func NewDropDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropDatabaseContext { + var p = new(DropDatabaseContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropDatabaseContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *DropDatabaseContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *DropDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropDatabaseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *DropDatabaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEMA, 0) +} + +func (s *DropDatabaseContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropDatabaseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropDatabaseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropDatabaseContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *DropDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropDatabase(s) + } +} + +func (s *DropDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropDatabase(s) + } +} + +func (s *DropDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +type DropDictionaryContext struct { + SupportedDropStatementContext + name IMultipartIdentifierContext +} + +func NewDropDictionaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropDictionaryContext { + var p = new(DropDictionaryContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropDictionaryContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *DropDictionaryContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *DropDictionaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropDictionaryContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropDictionaryContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARY, 0) +} + +func (s *DropDictionaryContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropDictionaryContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropDictionaryContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropDictionaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropDictionary(s) + } +} + +func (s *DropDictionaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropDictionary(s) + } +} + +func (s *DropDictionaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropDictionary(s) + + default: + return t.VisitChildren(s) + } +} + +type DropWorkloadPolicyContext struct { + SupportedDropStatementContext + name IIdentifierOrTextContext +} + +func NewDropWorkloadPolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropWorkloadPolicyContext { + var p = new(DropWorkloadPolicyContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropWorkloadPolicyContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *DropWorkloadPolicyContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *DropWorkloadPolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropWorkloadPolicyContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropWorkloadPolicyContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *DropWorkloadPolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *DropWorkloadPolicyContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DropWorkloadPolicyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropWorkloadPolicyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropWorkloadPolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropWorkloadPolicy(s) + } +} + +func (s *DropWorkloadPolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropWorkloadPolicy(s) + } +} + +func (s *DropWorkloadPolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropWorkloadPolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type DropRowPolicyContext struct { + SupportedDropStatementContext + policyName IIdentifierContext + tableName IMultipartIdentifierContext + roleName IIdentifierContext +} + +func NewDropRowPolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropRowPolicyContext { + var p = new(DropRowPolicyContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropRowPolicyContext) GetPolicyName() IIdentifierContext { return s.policyName } + +func (s *DropRowPolicyContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *DropRowPolicyContext) GetRoleName() IIdentifierContext { return s.roleName } + +func (s *DropRowPolicyContext) SetPolicyName(v IIdentifierContext) { s.policyName = v } + +func (s *DropRowPolicyContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *DropRowPolicyContext) SetRoleName(v IIdentifierContext) { s.roleName = v } + +func (s *DropRowPolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropRowPolicyContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropRowPolicyContext) ROW() antlr.TerminalNode { + return s.GetToken(DorisParserROW, 0) +} + +func (s *DropRowPolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *DropRowPolicyContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *DropRowPolicyContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *DropRowPolicyContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropRowPolicyContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropRowPolicyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropRowPolicyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropRowPolicyContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *DropRowPolicyContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *DropRowPolicyContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *DropRowPolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropRowPolicy(s) + } +} + +func (s *DropRowPolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropRowPolicy(s) + } +} + +func (s *DropRowPolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropRowPolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type DropFunctionContext struct { + SupportedDropStatementContext +} + +func NewDropFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropFunctionContext { + var p = new(DropFunctionContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropFunctionContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *DropFunctionContext) FunctionIdentifier() IFunctionIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionIdentifierContext) +} + +func (s *DropFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *DropFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *DropFunctionContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *DropFunctionContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropFunctionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropFunctionContext) FunctionArguments() IFunctionArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgumentsContext) +} + +func (s *DropFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropFunction(s) + } +} + +func (s *DropFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropFunction(s) + } +} + +func (s *DropFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type DropWorkloadGroupContext struct { + SupportedDropStatementContext + name IIdentifierOrTextContext + computeGroup IIdentifierOrTextContext +} + +func NewDropWorkloadGroupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropWorkloadGroupContext { + var p = new(DropWorkloadGroupContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropWorkloadGroupContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *DropWorkloadGroupContext) GetComputeGroup() IIdentifierOrTextContext { return s.computeGroup } + +func (s *DropWorkloadGroupContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *DropWorkloadGroupContext) SetComputeGroup(v IIdentifierOrTextContext) { s.computeGroup = v } + +func (s *DropWorkloadGroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropWorkloadGroupContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropWorkloadGroupContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *DropWorkloadGroupContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *DropWorkloadGroupContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *DropWorkloadGroupContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DropWorkloadGroupContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropWorkloadGroupContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropWorkloadGroupContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *DropWorkloadGroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropWorkloadGroup(s) + } +} + +func (s *DropWorkloadGroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropWorkloadGroup(s) + } +} + +func (s *DropWorkloadGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropWorkloadGroup(s) + + default: + return t.VisitChildren(s) + } +} + +type DropSqlBlockRuleContext struct { + SupportedDropStatementContext +} + +func NewDropSqlBlockRuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropSqlBlockRuleContext { + var p = new(DropSqlBlockRuleContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropSqlBlockRuleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropSqlBlockRuleContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropSqlBlockRuleContext) SQL_BLOCK_RULE() antlr.TerminalNode { + return s.GetToken(DorisParserSQL_BLOCK_RULE, 0) +} + +func (s *DropSqlBlockRuleContext) IdentifierSeq() IIdentifierSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierSeqContext) +} + +func (s *DropSqlBlockRuleContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropSqlBlockRuleContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropSqlBlockRuleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropSqlBlockRule(s) + } +} + +func (s *DropSqlBlockRuleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropSqlBlockRule(s) + } +} + +func (s *DropSqlBlockRuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropSqlBlockRule(s) + + default: + return t.VisitChildren(s) + } +} + +type DropViewContext struct { + SupportedDropStatementContext + name IMultipartIdentifierContext +} + +func NewDropViewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropViewContext { + var p = new(DropViewContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropViewContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *DropViewContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *DropViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropViewContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *DropViewContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropViewContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropViewContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropView(s) + } +} + +func (s *DropViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropView(s) + } +} + +func (s *DropViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropView(s) + + default: + return t.VisitChildren(s) + } +} + +type DropIndexCharFilterContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropIndexCharFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropIndexCharFilterContext { + var p = new(DropIndexCharFilterContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropIndexCharFilterContext) GetName() IIdentifierContext { return s.name } + +func (s *DropIndexCharFilterContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropIndexCharFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexCharFilterContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropIndexCharFilterContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *DropIndexCharFilterContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropIndexCharFilterContext) CHAR_FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR_FILTER, 0) +} + +func (s *DropIndexCharFilterContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropIndexCharFilterContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropIndexCharFilterContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropIndexCharFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropIndexCharFilter(s) + } +} + +func (s *DropIndexCharFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropIndexCharFilter(s) + } +} + +func (s *DropIndexCharFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropIndexCharFilter(s) + + default: + return t.VisitChildren(s) + } +} + +type DropIndexContext struct { + SupportedDropStatementContext + name IIdentifierContext + tableName IMultipartIdentifierContext +} + +func NewDropIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropIndexContext { + var p = new(DropIndexContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropIndexContext) GetName() IIdentifierContext { return s.name } + +func (s *DropIndexContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *DropIndexContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropIndexContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *DropIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropIndexContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *DropIndexContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropIndexContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropIndexContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropIndexContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropIndex(s) + } +} + +func (s *DropIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropIndex(s) + } +} + +func (s *DropIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropIndex(s) + + default: + return t.VisitChildren(s) + } +} + +type DropEncryptkeyContext struct { + SupportedDropStatementContext + name IMultipartIdentifierContext +} + +func NewDropEncryptkeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropEncryptkeyContext { + var p = new(DropEncryptkeyContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropEncryptkeyContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *DropEncryptkeyContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *DropEncryptkeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropEncryptkeyContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropEncryptkeyContext) ENCRYPTKEY() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTKEY, 0) +} + +func (s *DropEncryptkeyContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropEncryptkeyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropEncryptkeyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropEncryptkeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropEncryptkey(s) + } +} + +func (s *DropEncryptkeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropEncryptkey(s) + } +} + +func (s *DropEncryptkeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropEncryptkey(s) + + default: + return t.VisitChildren(s) + } +} + +type DropRepositoryContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropRepositoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropRepositoryContext { + var p = new(DropRepositoryContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropRepositoryContext) GetName() IIdentifierContext { return s.name } + +func (s *DropRepositoryContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropRepositoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropRepositoryContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropRepositoryContext) REPOSITORY() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORY, 0) +} + +func (s *DropRepositoryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropRepositoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropRepository(s) + } +} + +func (s *DropRepositoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropRepository(s) + } +} + +func (s *DropRepositoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropRepository(s) + + default: + return t.VisitChildren(s) + } +} + +type DropRoleContext struct { + SupportedDropStatementContext + name IIdentifierOrTextContext +} + +func NewDropRoleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropRoleContext { + var p = new(DropRoleContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropRoleContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *DropRoleContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *DropRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropRoleContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropRoleContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *DropRoleContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DropRoleContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropRoleContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropRole(s) + } +} + +func (s *DropRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropRole(s) + } +} + +func (s *DropRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropRole(s) + + default: + return t.VisitChildren(s) + } +} + +type DropIndexAnalyzerContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropIndexAnalyzerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropIndexAnalyzerContext { + var p = new(DropIndexAnalyzerContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropIndexAnalyzerContext) GetName() IIdentifierContext { return s.name } + +func (s *DropIndexAnalyzerContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropIndexAnalyzerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexAnalyzerContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropIndexAnalyzerContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *DropIndexAnalyzerContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropIndexAnalyzerContext) ANALYZER() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZER, 0) +} + +func (s *DropIndexAnalyzerContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropIndexAnalyzerContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropIndexAnalyzerContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropIndexAnalyzerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropIndexAnalyzer(s) + } +} + +func (s *DropIndexAnalyzerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropIndexAnalyzer(s) + } +} + +func (s *DropIndexAnalyzerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropIndexAnalyzer(s) + + default: + return t.VisitChildren(s) + } +} + +type DropStageContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropStageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropStageContext { + var p = new(DropStageContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropStageContext) GetName() IIdentifierContext { return s.name } + +func (s *DropStageContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropStageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropStageContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropStageContext) STAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGE, 0) +} + +func (s *DropStageContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropStageContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropStageContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropStageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropStage(s) + } +} + +func (s *DropStageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropStage(s) + } +} + +func (s *DropStageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropStage(s) + + default: + return t.VisitChildren(s) + } +} + +type DropIndexTokenizerContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropIndexTokenizerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropIndexTokenizerContext { + var p = new(DropIndexTokenizerContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropIndexTokenizerContext) GetName() IIdentifierContext { return s.name } + +func (s *DropIndexTokenizerContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropIndexTokenizerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexTokenizerContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropIndexTokenizerContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *DropIndexTokenizerContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropIndexTokenizerContext) TOKENIZER() antlr.TerminalNode { + return s.GetToken(DorisParserTOKENIZER, 0) +} + +func (s *DropIndexTokenizerContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropIndexTokenizerContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropIndexTokenizerContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropIndexTokenizerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropIndexTokenizer(s) + } +} + +func (s *DropIndexTokenizerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropIndexTokenizer(s) + } +} + +func (s *DropIndexTokenizerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropIndexTokenizer(s) + + default: + return t.VisitChildren(s) + } +} + +type DropResourceContext struct { + SupportedDropStatementContext + name IIdentifierOrTextContext +} + +func NewDropResourceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropResourceContext { + var p = new(DropResourceContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropResourceContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *DropResourceContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *DropResourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropResourceContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropResourceContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *DropResourceContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DropResourceContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropResourceContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropResourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropResource(s) + } +} + +func (s *DropResourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropResource(s) + } +} + +func (s *DropResourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropResource(s) + + default: + return t.VisitChildren(s) + } +} + +type DropFileContext struct { + SupportedDropStatementContext + name antlr.Token + database IIdentifierContext + properties IPropertyClauseContext +} + +func NewDropFileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropFileContext { + var p = new(DropFileContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropFileContext) GetName() antlr.Token { return s.name } + +func (s *DropFileContext) SetName(v antlr.Token) { s.name = v } + +func (s *DropFileContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *DropFileContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *DropFileContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *DropFileContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *DropFileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropFileContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropFileContext) FILE() antlr.TerminalNode { + return s.GetToken(DorisParserFILE, 0) +} + +func (s *DropFileContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *DropFileContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *DropFileContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *DropFileContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *DropFileContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropFileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropFile(s) + } +} + +func (s *DropFileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropFile(s) + } +} + +func (s *DropFileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropFile(s) + + default: + return t.VisitChildren(s) + } +} + +type DropCatalogContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropCatalogContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropCatalogContext { + var p = new(DropCatalogContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropCatalogContext) GetName() IIdentifierContext { return s.name } + +func (s *DropCatalogContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropCatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropCatalogContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropCatalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *DropCatalogContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropCatalogContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropCatalogContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropCatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropCatalog(s) + } +} + +func (s *DropCatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropCatalog(s) + } +} + +func (s *DropCatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropCatalog(s) + + default: + return t.VisitChildren(s) + } +} + +type DropCatalogRecycleBinContext struct { + SupportedDropStatementContext + idType antlr.Token + id antlr.Token +} + +func NewDropCatalogRecycleBinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropCatalogRecycleBinContext { + var p = new(DropCatalogRecycleBinContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropCatalogRecycleBinContext) GetIdType() antlr.Token { return s.idType } + +func (s *DropCatalogRecycleBinContext) GetId() antlr.Token { return s.id } + +func (s *DropCatalogRecycleBinContext) SetIdType(v antlr.Token) { s.idType = v } + +func (s *DropCatalogRecycleBinContext) SetId(v antlr.Token) { s.id = v } + +func (s *DropCatalogRecycleBinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropCatalogRecycleBinContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropCatalogRecycleBinContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *DropCatalogRecycleBinContext) RECYCLE() antlr.TerminalNode { + return s.GetToken(DorisParserRECYCLE, 0) +} + +func (s *DropCatalogRecycleBinContext) BIN() antlr.TerminalNode { + return s.GetToken(DorisParserBIN, 0) +} + +func (s *DropCatalogRecycleBinContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *DropCatalogRecycleBinContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *DropCatalogRecycleBinContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *DropCatalogRecycleBinContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *DropCatalogRecycleBinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropCatalogRecycleBin(s) + } +} + +func (s *DropCatalogRecycleBinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropCatalogRecycleBin(s) + } +} + +func (s *DropCatalogRecycleBinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropCatalogRecycleBin(s) + + default: + return t.VisitChildren(s) + } +} + +type DropIndexTokenFilterContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropIndexTokenFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropIndexTokenFilterContext { + var p = new(DropIndexTokenFilterContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropIndexTokenFilterContext) GetName() IIdentifierContext { return s.name } + +func (s *DropIndexTokenFilterContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropIndexTokenFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexTokenFilterContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropIndexTokenFilterContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *DropIndexTokenFilterContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropIndexTokenFilterContext) TOKEN_FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserTOKEN_FILTER, 0) +} + +func (s *DropIndexTokenFilterContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropIndexTokenFilterContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropIndexTokenFilterContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropIndexTokenFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropIndexTokenFilter(s) + } +} + +func (s *DropIndexTokenFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropIndexTokenFilter(s) + } +} + +func (s *DropIndexTokenFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropIndexTokenFilter(s) + + default: + return t.VisitChildren(s) + } +} + +type DropTableContext struct { + SupportedDropStatementContext + name IMultipartIdentifierContext +} + +func NewDropTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropTableContext { + var p = new(DropTableContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *DropTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *DropTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTableContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *DropTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropTableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *DropTableContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropTableContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropTableContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *DropTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropTable(s) + } +} + +func (s *DropTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropTable(s) + } +} + +func (s *DropTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropTable(s) + + default: + return t.VisitChildren(s) + } +} + +type DropStoragePolicyContext struct { + SupportedDropStatementContext + name IIdentifierContext +} + +func NewDropStoragePolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropStoragePolicyContext { + var p = new(DropStoragePolicyContext) + + InitEmptySupportedDropStatementContext(&p.SupportedDropStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDropStatementContext)) + + return p +} + +func (s *DropStoragePolicyContext) GetName() IIdentifierContext { return s.name } + +func (s *DropStoragePolicyContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropStoragePolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropStoragePolicyContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropStoragePolicyContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *DropStoragePolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *DropStoragePolicyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropStoragePolicyContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropStoragePolicyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropStoragePolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropStoragePolicy(s) + } +} + +func (s *DropStoragePolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropStoragePolicy(s) + } +} + +func (s *DropStoragePolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropStoragePolicy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedDropStatement() (localctx ISupportedDropStatementContext) { + localctx = NewSupportedDropStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, DorisParserRULE_supportedDropStatement) + var _la int + + p.SetState(2075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 246, p.GetParserRuleContext()) { + case 1: + localctx = NewDropCatalogRecycleBinContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1862) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1863) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1864) + p.Match(DorisParserRECYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1865) + p.Match(DorisParserBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1866) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1867) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropCatalogRecycleBinContext).idType = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1868) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1869) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*DropCatalogRecycleBinContext).id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewDropEncryptkeyContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1870) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1871) + p.Match(DorisParserENCRYPTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1872) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1873) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1876) + + var _x = p.MultipartIdentifier() + + localctx.(*DropEncryptkeyContext).name = _x + } + + case 3: + localctx = NewDropRoleContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1877) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1878) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1879) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1880) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1883) + + var _x = p.IdentifierOrText() + + localctx.(*DropRoleContext).name = _x + } + + case 4: + localctx = NewDropSqlBlockRuleContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1884) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1885) + p.Match(DorisParserSQL_BLOCK_RULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1886) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1887) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1890) + p.IdentifierSeq() + } + + case 5: + localctx = NewDropUserContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1891) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1892) + p.Match(DorisParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1893) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1894) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1897) + p.UserIdentify() + } + + case 6: + localctx = NewDropStoragePolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1898) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1899) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1900) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1901) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1902) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1905) + + var _x = p.Identifier() + + localctx.(*DropStoragePolicyContext).name = _x + } + + case 7: + localctx = NewDropWorkloadGroupContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1906) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1907) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1908) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1909) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1910) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1913) + + var _x = p.IdentifierOrText() + + localctx.(*DropWorkloadGroupContext).name = _x + } + p.SetState(1916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(1914) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1915) + + var _x = p.IdentifierOrText() + + localctx.(*DropWorkloadGroupContext).computeGroup = _x + } + + } + + case 8: + localctx = NewDropCatalogContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1918) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1919) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1920) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1921) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1924) + + var _x = p.Identifier() + + localctx.(*DropCatalogContext).name = _x + } + + case 9: + localctx = NewDropFileContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1925) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1926) + p.Match(DorisParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1927) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropFileContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(1928) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1929) + + var _x = p.Identifier() + + localctx.(*DropFileContext).database = _x + } + + } + { + p.SetState(1932) + + var _x = p.PropertyClause() + + localctx.(*DropFileContext).properties = _x + } + + case 10: + localctx = NewDropWorkloadPolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1933) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1934) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1935) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1936) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1937) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1940) + + var _x = p.IdentifierOrText() + + localctx.(*DropWorkloadPolicyContext).name = _x + } + + case 11: + localctx = NewDropRepositoryContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1941) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1942) + p.Match(DorisParserREPOSITORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1943) + + var _x = p.Identifier() + + localctx.(*DropRepositoryContext).name = _x + } + + case 12: + localctx = NewDropTableContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1944) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(1945) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1948) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1949) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1950) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1953) + + var _x = p.MultipartIdentifier() + + localctx.(*DropTableContext).name = _x + } + p.SetState(1955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(1954) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 13: + localctx = NewDropDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1957) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1958) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDATABASE || _la == DorisParserSCHEMA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1959) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1960) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1963) + + var _x = p.MultipartIdentifier() + + localctx.(*DropDatabaseContext).name = _x + } + p.SetState(1965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(1964) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 14: + localctx = NewDropFunctionContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1967) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(1968) + p.StatementScope() + } + + } + { + p.SetState(1971) + p.Match(DorisParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1974) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 232, p.GetParserRuleContext()) == 1 { + { + p.SetState(1972) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1973) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1976) + p.FunctionIdentifier() + } + { + p.SetState(1977) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&9152335059222592) != 0) || ((int64((_la-72)) & ^0x3f) == 0 && ((int64(1)<<(_la-72))&254418194574344193) != 0) || _la == DorisParserDOUBLE || _la == DorisParserFLOAT || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&9208814108673) != 0) || _la == DorisParserMAP || _la == DorisParserQUANTILE_STATE || ((int64((_la-446)) & ^0x3f) == 0 && ((int64(1)<<(_la-446))&5634997485569) != 0) || ((int64((_la-520)) & ^0x3f) == 0 && ((int64(1)<<(_la-520))&19) != 0) { + { + p.SetState(1978) + p.FunctionArguments() + } + + } + { + p.SetState(1981) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewDropIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1983) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1984) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1985) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1986) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1989) + + var _x = p.Identifier() + + localctx.(*DropIndexContext).name = _x + } + { + p.SetState(1990) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1991) + + var _x = p.MultipartIdentifier() + + localctx.(*DropIndexContext).tableName = _x + } + + case 16: + localctx = NewDropResourceContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1993) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1994) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(1995) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1996) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1999) + + var _x = p.IdentifierOrText() + + localctx.(*DropResourceContext).name = _x + } + + case 17: + localctx = NewDropRowPolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2000) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2001) + p.Match(DorisParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2002) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2003) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2004) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2007) + + var _x = p.Identifier() + + localctx.(*DropRowPolicyContext).policyName = _x + } + { + p.SetState(2008) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2009) + + var _x = p.MultipartIdentifier() + + localctx.(*DropRowPolicyContext).tableName = _x + } + p.SetState(2016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(2010) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(2011) + p.UserIdentify() + } + + case DorisParserROLE: + { + p.SetState(2012) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2013) + + var _x = p.Identifier() + + localctx.(*DropRowPolicyContext).roleName = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + case 18: + localctx = NewDropDictionaryContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2018) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2019) + p.Match(DorisParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2020) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2021) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2024) + + var _x = p.MultipartIdentifier() + + localctx.(*DropDictionaryContext).name = _x + } + + case 19: + localctx = NewDropStageContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2025) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2026) + p.Match(DorisParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2027) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2028) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2031) + + var _x = p.Identifier() + + localctx.(*DropStageContext).name = _x + } + + case 20: + localctx = NewDropViewContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2032) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2033) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2034) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2035) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2038) + + var _x = p.MultipartIdentifier() + + localctx.(*DropViewContext).name = _x + } + + case 21: + localctx = NewDropIndexAnalyzerContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2039) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2040) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2041) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2042) + p.Match(DorisParserANALYZER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2043) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2044) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2047) + + var _x = p.Identifier() + + localctx.(*DropIndexAnalyzerContext).name = _x + } + + case 22: + localctx = NewDropIndexTokenizerContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2048) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2049) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2050) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2051) + p.Match(DorisParserTOKENIZER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2052) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2053) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2056) + + var _x = p.Identifier() + + localctx.(*DropIndexTokenizerContext).name = _x + } + + case 23: + localctx = NewDropIndexTokenFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2057) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2058) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2059) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2060) + p.Match(DorisParserTOKEN_FILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2061) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2062) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2065) + + var _x = p.Identifier() + + localctx.(*DropIndexTokenFilterContext).name = _x + } + + case 24: + localctx = NewDropIndexCharFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2066) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2067) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2068) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2069) + p.Match(DorisParserCHAR_FILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(2070) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2071) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2074) + + var _x = p.Identifier() + + localctx.(*DropIndexCharFilterContext).name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedShowStatementContext is an interface to support dynamic dispatch. +type ISupportedShowStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedShowStatementContext differentiates from other interfaces. + IsSupportedShowStatementContext() +} + +type SupportedShowStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedShowStatementContext() *SupportedShowStatementContext { + var p = new(SupportedShowStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedShowStatement + return p +} + +func InitEmptySupportedShowStatementContext(p *SupportedShowStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedShowStatement +} + +func (*SupportedShowStatementContext) IsSupportedShowStatementContext() {} + +func NewSupportedShowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedShowStatementContext { + var p = new(SupportedShowStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedShowStatement + + return p +} + +func (s *SupportedShowStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedShowStatementContext) CopyAll(ctx *SupportedShowStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedShowStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedShowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ShowRepositoriesContext struct { + SupportedShowStatementContext +} + +func NewShowRepositoriesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRepositoriesContext { + var p = new(ShowRepositoriesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowRepositoriesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRepositoriesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowRepositoriesContext) REPOSITORIES() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORIES, 0) +} + +func (s *ShowRepositoriesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowRepositories(s) + } +} + +func (s *ShowRepositoriesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowRepositories(s) + } +} + +func (s *ShowRepositoriesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowRepositories(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDataContext struct { + SupportedShowStatementContext + tableName IMultipartIdentifierContext +} + +func NewShowDataContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDataContext { + var p = new(ShowDataContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDataContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowDataContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowDataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDataContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDataContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *ShowDataContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ShowDataContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowDataContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowDataContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ShowDataContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowDataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowData(s) + } +} + +func (s *ShowDataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowData(s) + } +} + +func (s *ShowDataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowData(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowIndexContext struct { + SupportedShowStatementContext + tableName IMultipartIdentifierContext + database IMultipartIdentifierContext +} + +func NewShowIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexContext { + var p = new(ShowIndexContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowIndexContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowIndexContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowIndexContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowIndexContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowIndexContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *ShowIndexContext) KEYS() antlr.TerminalNode { + return s.GetToken(DorisParserKEYS, 0) +} + +func (s *ShowIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowIndexContext) INDEXES() antlr.TerminalNode { + return s.GetToken(DorisParserINDEXES, 0) +} + +func (s *ShowIndexContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(DorisParserFROM) +} + +func (s *ShowIndexContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(DorisParserFROM, i) +} + +func (s *ShowIndexContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(DorisParserIN) +} + +func (s *ShowIndexContext) IN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserIN, i) +} + +func (s *ShowIndexContext) AllMultipartIdentifier() []IMultipartIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + len++ + } + } + + tst := make([]IMultipartIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultipartIdentifierContext); ok { + tst[i] = t.(IMultipartIdentifierContext) + i++ + } + } + + return tst +} + +func (s *ShowIndexContext) MultipartIdentifier(i int) IMultipartIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowIndex(s) + } +} + +func (s *ShowIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowIndex(s) + } +} + +func (s *ShowIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowIndex(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDynamicPartitionContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowDynamicPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDynamicPartitionContext { + var p = new(ShowDynamicPartitionContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDynamicPartitionContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowDynamicPartitionContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowDynamicPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDynamicPartitionContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDynamicPartitionContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(DorisParserDYNAMIC, 0) +} + +func (s *ShowDynamicPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *ShowDynamicPartitionContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *ShowDynamicPartitionContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowDynamicPartitionContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowDynamicPartitionContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowDynamicPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDynamicPartition(s) + } +} + +func (s *ShowDynamicPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDynamicPartition(s) + } +} + +func (s *ShowDynamicPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDynamicPartition(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTableStatusContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowTableStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTableStatusContext { + var p = new(ShowTableStatusContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTableStatusContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowTableStatusContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowTableStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTableStatusContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTableStatusContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ShowTableStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *ShowTableStatusContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowTableStatusContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTableStatusContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowTableStatusContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTableStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTableStatus(s) + } +} + +func (s *ShowTableStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTableStatus(s) + } +} + +func (s *ShowTableStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTableStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowBackupContext struct { + SupportedShowStatementContext + database IIdentifierContext +} + +func NewShowBackupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowBackupContext { + var p = new(ShowBackupContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowBackupContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowBackupContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowBackupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowBackupContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowBackupContext) BACKUP() antlr.TerminalNode { + return s.GetToken(DorisParserBACKUP, 0) +} + +func (s *ShowBackupContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowBackupContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowBackupContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowBackupContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowBackupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowBackup(s) + } +} + +func (s *ShowBackupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowBackup(s) + } +} + +func (s *ShowBackupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowBackup(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateFunctionContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowCreateFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateFunctionContext { + var p = new(ShowCreateFunctionContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateFunctionContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowCreateFunctionContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowCreateFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateFunctionContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateFunctionContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *ShowCreateFunctionContext) FunctionIdentifier() IFunctionIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionIdentifierContext) +} + +func (s *ShowCreateFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ShowCreateFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ShowCreateFunctionContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *ShowCreateFunctionContext) FunctionArguments() IFunctionArgumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgumentsContext) +} + +func (s *ShowCreateFunctionContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowCreateFunctionContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowCreateFunctionContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateFunction(s) + } +} + +func (s *ShowCreateFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateFunction(s) + } +} + +func (s *ShowCreateFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowGrantsForUserContext struct { + SupportedShowStatementContext +} + +func NewShowGrantsForUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGrantsForUserContext { + var p = new(ShowGrantsForUserContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowGrantsForUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowGrantsForUserContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowGrantsForUserContext) GRANTS() antlr.TerminalNode { + return s.GetToken(DorisParserGRANTS, 0) +} + +func (s *ShowGrantsForUserContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowGrantsForUserContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *ShowGrantsForUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowGrantsForUser(s) + } +} + +func (s *ShowGrantsForUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowGrantsForUser(s) + } +} + +func (s *ShowGrantsForUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowGrantsForUser(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowViewContext struct { + SupportedShowStatementContext + tableName IMultipartIdentifierContext + database IIdentifierContext +} + +func NewShowViewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowViewContext { + var p = new(ShowViewContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowViewContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowViewContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowViewContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowViewContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowViewContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *ShowViewContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(DorisParserFROM) +} + +func (s *ShowViewContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(DorisParserFROM, i) +} + +func (s *ShowViewContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(DorisParserIN) +} + +func (s *ShowViewContext) IN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserIN, i) +} + +func (s *ShowViewContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowViewContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowView(s) + } +} + +func (s *ShowViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowView(s) + } +} + +func (s *ShowViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowView(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTablesContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowTablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTablesContext { + var p = new(ShowTablesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTablesContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowTablesContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *ShowTablesContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowTablesContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowTablesContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTablesContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowTablesContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTables(s) + } +} + +func (s *ShowTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTables(s) + } +} + +func (s *ShowTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTables(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowExportContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowExportContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowExportContext { + var p = new(ShowExportContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowExportContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowExportContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowExportContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowExportContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowExportContext) EXPORT() antlr.TerminalNode { + return s.GetToken(DorisParserEXPORT, 0) +} + +func (s *ShowExportContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowExportContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowExportContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowExportContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowExportContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowExportContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowExportContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowExport(s) + } +} + +func (s *ShowExportContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowExport(s) + } +} + +func (s *ShowExportContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowExport(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowAuthorsContext struct { + SupportedShowStatementContext +} + +func NewShowAuthorsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowAuthorsContext { + var p = new(ShowAuthorsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowAuthorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowAuthorsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowAuthorsContext) AUTHORS() antlr.TerminalNode { + return s.GetToken(DorisParserAUTHORS, 0) +} + +func (s *ShowAuthorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowAuthors(s) + } +} + +func (s *ShowAuthorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowAuthors(s) + } +} + +func (s *ShowAuthorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowAuthors(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowStorageEnginesContext struct { + SupportedShowStatementContext +} + +func NewShowStorageEnginesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowStorageEnginesContext { + var p = new(ShowStorageEnginesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowStorageEnginesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowStorageEnginesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowStorageEnginesContext) ENGINES() antlr.TerminalNode { + return s.GetToken(DorisParserENGINES, 0) +} + +func (s *ShowStorageEnginesContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *ShowStorageEnginesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowStorageEngines(s) + } +} + +func (s *ShowStorageEnginesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowStorageEngines(s) + } +} + +func (s *ShowStorageEnginesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowStorageEngines(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowWarningErrorsContext struct { + SupportedShowStatementContext +} + +func NewShowWarningErrorsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowWarningErrorsContext { + var p = new(ShowWarningErrorsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowWarningErrorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowWarningErrorsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowWarningErrorsContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(DorisParserWARNINGS, 0) +} + +func (s *ShowWarningErrorsContext) ERRORS() antlr.TerminalNode { + return s.GetToken(DorisParserERRORS, 0) +} + +func (s *ShowWarningErrorsContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowWarningErrorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowWarningErrors(s) + } +} + +func (s *ShowWarningErrorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowWarningErrors(s) + } +} + +func (s *ShowWarningErrorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowWarningErrors(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCatalogsContext struct { + SupportedShowStatementContext +} + +func NewShowCatalogsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCatalogsContext { + var p = new(ShowCatalogsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCatalogsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCatalogsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCatalogsContext) CATALOGS() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOGS, 0) +} + +func (s *ShowCatalogsContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowCatalogsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCatalogs(s) + } +} + +func (s *ShowCatalogsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCatalogs(s) + } +} + +func (s *ShowCatalogsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCatalogs(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowRolesContext struct { + SupportedShowStatementContext +} + +func NewShowRolesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRolesContext { + var p = new(ShowRolesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowRolesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRolesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowRolesContext) ROLES() antlr.TerminalNode { + return s.GetToken(DorisParserROLES, 0) +} + +func (s *ShowRolesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowRoles(s) + } +} + +func (s *ShowRolesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowRoles(s) + } +} + +func (s *ShowRolesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowRoles(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowRowPolicyContext struct { + SupportedShowStatementContext + role IIdentifierContext +} + +func NewShowRowPolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRowPolicyContext { + var p = new(ShowRowPolicyContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowRowPolicyContext) GetRole() IIdentifierContext { return s.role } + +func (s *ShowRowPolicyContext) SetRole(v IIdentifierContext) { s.role = v } + +func (s *ShowRowPolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRowPolicyContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowRowPolicyContext) ROW() antlr.TerminalNode { + return s.GetToken(DorisParserROW, 0) +} + +func (s *ShowRowPolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *ShowRowPolicyContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowRowPolicyContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *ShowRowPolicyContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *ShowRowPolicyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowRowPolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowRowPolicy(s) + } +} + +func (s *ShowRowPolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowRowPolicy(s) + } +} + +func (s *ShowRowPolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowRowPolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTabletsBelongContext struct { + SupportedShowStatementContext + _INTEGER_VALUE antlr.Token + tabletIds []antlr.Token +} + +func NewShowTabletsBelongContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTabletsBelongContext { + var p = new(ShowTabletsBelongContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTabletsBelongContext) Get_INTEGER_VALUE() antlr.Token { return s._INTEGER_VALUE } + +func (s *ShowTabletsBelongContext) Set_INTEGER_VALUE(v antlr.Token) { s._INTEGER_VALUE = v } + +func (s *ShowTabletsBelongContext) GetTabletIds() []antlr.Token { return s.tabletIds } + +func (s *ShowTabletsBelongContext) SetTabletIds(v []antlr.Token) { s.tabletIds = v } + +func (s *ShowTabletsBelongContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTabletsBelongContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTabletsBelongContext) TABLETS() antlr.TerminalNode { + return s.GetToken(DorisParserTABLETS, 0) +} + +func (s *ShowTabletsBelongContext) BELONG() antlr.TerminalNode { + return s.GetToken(DorisParserBELONG, 0) +} + +func (s *ShowTabletsBelongContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *ShowTabletsBelongContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *ShowTabletsBelongContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ShowTabletsBelongContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ShowTabletsBelongContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTabletsBelong(s) + } +} + +func (s *ShowTabletsBelongContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTabletsBelong(s) + } +} + +func (s *ShowTabletsBelongContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTabletsBelong(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTriggersContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowTriggersContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTriggersContext { + var p = new(ShowTriggersContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTriggersContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowTriggersContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowTriggersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTriggersContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTriggersContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(DorisParserTRIGGERS, 0) +} + +func (s *ShowTriggersContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowTriggersContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowTriggersContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTriggersContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowTriggersContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTriggersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTriggers(s) + } +} + +func (s *ShowTriggersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTriggers(s) + } +} + +func (s *ShowTriggersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTriggers(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateTableContext struct { + SupportedShowStatementContext + name IMultipartIdentifierContext +} + +func NewShowCreateTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateTableContext { + var p = new(ShowCreateTableContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *ShowCreateTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *ShowCreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateTableContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateTableContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ShowCreateTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateTableContext) BRIEF() antlr.TerminalNode { + return s.GetToken(DorisParserBRIEF, 0) +} + +func (s *ShowCreateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateTable(s) + } +} + +func (s *ShowCreateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateTable(s) + } +} + +func (s *ShowCreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateTable(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCatalogContext struct { + SupportedShowStatementContext + name IIdentifierContext +} + +func NewShowCatalogContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCatalogContext { + var p = new(ShowCatalogContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCatalogContext) GetName() IIdentifierContext { return s.name } + +func (s *ShowCatalogContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ShowCatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCatalogContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCatalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *ShowCatalogContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowCatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCatalog(s) + } +} + +func (s *ShowCatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCatalog(s) + } +} + +func (s *ShowCatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCatalog(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowColumnsContext struct { + SupportedShowStatementContext + tableName IMultipartIdentifierContext + database IMultipartIdentifierContext +} + +func NewShowColumnsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowColumnsContext { + var p = new(ShowColumnsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowColumnsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowColumnsContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowColumnsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowColumnsContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowColumnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowColumnsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowColumnsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *ShowColumnsContext) FIELDS() antlr.TerminalNode { + return s.GetToken(DorisParserFIELDS, 0) +} + +func (s *ShowColumnsContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(DorisParserFROM) +} + +func (s *ShowColumnsContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(DorisParserFROM, i) +} + +func (s *ShowColumnsContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(DorisParserIN) +} + +func (s *ShowColumnsContext) IN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserIN, i) +} + +func (s *ShowColumnsContext) AllMultipartIdentifier() []IMultipartIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + len++ + } + } + + tst := make([]IMultipartIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultipartIdentifierContext); ok { + tst[i] = t.(IMultipartIdentifierContext) + i++ + } + } + + return tst +} + +func (s *ShowColumnsContext) MultipartIdentifier(i int) IMultipartIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowColumnsContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowColumnsContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowColumnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowColumns(s) + } +} + +func (s *ShowColumnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowColumns(s) + } +} + +func (s *ShowColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowColumns(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowBuildIndexContext struct { + SupportedShowStatementContext + database IIdentifierContext +} + +func NewShowBuildIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowBuildIndexContext { + var p = new(ShowBuildIndexContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowBuildIndexContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowBuildIndexContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowBuildIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowBuildIndexContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowBuildIndexContext) BUILD() antlr.TerminalNode { + return s.GetToken(DorisParserBUILD, 0) +} + +func (s *ShowBuildIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowBuildIndexContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowBuildIndexContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowBuildIndexContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowBuildIndexContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowBuildIndexContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowBuildIndexContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowBuildIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowBuildIndex(s) + } +} + +func (s *ShowBuildIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowBuildIndex(s) + } +} + +func (s *ShowBuildIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowBuildIndex(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowVariablesContext struct { + SupportedShowStatementContext +} + +func NewShowVariablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowVariablesContext { + var p = new(ShowVariablesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowVariablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowVariablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowVariablesContext) VARIABLES() antlr.TerminalNode { + return s.GetToken(DorisParserVARIABLES, 0) +} + +func (s *ShowVariablesContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *ShowVariablesContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowVariablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowVariables(s) + } +} + +func (s *ShowVariablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowVariables(s) + } +} + +func (s *ShowVariablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowVariables(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowEventsContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowEventsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowEventsContext { + var p = new(ShowEventsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowEventsContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowEventsContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowEventsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowEventsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowEventsContext) EVENTS() antlr.TerminalNode { + return s.GetToken(DorisParserEVENTS, 0) +} + +func (s *ShowEventsContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowEventsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowEventsContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowEventsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowEventsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowEvents(s) + } +} + +func (s *ShowEventsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowEvents(s) + } +} + +func (s *ShowEventsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowEvents(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowPluginsContext struct { + SupportedShowStatementContext +} + +func NewShowPluginsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowPluginsContext { + var p = new(ShowPluginsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowPluginsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowPluginsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowPluginsContext) PLUGINS() antlr.TerminalNode { + return s.GetToken(DorisParserPLUGINS, 0) +} + +func (s *ShowPluginsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowPlugins(s) + } +} + +func (s *ShowPluginsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowPlugins(s) + } +} + +func (s *ShowPluginsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowPlugins(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowAllPropertiesContext struct { + SupportedShowStatementContext +} + +func NewShowAllPropertiesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowAllPropertiesContext { + var p = new(ShowAllPropertiesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowAllPropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowAllPropertiesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowAllPropertiesContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ShowAllPropertiesContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *ShowAllPropertiesContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowAllPropertiesContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowAllPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowAllProperties(s) + } +} + +func (s *ShowAllPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowAllProperties(s) + } +} + +func (s *ShowAllPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowAllProperties(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDataSkewContext struct { + SupportedShowStatementContext +} + +func NewShowDataSkewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDataSkewContext { + var p = new(ShowDataSkewContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDataSkewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDataSkewContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDataSkewContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *ShowDataSkewContext) SKEW() antlr.TerminalNode { + return s.GetToken(DorisParserSKEW, 0) +} + +func (s *ShowDataSkewContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowDataSkewContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *ShowDataSkewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDataSkew(s) + } +} + +func (s *ShowDataSkewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDataSkew(s) + } +} + +func (s *ShowDataSkewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDataSkew(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowConvertLscContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowConvertLscContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowConvertLscContext { + var p = new(ShowConvertLscContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowConvertLscContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowConvertLscContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowConvertLscContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowConvertLscContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowConvertLscContext) CONVERT_LSC() antlr.TerminalNode { + return s.GetToken(DorisParserCONVERT_LSC, 0) +} + +func (s *ShowConvertLscContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowConvertLscContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowConvertLscContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowConvertLscContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowConvertLsc(s) + } +} + +func (s *ShowConvertLscContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowConvertLsc(s) + } +} + +func (s *ShowConvertLscContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowConvertLsc(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowSqlBlockRuleContext struct { + SupportedShowStatementContext + ruleName IIdentifierContext +} + +func NewShowSqlBlockRuleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSqlBlockRuleContext { + var p = new(ShowSqlBlockRuleContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowSqlBlockRuleContext) GetRuleName() IIdentifierContext { return s.ruleName } + +func (s *ShowSqlBlockRuleContext) SetRuleName(v IIdentifierContext) { s.ruleName = v } + +func (s *ShowSqlBlockRuleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowSqlBlockRuleContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowSqlBlockRuleContext) SQL_BLOCK_RULE() antlr.TerminalNode { + return s.GetToken(DorisParserSQL_BLOCK_RULE, 0) +} + +func (s *ShowSqlBlockRuleContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowSqlBlockRuleContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowSqlBlockRuleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowSqlBlockRule(s) + } +} + +func (s *ShowSqlBlockRuleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowSqlBlockRule(s) + } +} + +func (s *ShowSqlBlockRuleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowSqlBlockRule(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTableCreationContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowTableCreationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTableCreationContext { + var p = new(ShowTableCreationContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTableCreationContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowTableCreationContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowTableCreationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTableCreationContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTableCreationContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ShowTableCreationContext) CREATION() antlr.TerminalNode { + return s.GetToken(DorisParserCREATION, 0) +} + +func (s *ShowTableCreationContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowTableCreationContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowTableCreationContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTableCreationContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowTableCreationContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTableCreationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTableCreation(s) + } +} + +func (s *ShowTableCreationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTableCreation(s) + } +} + +func (s *ShowTableCreationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTableCreation(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowWarningErrorCountContext struct { + SupportedShowStatementContext +} + +func NewShowWarningErrorCountContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowWarningErrorCountContext { + var p = new(ShowWarningErrorCountContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowWarningErrorCountContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowWarningErrorCountContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowWarningErrorCountContext) COUNT() antlr.TerminalNode { + return s.GetToken(DorisParserCOUNT, 0) +} + +func (s *ShowWarningErrorCountContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ShowWarningErrorCountContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *ShowWarningErrorCountContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ShowWarningErrorCountContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(DorisParserWARNINGS, 0) +} + +func (s *ShowWarningErrorCountContext) ERRORS() antlr.TerminalNode { + return s.GetToken(DorisParserERRORS, 0) +} + +func (s *ShowWarningErrorCountContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowWarningErrorCount(s) + } +} + +func (s *ShowWarningErrorCountContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowWarningErrorCount(s) + } +} + +func (s *ShowWarningErrorCountContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowWarningErrorCount(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowReplicaStatusContext struct { + SupportedShowStatementContext +} + +func NewShowReplicaStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowReplicaStatusContext { + var p = new(ShowReplicaStatusContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowReplicaStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowReplicaStatusContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowReplicaStatusContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *ShowReplicaStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *ShowReplicaStatusContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowReplicaStatusContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *ShowReplicaStatusContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *ShowReplicaStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowReplicaStatus(s) + } +} + +func (s *ShowReplicaStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowReplicaStatus(s) + } +} + +func (s *ShowReplicaStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowReplicaStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDeleteContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowDeleteContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDeleteContext { + var p = new(ShowDeleteContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDeleteContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowDeleteContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowDeleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDeleteContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDeleteContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *ShowDeleteContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowDeleteContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowDeleteContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowDeleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDelete(s) + } +} + +func (s *ShowDeleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDelete(s) + } +} + +func (s *ShowDeleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDelete(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTabletsFromTableContext struct { + SupportedShowStatementContext + tableName IMultipartIdentifierContext +} + +func NewShowTabletsFromTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTabletsFromTableContext { + var p = new(ShowTabletsFromTableContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTabletsFromTableContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowTabletsFromTableContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowTabletsFromTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTabletsFromTableContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTabletsFromTableContext) TABLETS() antlr.TerminalNode { + return s.GetToken(DorisParserTABLETS, 0) +} + +func (s *ShowTabletsFromTableContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTabletsFromTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTabletsFromTableContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *ShowTabletsFromTableContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowTabletsFromTableContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowTabletsFromTableContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowTabletsFromTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTabletsFromTable(s) + } +} + +func (s *ShowTabletsFromTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTabletsFromTable(s) + } +} + +func (s *ShowTabletsFromTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTabletsFromTable(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowStagesContext struct { + SupportedShowStatementContext +} + +func NewShowStagesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowStagesContext { + var p = new(ShowStagesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowStagesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowStagesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowStagesContext) STAGES() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGES, 0) +} + +func (s *ShowStagesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowStages(s) + } +} + +func (s *ShowStagesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowStages(s) + } +} + +func (s *ShowStagesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowStages(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTransactionContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTransactionContext { + var p = new(ShowTransactionContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTransactionContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowTransactionContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTransactionContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTransactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(DorisParserTRANSACTION, 0) +} + +func (s *ShowTransactionContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowTransactionContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTransactionContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowTransactionContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTransaction(s) + } +} + +func (s *ShowTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTransaction(s) + } +} + +func (s *ShowTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTransaction(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowBrokerContext struct { + SupportedShowStatementContext +} + +func NewShowBrokerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowBrokerContext { + var p = new(ShowBrokerContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowBrokerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowBrokerContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowBrokerContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *ShowBrokerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowBroker(s) + } +} + +func (s *ShowBrokerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowBroker(s) + } +} + +func (s *ShowBrokerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowBroker(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowGrantsContext struct { + SupportedShowStatementContext +} + +func NewShowGrantsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGrantsContext { + var p = new(ShowGrantsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowGrantsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowGrantsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowGrantsContext) GRANTS() antlr.TerminalNode { + return s.GetToken(DorisParserGRANTS, 0) +} + +func (s *ShowGrantsContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ShowGrantsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowGrants(s) + } +} + +func (s *ShowGrantsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowGrants(s) + } +} + +func (s *ShowGrantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowGrants(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowResourcesContext struct { + SupportedShowStatementContext +} + +func NewShowResourcesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowResourcesContext { + var p = new(ShowResourcesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowResourcesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowResourcesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowResourcesContext) RESOURCES() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCES, 0) +} + +func (s *ShowResourcesContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowResourcesContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowResourcesContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowResourcesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowResources(s) + } +} + +func (s *ShowResourcesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowResources(s) + } +} + +func (s *ShowResourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowResources(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowWorkloadGroupsContext struct { + SupportedShowStatementContext +} + +func NewShowWorkloadGroupsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowWorkloadGroupsContext { + var p = new(ShowWorkloadGroupsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowWorkloadGroupsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowWorkloadGroupsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowWorkloadGroupsContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *ShowWorkloadGroupsContext) GROUPS() antlr.TerminalNode { + return s.GetToken(DorisParserGROUPS, 0) +} + +func (s *ShowWorkloadGroupsContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowWorkloadGroupsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowWorkloadGroupsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowWorkloadGroups(s) + } +} + +func (s *ShowWorkloadGroupsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowWorkloadGroups(s) + } +} + +func (s *ShowWorkloadGroupsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowWorkloadGroups(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowReplicaDistributionContext struct { + SupportedShowStatementContext +} + +func NewShowReplicaDistributionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowReplicaDistributionContext { + var p = new(ShowReplicaDistributionContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowReplicaDistributionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowReplicaDistributionContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowReplicaDistributionContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *ShowReplicaDistributionContext) DISTRIBUTION() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTION, 0) +} + +func (s *ShowReplicaDistributionContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowReplicaDistributionContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *ShowReplicaDistributionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowReplicaDistribution(s) + } +} + +func (s *ShowReplicaDistributionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowReplicaDistribution(s) + } +} + +func (s *ShowReplicaDistributionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowReplicaDistribution(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTabletStorageFormatContext struct { + SupportedShowStatementContext +} + +func NewShowTabletStorageFormatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTabletStorageFormatContext { + var p = new(ShowTabletStorageFormatContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTabletStorageFormatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTabletStorageFormatContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTabletStorageFormatContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *ShowTabletStorageFormatContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *ShowTabletStorageFormatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserFORMAT, 0) +} + +func (s *ShowTabletStorageFormatContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(DorisParserVERBOSE, 0) +} + +func (s *ShowTabletStorageFormatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTabletStorageFormat(s) + } +} + +func (s *ShowTabletStorageFormatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTabletStorageFormat(s) + } +} + +func (s *ShowTabletStorageFormatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTabletStorageFormat(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCharsetContext struct { + SupportedShowStatementContext +} + +func NewShowCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCharsetContext { + var p = new(ShowCharsetContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCharsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCharsetContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCharsetContext) CHARSET() antlr.TerminalNode { + return s.GetToken(DorisParserCHARSET, 0) +} + +func (s *ShowCharsetContext) CHAR() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR, 0) +} + +func (s *ShowCharsetContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *ShowCharsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCharset(s) + } +} + +func (s *ShowCharsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCharset(s) + } +} + +func (s *ShowCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCharset(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowProcContext struct { + SupportedShowStatementContext + path antlr.Token +} + +func NewShowProcContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowProcContext { + var p = new(ShowProcContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowProcContext) GetPath() antlr.Token { return s.path } + +func (s *ShowProcContext) SetPath(v antlr.Token) { s.path = v } + +func (s *ShowProcContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowProcContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowProcContext) PROC() antlr.TerminalNode { + return s.GetToken(DorisParserPROC, 0) +} + +func (s *ShowProcContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowProcContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowProc(s) + } +} + +func (s *ShowProcContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowProc(s) + } +} + +func (s *ShowProcContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowProc(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateViewContext struct { + SupportedShowStatementContext + name IMultipartIdentifierContext +} + +func NewShowCreateViewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateViewContext { + var p = new(ShowCreateViewContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateViewContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *ShowCreateViewContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *ShowCreateViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateViewContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateViewContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *ShowCreateViewContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateView(s) + } +} + +func (s *ShowCreateViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateView(s) + } +} + +func (s *ShowCreateViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateView(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowOpenTablesContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowOpenTablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowOpenTablesContext { + var p = new(ShowOpenTablesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowOpenTablesContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowOpenTablesContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowOpenTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowOpenTablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowOpenTablesContext) OPEN() antlr.TerminalNode { + return s.GetToken(DorisParserOPEN, 0) +} + +func (s *ShowOpenTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *ShowOpenTablesContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowOpenTablesContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowOpenTablesContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowOpenTablesContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowOpenTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowOpenTables(s) + } +} + +func (s *ShowOpenTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowOpenTables(s) + } +} + +func (s *ShowOpenTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowOpenTables(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowQueryStatsContext struct { + SupportedShowStatementContext + database IIdentifierContext + tableName IMultipartIdentifierContext +} + +func NewShowQueryStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowQueryStatsContext { + var p = new(ShowQueryStatsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowQueryStatsContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowQueryStatsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowQueryStatsContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowQueryStatsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowQueryStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowQueryStatsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowQueryStatsContext) QUERY() antlr.TerminalNode { + return s.GetToken(DorisParserQUERY, 0) +} + +func (s *ShowQueryStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *ShowQueryStatsContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowQueryStatsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowQueryStatsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowQueryStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowQueryStatsContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ShowQueryStatsContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(DorisParserVERBOSE, 0) +} + +func (s *ShowQueryStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowQueryStats(s) + } +} + +func (s *ShowQueryStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowQueryStats(s) + } +} + +func (s *ShowQueryStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowQueryStats(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateDatabaseContext struct { + SupportedShowStatementContext + name IMultipartIdentifierContext +} + +func NewShowCreateDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateDatabaseContext { + var p = new(ShowCreateDatabaseContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateDatabaseContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *ShowCreateDatabaseContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *ShowCreateDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateDatabaseContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateDatabaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *ShowCreateDatabaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEMA, 0) +} + +func (s *ShowCreateDatabaseContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateDatabase(s) + } +} + +func (s *ShowCreateDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateDatabase(s) + } +} + +func (s *ShowCreateDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowQueryProfileContext struct { + SupportedShowStatementContext + queryIdPath antlr.Token +} + +func NewShowQueryProfileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowQueryProfileContext { + var p = new(ShowQueryProfileContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowQueryProfileContext) GetQueryIdPath() antlr.Token { return s.queryIdPath } + +func (s *ShowQueryProfileContext) SetQueryIdPath(v antlr.Token) { s.queryIdPath = v } + +func (s *ShowQueryProfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowQueryProfileContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowQueryProfileContext) QUERY() antlr.TerminalNode { + return s.GetToken(DorisParserQUERY, 0) +} + +func (s *ShowQueryProfileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(DorisParserPROFILE, 0) +} + +func (s *ShowQueryProfileContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowQueryProfileContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowQueryProfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowQueryProfile(s) + } +} + +func (s *ShowQueryProfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowQueryProfile(s) + } +} + +func (s *ShowQueryProfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowQueryProfile(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDictionariesContext struct { + SupportedShowStatementContext +} + +func NewShowDictionariesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDictionariesContext { + var p = new(ShowDictionariesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDictionariesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDictionariesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDictionariesContext) DICTIONARIES() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARIES, 0) +} + +func (s *ShowDictionariesContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowDictionariesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDictionaries(s) + } +} + +func (s *ShowDictionariesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDictionaries(s) + } +} + +func (s *ShowDictionariesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDictionaries(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowStoragePolicyContext struct { + SupportedShowStatementContext + policy IIdentifierOrTextContext +} + +func NewShowStoragePolicyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowStoragePolicyContext { + var p = new(ShowStoragePolicyContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowStoragePolicyContext) GetPolicy() IIdentifierOrTextContext { return s.policy } + +func (s *ShowStoragePolicyContext) SetPolicy(v IIdentifierOrTextContext) { s.policy = v } + +func (s *ShowStoragePolicyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowStoragePolicyContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowStoragePolicyContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *ShowStoragePolicyContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *ShowStoragePolicyContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *ShowStoragePolicyContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowStoragePolicyContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *ShowStoragePolicyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowStoragePolicy(s) + } +} + +func (s *ShowStoragePolicyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowStoragePolicy(s) + } +} + +func (s *ShowStoragePolicyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowStoragePolicy(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowEncryptKeysContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowEncryptKeysContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowEncryptKeysContext { + var p = new(ShowEncryptKeysContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowEncryptKeysContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowEncryptKeysContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowEncryptKeysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowEncryptKeysContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowEncryptKeysContext) ENCRYPTKEYS() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTKEYS, 0) +} + +func (s *ShowEncryptKeysContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowEncryptKeysContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowEncryptKeysContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowEncryptKeysContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowEncryptKeysContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowEncryptKeysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowEncryptKeys(s) + } +} + +func (s *ShowEncryptKeysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowEncryptKeys(s) + } +} + +func (s *ShowEncryptKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowEncryptKeys(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowLoadContext struct { + SupportedShowStatementContext + database IIdentifierContext +} + +func NewShowLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowLoadContext { + var p = new(ShowLoadContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowLoadContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowLoadContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowLoadContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowLoadContext) STREAM() antlr.TerminalNode { + return s.GetToken(DorisParserSTREAM, 0) +} + +func (s *ShowLoadContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowLoadContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowLoadContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowLoadContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowLoadContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowLoadContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowLoad(s) + } +} + +func (s *ShowLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowLoad(s) + } +} + +func (s *ShowLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowClustersContext struct { + SupportedShowStatementContext +} + +func NewShowClustersContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowClustersContext { + var p = new(ShowClustersContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowClustersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowClustersContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowClustersContext) CLUSTERS() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTERS, 0) +} + +func (s *ShowClustersContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, 0) +} + +func (s *ShowClustersContext) GROUPS() antlr.TerminalNode { + return s.GetToken(DorisParserGROUPS, 0) +} + +func (s *ShowClustersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowClusters(s) + } +} + +func (s *ShowClustersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowClusters(s) + } +} + +func (s *ShowClustersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowClusters(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTrashContext struct { + SupportedShowStatementContext + backend antlr.Token +} + +func NewShowTrashContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTrashContext { + var p = new(ShowTrashContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTrashContext) GetBackend() antlr.Token { return s.backend } + +func (s *ShowTrashContext) SetBackend(v antlr.Token) { s.backend = v } + +func (s *ShowTrashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTrashContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTrashContext) TRASH() antlr.TerminalNode { + return s.GetToken(DorisParserTRASH, 0) +} + +func (s *ShowTrashContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ShowTrashContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowTrashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTrash(s) + } +} + +func (s *ShowTrashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTrash(s) + } +} + +func (s *ShowTrashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTrash(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowPartitionsContext struct { + SupportedShowStatementContext + tableName IMultipartIdentifierContext +} + +func NewShowPartitionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowPartitionsContext { + var p = new(ShowPartitionsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowPartitionsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowPartitionsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowPartitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowPartitionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowPartitionsContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITIONS, 0) +} + +func (s *ShowPartitionsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowPartitionsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowPartitionsContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *ShowPartitionsContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowPartitionsContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowPartitionsContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowPartitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowPartitions(s) + } +} + +func (s *ShowPartitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowPartitions(s) + } +} + +func (s *ShowPartitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowPartitions(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowGlobalFunctionsContext struct { + SupportedShowStatementContext +} + +func NewShowGlobalFunctionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowGlobalFunctionsContext { + var p = new(ShowGlobalFunctionsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowGlobalFunctionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowGlobalFunctionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowGlobalFunctionsContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(DorisParserGLOBAL, 0) +} + +func (s *ShowGlobalFunctionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTIONS, 0) +} + +func (s *ShowGlobalFunctionsContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowGlobalFunctionsContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowGlobalFunctionsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowGlobalFunctionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowGlobalFunctions(s) + } +} + +func (s *ShowGlobalFunctionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowGlobalFunctions(s) + } +} + +func (s *ShowGlobalFunctionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowGlobalFunctions(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowFrontendsContext struct { + SupportedShowStatementContext + name IIdentifierContext +} + +func NewShowFrontendsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowFrontendsContext { + var p = new(ShowFrontendsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowFrontendsContext) GetName() IIdentifierContext { return s.name } + +func (s *ShowFrontendsContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ShowFrontendsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowFrontendsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowFrontendsContext) FRONTENDS() antlr.TerminalNode { + return s.GetToken(DorisParserFRONTENDS, 0) +} + +func (s *ShowFrontendsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowFrontendsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowFrontends(s) + } +} + +func (s *ShowFrontendsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowFrontends(s) + } +} + +func (s *ShowFrontendsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowFrontends(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowLoadProfileContext struct { + SupportedShowStatementContext + loadIdPath antlr.Token +} + +func NewShowLoadProfileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowLoadProfileContext { + var p = new(ShowLoadProfileContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowLoadProfileContext) GetLoadIdPath() antlr.Token { return s.loadIdPath } + +func (s *ShowLoadProfileContext) SetLoadIdPath(v antlr.Token) { s.loadIdPath = v } + +func (s *ShowLoadProfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowLoadProfileContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowLoadProfileContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowLoadProfileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(DorisParserPROFILE, 0) +} + +func (s *ShowLoadProfileContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowLoadProfileContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowLoadProfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowLoadProfile(s) + } +} + +func (s *ShowLoadProfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowLoadProfile(s) + } +} + +func (s *ShowLoadProfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowLoadProfile(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowPartitionIdContext struct { + SupportedShowStatementContext + partitionId antlr.Token +} + +func NewShowPartitionIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowPartitionIdContext { + var p = new(ShowPartitionIdContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowPartitionIdContext) GetPartitionId() antlr.Token { return s.partitionId } + +func (s *ShowPartitionIdContext) SetPartitionId(v antlr.Token) { s.partitionId = v } + +func (s *ShowPartitionIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowPartitionIdContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowPartitionIdContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *ShowPartitionIdContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowPartitionIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowPartitionId(s) + } +} + +func (s *ShowPartitionIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowPartitionId(s) + } +} + +func (s *ShowPartitionIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowPartitionId(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowSnapshotContext struct { + SupportedShowStatementContext + repo IIdentifierContext +} + +func NewShowSnapshotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSnapshotContext { + var p = new(ShowSnapshotContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowSnapshotContext) GetRepo() IIdentifierContext { return s.repo } + +func (s *ShowSnapshotContext) SetRepo(v IIdentifierContext) { s.repo = v } + +func (s *ShowSnapshotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowSnapshotContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowSnapshotContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *ShowSnapshotContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ShowSnapshotContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowSnapshotContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowSnapshotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowSnapshot(s) + } +} + +func (s *ShowSnapshotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowSnapshot(s) + } +} + +func (s *ShowSnapshotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowSnapshot(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCatalogRecycleBinContext struct { + SupportedShowStatementContext +} + +func NewShowCatalogRecycleBinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCatalogRecycleBinContext { + var p = new(ShowCatalogRecycleBinContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCatalogRecycleBinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCatalogRecycleBinContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCatalogRecycleBinContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *ShowCatalogRecycleBinContext) RECYCLE() antlr.TerminalNode { + return s.GetToken(DorisParserRECYCLE, 0) +} + +func (s *ShowCatalogRecycleBinContext) BIN() antlr.TerminalNode { + return s.GetToken(DorisParserBIN, 0) +} + +func (s *ShowCatalogRecycleBinContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *ShowCatalogRecycleBinContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ShowCatalogRecycleBinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCatalogRecycleBin(s) + } +} + +func (s *ShowCatalogRecycleBinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCatalogRecycleBin(s) + } +} + +func (s *ShowCatalogRecycleBinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCatalogRecycleBin(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCopyContext struct { + SupportedShowStatementContext + database IIdentifierContext +} + +func NewShowCopyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCopyContext { + var p = new(ShowCopyContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCopyContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowCopyContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowCopyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCopyContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCopyContext) COPY() antlr.TerminalNode { + return s.GetToken(DorisParserCOPY, 0) +} + +func (s *ShowCopyContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *ShowCopyContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowCopyContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowCopyContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowCopyContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowCopyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowCopyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCopy(s) + } +} + +func (s *ShowCopyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCopy(s) + } +} + +func (s *ShowCopyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCopy(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCollationContext struct { + SupportedShowStatementContext +} + +func NewShowCollationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCollationContext { + var p = new(ShowCollationContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCollationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCollationContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCollationContext) COLLATION() antlr.TerminalNode { + return s.GetToken(DorisParserCOLLATION, 0) +} + +func (s *ShowCollationContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowCollationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCollation(s) + } +} + +func (s *ShowCollationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCollation(s) + } +} + +func (s *ShowCollationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCollation(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowBackendsContext struct { + SupportedShowStatementContext +} + +func NewShowBackendsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowBackendsContext { + var p = new(ShowBackendsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowBackendsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowBackendsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowBackendsContext) BACKENDS() antlr.TerminalNode { + return s.GetToken(DorisParserBACKENDS, 0) +} + +func (s *ShowBackendsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowBackends(s) + } +} + +func (s *ShowBackendsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowBackends(s) + } +} + +func (s *ShowBackendsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowBackends(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTypeCastContext struct { + SupportedShowStatementContext + database IIdentifierContext +} + +func NewShowTypeCastContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTypeCastContext { + var p = new(ShowTypeCastContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTypeCastContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowTypeCastContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowTypeCastContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTypeCastContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTypeCastContext) TYPECAST() antlr.TerminalNode { + return s.GetToken(DorisParserTYPECAST, 0) +} + +func (s *ShowTypeCastContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowTypeCastContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowTypeCastContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowTypeCastContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTypeCast(s) + } +} + +func (s *ShowTypeCastContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTypeCast(s) + } +} + +func (s *ShowTypeCastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTypeCast(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowPrivilegesContext struct { + SupportedShowStatementContext +} + +func NewShowPrivilegesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowPrivilegesContext { + var p = new(ShowPrivilegesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowPrivilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowPrivilegesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowPrivilegesContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(DorisParserPRIVILEGES, 0) +} + +func (s *ShowPrivilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowPrivileges(s) + } +} + +func (s *ShowPrivilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowPrivileges(s) + } +} + +func (s *ShowPrivilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowPrivileges(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowRestoreContext struct { + SupportedShowStatementContext + database IIdentifierContext +} + +func NewShowRestoreContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRestoreContext { + var p = new(ShowRestoreContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowRestoreContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowRestoreContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowRestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRestoreContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowRestoreContext) RESTORE() antlr.TerminalNode { + return s.GetToken(DorisParserRESTORE, 0) +} + +func (s *ShowRestoreContext) BRIEF() antlr.TerminalNode { + return s.GetToken(DorisParserBRIEF, 0) +} + +func (s *ShowRestoreContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowRestoreContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowRestoreContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowRestoreContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowRestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowRestore(s) + } +} + +func (s *ShowRestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowRestore(s) + } +} + +func (s *ShowRestoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowRestore(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowLoadWaringsContext struct { + SupportedShowStatementContext + database IIdentifierContext + url antlr.Token +} + +func NewShowLoadWaringsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowLoadWaringsContext { + var p = new(ShowLoadWaringsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowLoadWaringsContext) GetUrl() antlr.Token { return s.url } + +func (s *ShowLoadWaringsContext) SetUrl(v antlr.Token) { s.url = v } + +func (s *ShowLoadWaringsContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowLoadWaringsContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowLoadWaringsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowLoadWaringsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowLoadWaringsContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowLoadWaringsContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(DorisParserWARNINGS, 0) +} + +func (s *ShowLoadWaringsContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ShowLoadWaringsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowLoadWaringsContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowLoadWaringsContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowLoadWaringsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowLoadWaringsContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowLoadWaringsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowLoadWaringsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowLoadWarings(s) + } +} + +func (s *ShowLoadWaringsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowLoadWarings(s) + } +} + +func (s *ShowLoadWaringsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowLoadWarings(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowAlterTableContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowAlterTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowAlterTableContext { + var p = new(ShowAlterTableContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowAlterTableContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowAlterTableContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowAlterTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowAlterTableContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowAlterTableContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *ShowAlterTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ShowAlterTableContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *ShowAlterTableContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *ShowAlterTableContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowAlterTableContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *ShowAlterTableContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *ShowAlterTableContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *ShowAlterTableContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *ShowAlterTableContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowAlterTableContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowAlterTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowAlterTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowAlterTable(s) + } +} + +func (s *ShowAlterTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowAlterTable(s) + } +} + +func (s *ShowAlterTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowAlterTable(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTableIdContext struct { + SupportedShowStatementContext + tableId antlr.Token +} + +func NewShowTableIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTableIdContext { + var p = new(ShowTableIdContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTableIdContext) GetTableId() antlr.Token { return s.tableId } + +func (s *ShowTableIdContext) SetTableId(v antlr.Token) { s.tableId = v } + +func (s *ShowTableIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTableIdContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTableIdContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ShowTableIdContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowTableIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTableId(s) + } +} + +func (s *ShowTableIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTableId(s) + } +} + +func (s *ShowTableIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTableId(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowSmallFilesContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowSmallFilesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowSmallFilesContext { + var p = new(ShowSmallFilesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowSmallFilesContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowSmallFilesContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowSmallFilesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowSmallFilesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowSmallFilesContext) FILE() antlr.TerminalNode { + return s.GetToken(DorisParserFILE, 0) +} + +func (s *ShowSmallFilesContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowSmallFilesContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowSmallFilesContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowSmallFilesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowSmallFiles(s) + } +} + +func (s *ShowSmallFilesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowSmallFiles(s) + } +} + +func (s *ShowSmallFilesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowSmallFiles(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDatabasesContext struct { + SupportedShowStatementContext + catalog IIdentifierContext +} + +func NewShowDatabasesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDatabasesContext { + var p = new(ShowDatabasesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDatabasesContext) GetCatalog() IIdentifierContext { return s.catalog } + +func (s *ShowDatabasesContext) SetCatalog(v IIdentifierContext) { s.catalog = v } + +func (s *ShowDatabasesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDatabasesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDatabasesContext) DATABASES() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASES, 0) +} + +func (s *ShowDatabasesContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEMAS, 0) +} + +func (s *ShowDatabasesContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowDatabasesContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowDatabasesContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowDatabasesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDatabases(s) + } +} + +func (s *ShowDatabasesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDatabases(s) + } +} + +func (s *ShowDatabasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDatabases(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateUserContext struct { + SupportedShowStatementContext +} + +func NewShowCreateUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateUserContext { + var p = new(ShowCreateUserContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateUserContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateUserContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateUserContext) USER() antlr.TerminalNode { + return s.GetToken(DorisParserUSER, 0) +} + +func (s *ShowCreateUserContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *ShowCreateUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateUser(s) + } +} + +func (s *ShowCreateUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateUser(s) + } +} + +func (s *ShowCreateUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateUser(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowTabletIdContext struct { + SupportedShowStatementContext + tabletId antlr.Token +} + +func NewShowTabletIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTabletIdContext { + var p = new(ShowTabletIdContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowTabletIdContext) GetTabletId() antlr.Token { return s.tabletId } + +func (s *ShowTabletIdContext) SetTabletId(v antlr.Token) { s.tabletId = v } + +func (s *ShowTabletIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTabletIdContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTabletIdContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *ShowTabletIdContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowTabletIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTabletId(s) + } +} + +func (s *ShowTabletIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTabletId(s) + } +} + +func (s *ShowTabletIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTabletId(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowStorageVaultContext struct { + SupportedShowStatementContext +} + +func NewShowStorageVaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowStorageVaultContext { + var p = new(ShowStorageVaultContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowStorageVaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowStorageVaultContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowStorageVaultContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *ShowStorageVaultContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *ShowStorageVaultContext) VAULTS() antlr.TerminalNode { + return s.GetToken(DorisParserVAULTS, 0) +} + +func (s *ShowStorageVaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowStorageVault(s) + } +} + +func (s *ShowStorageVaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowStorageVault(s) + } +} + +func (s *ShowStorageVaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowStorageVault(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowStatusContext struct { + SupportedShowStatementContext +} + +func NewShowStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowStatusContext { + var p = new(ShowStatusContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowStatusContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *ShowStatusContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *ShowStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowStatus(s) + } +} + +func (s *ShowStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowStatus(s) + } +} + +func (s *ShowStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowUserPropertiesContext struct { + SupportedShowStatementContext + user IIdentifierOrTextContext +} + +func NewShowUserPropertiesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowUserPropertiesContext { + var p = new(ShowUserPropertiesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowUserPropertiesContext) GetUser() IIdentifierOrTextContext { return s.user } + +func (s *ShowUserPropertiesContext) SetUser(v IIdentifierOrTextContext) { s.user = v } + +func (s *ShowUserPropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowUserPropertiesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowUserPropertiesContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTY, 0) +} + +func (s *ShowUserPropertiesContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowUserPropertiesContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowUserPropertiesContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowUserPropertiesContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *ShowUserPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowUserProperties(s) + } +} + +func (s *ShowUserPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowUserProperties(s) + } +} + +func (s *ShowUserPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowUserProperties(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowWarmUpJobContext struct { + SupportedShowStatementContext +} + +func NewShowWarmUpJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowWarmUpJobContext { + var p = new(ShowWarmUpJobContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowWarmUpJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowWarmUpJobContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowWarmUpJobContext) WARM() antlr.TerminalNode { + return s.GetToken(DorisParserWARM, 0) +} + +func (s *ShowWarmUpJobContext) UP() antlr.TerminalNode { + return s.GetToken(DorisParserUP, 0) +} + +func (s *ShowWarmUpJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *ShowWarmUpJobContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowWarmUpJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowWarmUpJob(s) + } +} + +func (s *ShowWarmUpJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowWarmUpJob(s) + } +} + +func (s *ShowWarmUpJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowWarmUpJob(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowLastInsertContext struct { + SupportedShowStatementContext +} + +func NewShowLastInsertContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowLastInsertContext { + var p = new(ShowLastInsertContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowLastInsertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowLastInsertContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowLastInsertContext) LAST() antlr.TerminalNode { + return s.GetToken(DorisParserLAST, 0) +} + +func (s *ShowLastInsertContext) INSERT() antlr.TerminalNode { + return s.GetToken(DorisParserINSERT, 0) +} + +func (s *ShowLastInsertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowLastInsert(s) + } +} + +func (s *ShowLastInsertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowLastInsert(s) + } +} + +func (s *ShowLastInsertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowLastInsert(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateCatalogContext struct { + SupportedShowStatementContext + name IIdentifierContext +} + +func NewShowCreateCatalogContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateCatalogContext { + var p = new(ShowCreateCatalogContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateCatalogContext) GetName() IIdentifierContext { return s.name } + +func (s *ShowCreateCatalogContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ShowCreateCatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateCatalogContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateCatalogContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateCatalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *ShowCreateCatalogContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowCreateCatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateCatalog(s) + } +} + +func (s *ShowCreateCatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateCatalog(s) + } +} + +func (s *ShowCreateCatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateCatalog(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateMaterializedViewContext struct { + SupportedShowStatementContext + mvName IIdentifierContext + tableName IMultipartIdentifierContext +} + +func NewShowCreateMaterializedViewContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateMaterializedViewContext { + var p = new(ShowCreateMaterializedViewContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateMaterializedViewContext) GetMvName() IIdentifierContext { return s.mvName } + +func (s *ShowCreateMaterializedViewContext) GetTableName() IMultipartIdentifierContext { + return s.tableName +} + +func (s *ShowCreateMaterializedViewContext) SetMvName(v IIdentifierContext) { s.mvName = v } + +func (s *ShowCreateMaterializedViewContext) SetTableName(v IMultipartIdentifierContext) { + s.tableName = v +} + +func (s *ShowCreateMaterializedViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateMaterializedViewContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateMaterializedViewContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateMaterializedViewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *ShowCreateMaterializedViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *ShowCreateMaterializedViewContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ShowCreateMaterializedViewContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowCreateMaterializedViewContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateMaterializedView(s) + } +} + +func (s *ShowCreateMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateMaterializedView(s) + } +} + +func (s *ShowCreateMaterializedViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateMaterializedView(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowProcessListContext struct { + SupportedShowStatementContext +} + +func NewShowProcessListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowProcessListContext { + var p = new(ShowProcessListContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowProcessListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowProcessListContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowProcessListContext) PROCESSLIST() antlr.TerminalNode { + return s.GetToken(DorisParserPROCESSLIST, 0) +} + +func (s *ShowProcessListContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowProcessListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowProcessList(s) + } +} + +func (s *ShowProcessListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowProcessList(s) + } +} + +func (s *ShowProcessListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowProcessList(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDataTypesContext struct { + SupportedShowStatementContext +} + +func NewShowDataTypesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDataTypesContext { + var p = new(ShowDataTypesContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDataTypesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDataTypesContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDataTypesContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *ShowDataTypesContext) TYPES() antlr.TerminalNode { + return s.GetToken(DorisParserTYPES, 0) +} + +func (s *ShowDataTypesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDataTypes(s) + } +} + +func (s *ShowDataTypesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDataTypes(s) + } +} + +func (s *ShowDataTypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDataTypes(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDiagnoseTabletContext struct { + SupportedShowStatementContext + tabletId antlr.Token +} + +func NewShowDiagnoseTabletContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDiagnoseTabletContext { + var p = new(ShowDiagnoseTabletContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDiagnoseTabletContext) GetTabletId() antlr.Token { return s.tabletId } + +func (s *ShowDiagnoseTabletContext) SetTabletId(v antlr.Token) { s.tabletId = v } + +func (s *ShowDiagnoseTabletContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDiagnoseTabletContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDiagnoseTabletContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *ShowDiagnoseTabletContext) DIAGNOSIS() antlr.TerminalNode { + return s.GetToken(DorisParserDIAGNOSIS, 0) +} + +func (s *ShowDiagnoseTabletContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowDiagnoseTabletContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDiagnoseTablet(s) + } +} + +func (s *ShowDiagnoseTabletContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDiagnoseTablet(s) + } +} + +func (s *ShowDiagnoseTabletContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDiagnoseTablet(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowWhitelistContext struct { + SupportedShowStatementContext +} + +func NewShowWhitelistContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowWhitelistContext { + var p = new(ShowWhitelistContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowWhitelistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowWhitelistContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowWhitelistContext) WHITELIST() antlr.TerminalNode { + return s.GetToken(DorisParserWHITELIST, 0) +} + +func (s *ShowWhitelistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowWhitelist(s) + } +} + +func (s *ShowWhitelistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowWhitelist(s) + } +} + +func (s *ShowWhitelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowWhitelist(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowViewsContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowViewsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowViewsContext { + var p = new(ShowViewsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowViewsContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowViewsContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowViewsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowViewsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowViewsContext) VIEWS() antlr.TerminalNode { + return s.GetToken(DorisParserVIEWS, 0) +} + +func (s *ShowViewsContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowViewsContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowViewsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowViewsContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowViewsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowViewsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowViews(s) + } +} + +func (s *ShowViewsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowViews(s) + } +} + +func (s *ShowViewsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowViews(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowFunctionsContext struct { + SupportedShowStatementContext + database IMultipartIdentifierContext +} + +func NewShowFunctionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowFunctionsContext { + var p = new(ShowFunctionsContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowFunctionsContext) GetDatabase() IMultipartIdentifierContext { return s.database } + +func (s *ShowFunctionsContext) SetDatabase(v IMultipartIdentifierContext) { s.database = v } + +func (s *ShowFunctionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowFunctionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowFunctionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTIONS, 0) +} + +func (s *ShowFunctionsContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *ShowFunctionsContext) BUILTIN() antlr.TerminalNode { + return s.GetToken(DorisParserBUILTIN, 0) +} + +func (s *ShowFunctionsContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowFunctionsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowFunctionsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowFunctionsContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowFunctionsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowFunctionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowFunctions(s) + } +} + +func (s *ShowFunctionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowFunctions(s) + } +} + +func (s *ShowFunctionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowFunctions(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateStorageVaultContext struct { + SupportedShowStatementContext +} + +func NewShowCreateStorageVaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateStorageVaultContext { + var p = new(ShowCreateStorageVaultContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateStorageVaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateStorageVaultContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateStorageVaultContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateStorageVaultContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *ShowCreateStorageVaultContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *ShowCreateStorageVaultContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowCreateStorageVaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateStorageVault(s) + } +} + +func (s *ShowCreateStorageVaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateStorageVault(s) + } +} + +func (s *ShowCreateStorageVaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateStorageVault(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowDatabaseIdContext struct { + SupportedShowStatementContext + databaseId antlr.Token +} + +func NewShowDatabaseIdContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDatabaseIdContext { + var p = new(ShowDatabaseIdContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowDatabaseIdContext) GetDatabaseId() antlr.Token { return s.databaseId } + +func (s *ShowDatabaseIdContext) SetDatabaseId(v antlr.Token) { s.databaseId = v } + +func (s *ShowDatabaseIdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowDatabaseIdContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowDatabaseIdContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *ShowDatabaseIdContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowDatabaseIdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowDatabaseId(s) + } +} + +func (s *ShowDatabaseIdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowDatabaseId(s) + } +} + +func (s *ShowDatabaseIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowDatabaseId(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateRepositoryContext struct { + SupportedShowStatementContext +} + +func NewShowCreateRepositoryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateRepositoryContext { + var p = new(ShowCreateRepositoryContext) + + InitEmptySupportedShowStatementContext(&p.SupportedShowStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedShowStatementContext)) + + return p +} + +func (s *ShowCreateRepositoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateRepositoryContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateRepositoryContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateRepositoryContext) REPOSITORY() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORY, 0) +} + +func (s *ShowCreateRepositoryContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowCreateRepositoryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowCreateRepositoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateRepository(s) + } +} + +func (s *ShowCreateRepositoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateRepository(s) + } +} + +func (s *ShowCreateRepositoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateRepository(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedShowStatement() (localctx ISupportedShowStatementContext) { + localctx = NewSupportedShowStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, DorisParserRULE_supportedShowStatement) + var _la int + + p.SetState(2780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 372, p.GetParserRuleContext()) { + case 1: + localctx = NewShowVariablesContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2077) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(2078) + p.StatementScope() + } + + } + { + p.SetState(2081) + p.Match(DorisParserVARIABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2083) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2082) + p.WildWhere() + } + + } + + case 2: + localctx = NewShowAuthorsContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2085) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2086) + p.Match(DorisParserAUTHORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewShowAlterTableContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2087) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2088) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2089) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserROLLUP: + { + p.SetState(2090) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserMATERIALIZED: + { + p.SetState(2091) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2092) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOLUMN: + { + p.SetState(2093) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2096) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2097) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowAlterTableContext).database = _x + } + + } + p.SetState(2101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2100) + p.WildWhere() + } + + } + p.SetState(2104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2103) + p.SortClause() + } + + } + p.SetState(2107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2106) + p.LimitClause() + } + + } + + case 4: + localctx = NewShowCreateDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2109) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2110) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2111) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDATABASE || _la == DorisParserSCHEMA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2112) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateDatabaseContext).name = _x + } + + case 5: + localctx = NewShowBackupContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2113) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2114) + p.Match(DorisParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2117) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2115) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2116) + + var _x = p.Identifier() + + localctx.(*ShowBackupContext).database = _x + } + + } + p.SetState(2120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2119) + p.WildWhere() + } + + } + + case 6: + localctx = NewShowBrokerContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2122) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2123) + p.Match(DorisParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + localctx = NewShowBuildIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2124) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2125) + p.Match(DorisParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2126) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2127) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2128) + + var _x = p.Identifier() + + localctx.(*ShowBuildIndexContext).database = _x + } + + } + p.SetState(2132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2131) + p.WildWhere() + } + + } + p.SetState(2135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2134) + p.SortClause() + } + + } + p.SetState(2138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2137) + p.LimitClause() + } + + } + + case 8: + localctx = NewShowDynamicPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2140) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2141) + p.Match(DorisParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2142) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2143) + p.Match(DorisParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2144) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2145) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowDynamicPartitionContext).database = _x + } + + } + + case 9: + localctx = NewShowEventsContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2148) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2149) + p.Match(DorisParserEVENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2150) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2151) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowEventsContext).database = _x + } + + } + p.SetState(2155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2154) + p.WildWhere() + } + + } + + case 10: + localctx = NewShowExportContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2157) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2158) + p.Match(DorisParserEXPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2159) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2160) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowExportContext).database = _x + } + + } + p.SetState(2164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2163) + p.WildWhere() + } + + } + p.SetState(2167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2166) + p.SortClause() + } + + } + p.SetState(2170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2169) + p.LimitClause() + } + + } + + case 11: + localctx = NewShowLastInsertContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2172) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2173) + p.Match(DorisParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2174) + p.Match(DorisParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewShowCharsetContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2175) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCHAR: + { + p.SetState(2176) + p.Match(DorisParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2177) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCHARSET: + { + p.SetState(2178) + p.Match(DorisParserCHARSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 13: + localctx = NewShowDeleteContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2181) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2182) + p.Match(DorisParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2183) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2184) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowDeleteContext).database = _x + } + + } + + case 14: + localctx = NewShowCreateFunctionContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2187) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2188) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(2189) + p.StatementScope() + } + + } + { + p.SetState(2192) + p.Match(DorisParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2193) + p.FunctionIdentifier() + } + { + p.SetState(2194) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&9152335059222592) != 0) || ((int64((_la-72)) & ^0x3f) == 0 && ((int64(1)<<(_la-72))&254418194574344193) != 0) || _la == DorisParserDOUBLE || _la == DorisParserFLOAT || ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&9208814108673) != 0) || _la == DorisParserMAP || _la == DorisParserQUANTILE_STATE || ((int64((_la-446)) & ^0x3f) == 0 && ((int64(1)<<(_la-446))&5634997485569) != 0) || ((int64((_la-520)) & ^0x3f) == 0 && ((int64(1)<<(_la-520))&19) != 0) { + { + p.SetState(2195) + p.FunctionArguments() + } + + } + { + p.SetState(2198) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2199) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2200) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateFunctionContext).database = _x + } + + } + + case 15: + localctx = NewShowFunctionsContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2203) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2204) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBUILTIN { + { + p.SetState(2207) + p.Match(DorisParserBUILTIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2210) + p.Match(DorisParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2211) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2212) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowFunctionsContext).database = _x + } + + } + p.SetState(2217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2215) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2216) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 16: + localctx = NewShowGlobalFunctionsContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2219) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2220) + p.Match(DorisParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2221) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2224) + p.Match(DorisParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2225) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2226) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 17: + localctx = NewShowGrantsContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2229) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL { + { + p.SetState(2230) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2233) + p.Match(DorisParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + localctx = NewShowGrantsForUserContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2234) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2235) + p.Match(DorisParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2236) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2237) + p.UserIdentify() + } + + case 19: + localctx = NewShowCreateUserContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2238) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2239) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2240) + p.Match(DorisParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2241) + p.UserIdentify() + } + + case 20: + localctx = NewShowSnapshotContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2242) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2243) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2244) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2245) + + var _x = p.Identifier() + + localctx.(*ShowSnapshotContext).repo = _x + } + p.SetState(2247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2246) + p.WildWhere() + } + + } + + case 21: + localctx = NewShowLoadProfileContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2249) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2250) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2251) + p.Match(DorisParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTRING_LITERAL { + { + p.SetState(2252) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowLoadProfileContext).loadIdPath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2255) + p.LimitClause() + } + + } + + case 22: + localctx = NewShowCreateRepositoryContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2258) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2259) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2260) + p.Match(DorisParserREPOSITORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2261) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2262) + p.Identifier() + } + + case 23: + localctx = NewShowViewContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2263) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2264) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2265) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2266) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowViewContext).tableName = _x + } + p.SetState(2269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2267) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2268) + + var _x = p.Identifier() + + localctx.(*ShowViewContext).database = _x + } + + } + + case 24: + localctx = NewShowPluginsContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2271) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2272) + p.Match(DorisParserPLUGINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + localctx = NewShowStorageVaultContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2273) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2274) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2275) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserVAULT || _la == DorisParserVAULTS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 26: + localctx = NewShowRepositoriesContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2276) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2277) + p.Match(DorisParserREPOSITORIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + localctx = NewShowEncryptKeysContext(p, localctx) + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2278) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2279) + p.Match(DorisParserENCRYPTKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2280) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2281) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowEncryptKeysContext).database = _x + } + + } + p.SetState(2286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2284) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2285) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 28: + localctx = NewShowCreateTableContext(p, localctx) + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2288) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBRIEF { + { + p.SetState(2289) + p.Match(DorisParserBRIEF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2292) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2293) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2294) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateTableContext).name = _x + } + + case 29: + localctx = NewShowProcessListContext(p, localctx) + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2295) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2296) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2299) + p.Match(DorisParserPROCESSLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + localctx = NewShowPartitionsContext(p, localctx) + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2300) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(2301) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2304) + p.Match(DorisParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2305) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2306) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowPartitionsContext).tableName = _x + } + p.SetState(2308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2307) + p.WildWhere() + } + + } + p.SetState(2311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2310) + p.SortClause() + } + + } + p.SetState(2314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2313) + p.LimitClause() + } + + } + + case 31: + localctx = NewShowRestoreContext(p, localctx) + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2316) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBRIEF { + { + p.SetState(2317) + p.Match(DorisParserBRIEF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2320) + p.Match(DorisParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2321) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2322) + + var _x = p.Identifier() + + localctx.(*ShowRestoreContext).database = _x + } + + } + p.SetState(2326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2325) + p.WildWhere() + } + + } + + case 32: + localctx = NewShowRolesContext(p, localctx) + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2328) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2329) + p.Match(DorisParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + localctx = NewShowPartitionIdContext(p, localctx) + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2330) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2331) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2332) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowPartitionIdContext).partitionId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + localctx = NewShowPrivilegesContext(p, localctx) + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2333) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2334) + p.Match(DorisParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + localctx = NewShowProcContext(p, localctx) + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2335) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2336) + p.Match(DorisParserPROC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2337) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowProcContext).path = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + localctx = NewShowSmallFilesContext(p, localctx) + p.EnterOuterAlt(localctx, 36) + { + p.SetState(2338) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2339) + p.Match(DorisParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2340) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2341) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowSmallFilesContext).database = _x + } + + } + + case 37: + localctx = NewShowStorageEnginesContext(p, localctx) + p.EnterOuterAlt(localctx, 37) + { + p.SetState(2344) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTORAGE { + { + p.SetState(2345) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2348) + p.Match(DorisParserENGINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + localctx = NewShowCreateCatalogContext(p, localctx) + p.EnterOuterAlt(localctx, 38) + { + p.SetState(2349) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2350) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2351) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2352) + + var _x = p.Identifier() + + localctx.(*ShowCreateCatalogContext).name = _x + } + + case 39: + localctx = NewShowCatalogContext(p, localctx) + p.EnterOuterAlt(localctx, 39) + { + p.SetState(2353) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2354) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2355) + + var _x = p.Identifier() + + localctx.(*ShowCatalogContext).name = _x + } + + case 40: + localctx = NewShowCatalogsContext(p, localctx) + p.EnterOuterAlt(localctx, 40) + { + p.SetState(2356) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2357) + p.Match(DorisParserCATALOGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2358) + p.WildWhere() + } + + } + + case 41: + localctx = NewShowUserPropertiesContext(p, localctx) + p.EnterOuterAlt(localctx, 41) + { + p.SetState(2361) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2362) + p.Match(DorisParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2365) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(2363) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2364) + + var _x = p.IdentifierOrText() + + localctx.(*ShowUserPropertiesContext).user = _x + } + + } + p.SetState(2369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2367) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2368) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 42: + localctx = NewShowAllPropertiesContext(p, localctx) + p.EnterOuterAlt(localctx, 42) + { + p.SetState(2371) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2372) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2373) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2374) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2375) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 43: + localctx = NewShowCollationContext(p, localctx) + p.EnterOuterAlt(localctx, 43) + { + p.SetState(2378) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2379) + p.Match(DorisParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2380) + p.WildWhere() + } + + } + + case 44: + localctx = NewShowRowPolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 44) + { + p.SetState(2383) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2384) + p.Match(DorisParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2385) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(2386) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(2387) + p.UserIdentify() + } + + case DorisParserROLE: + { + p.SetState(2388) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2389) + + var _x = p.Identifier() + + localctx.(*ShowRowPolicyContext).role = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + case 45: + localctx = NewShowStoragePolicyContext(p, localctx) + p.EnterOuterAlt(localctx, 45) + { + p.SetState(2394) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2395) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2396) + p.Match(DorisParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserUSING { + { + p.SetState(2397) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(2398) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2399) + + var _x = p.IdentifierOrText() + + localctx.(*ShowStoragePolicyContext).policy = _x + } + + } + + } + + case 46: + localctx = NewShowSqlBlockRuleContext(p, localctx) + p.EnterOuterAlt(localctx, 46) + { + p.SetState(2404) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2405) + p.Match(DorisParserSQL_BLOCK_RULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(2406) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2407) + + var _x = p.Identifier() + + localctx.(*ShowSqlBlockRuleContext).ruleName = _x + } + + } + + case 47: + localctx = NewShowCreateViewContext(p, localctx) + p.EnterOuterAlt(localctx, 47) + { + p.SetState(2410) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2411) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2412) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2413) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateViewContext).name = _x + } + + case 48: + localctx = NewShowCreateStorageVaultContext(p, localctx) + p.EnterOuterAlt(localctx, 48) + { + p.SetState(2414) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2415) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2416) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2417) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2418) + p.Identifier() + } + + case 49: + localctx = NewShowDataTypesContext(p, localctx) + p.EnterOuterAlt(localctx, 49) + { + p.SetState(2419) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2420) + p.Match(DorisParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2421) + p.Match(DorisParserTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + localctx = NewShowDataContext(p, localctx) + p.EnterOuterAlt(localctx, 50) + { + p.SetState(2422) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2423) + p.Match(DorisParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL { + { + p.SetState(2424) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(2427) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2428) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowDataContext).tableName = _x + } + + } + p.SetState(2432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2431) + p.SortClause() + } + + } + p.SetState(2435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(2434) + p.PropertyClause() + } + + } + + case 51: + localctx = NewShowCreateMaterializedViewContext(p, localctx) + p.EnterOuterAlt(localctx, 51) + { + p.SetState(2437) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2438) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2439) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2440) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2441) + + var _x = p.Identifier() + + localctx.(*ShowCreateMaterializedViewContext).mvName = _x + } + { + p.SetState(2442) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2443) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateMaterializedViewContext).tableName = _x + } + + case 52: + localctx = NewShowWarningErrorsContext(p, localctx) + p.EnterOuterAlt(localctx, 52) + { + p.SetState(2445) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2446) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserERRORS || _la == DorisParserWARNINGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2447) + p.LimitClause() + } + + } + + case 53: + localctx = NewShowWarningErrorCountContext(p, localctx) + p.EnterOuterAlt(localctx, 53) + { + p.SetState(2450) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2451) + p.Match(DorisParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2452) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2453) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2454) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2455) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserERRORS || _la == DorisParserWARNINGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 54: + localctx = NewShowBackendsContext(p, localctx) + p.EnterOuterAlt(localctx, 54) + { + p.SetState(2456) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2457) + p.Match(DorisParserBACKENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + localctx = NewShowStagesContext(p, localctx) + p.EnterOuterAlt(localctx, 55) + { + p.SetState(2458) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2459) + p.Match(DorisParserSTAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + localctx = NewShowReplicaDistributionContext(p, localctx) + p.EnterOuterAlt(localctx, 56) + { + p.SetState(2460) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2461) + p.Match(DorisParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2462) + p.Match(DorisParserDISTRIBUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2463) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2464) + p.BaseTableRef() + } + + case 57: + localctx = NewShowResourcesContext(p, localctx) + p.EnterOuterAlt(localctx, 57) + { + p.SetState(2465) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2466) + p.Match(DorisParserRESOURCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2467) + p.WildWhere() + } + + } + p.SetState(2471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2470) + p.SortClause() + } + + } + p.SetState(2474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2473) + p.LimitClause() + } + + } + + case 58: + localctx = NewShowLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 58) + { + p.SetState(2476) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTREAM { + { + p.SetState(2477) + p.Match(DorisParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2480) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2481) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2482) + + var _x = p.Identifier() + + localctx.(*ShowLoadContext).database = _x + } + + } + p.SetState(2486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2485) + p.WildWhere() + } + + } + p.SetState(2489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2488) + p.SortClause() + } + + } + p.SetState(2492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2491) + p.LimitClause() + } + + } + + case 59: + localctx = NewShowLoadWaringsContext(p, localctx) + p.EnterOuterAlt(localctx, 59) + { + p.SetState(2494) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2495) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2496) + p.Match(DorisParserWARNINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserEOF, DorisParserSEMICOLON, DorisParserFROM, DorisParserIN, DorisParserLIKE, DorisParserLIMIT, DorisParserWHERE: + p.SetState(2499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2497) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2498) + + var _x = p.Identifier() + + localctx.(*ShowLoadWaringsContext).database = _x + } + + } + p.SetState(2502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2501) + p.WildWhere() + } + + } + p.SetState(2505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2504) + p.LimitClause() + } + + } + + case DorisParserON: + { + p.SetState(2507) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2508) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowLoadWaringsContext).url = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 60: + localctx = NewShowTriggersContext(p, localctx) + p.EnterOuterAlt(localctx, 60) + { + p.SetState(2511) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2512) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2515) + p.Match(DorisParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2516) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2517) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTriggersContext).database = _x + } + + } + p.SetState(2521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2520) + p.WildWhere() + } + + } + + case 61: + localctx = NewShowDiagnoseTabletContext(p, localctx) + p.EnterOuterAlt(localctx, 61) + { + p.SetState(2523) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2524) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2525) + p.Match(DorisParserDIAGNOSIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2526) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowDiagnoseTabletContext).tabletId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + localctx = NewShowOpenTablesContext(p, localctx) + p.EnterOuterAlt(localctx, 62) + { + p.SetState(2527) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2528) + p.Match(DorisParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2529) + p.Match(DorisParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2530) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2531) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowOpenTablesContext).database = _x + } + + } + p.SetState(2535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2534) + p.WildWhere() + } + + } + + case 63: + localctx = NewShowFrontendsContext(p, localctx) + p.EnterOuterAlt(localctx, 63) + { + p.SetState(2537) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2538) + p.Match(DorisParserFRONTENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(2539) + + var _x = p.Identifier() + + localctx.(*ShowFrontendsContext).name = _x + } + + } + + case 64: + localctx = NewShowDatabaseIdContext(p, localctx) + p.EnterOuterAlt(localctx, 64) + { + p.SetState(2542) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2543) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2544) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowDatabaseIdContext).databaseId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + localctx = NewShowColumnsContext(p, localctx) + p.EnterOuterAlt(localctx, 65) + { + p.SetState(2545) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2546) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2549) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserCOLUMNS || _la == DorisParserFIELDS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2550) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2551) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowColumnsContext).tableName = _x + } + p.SetState(2554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2552) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2553) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowColumnsContext).database = _x + } + + } + p.SetState(2557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2556) + p.WildWhere() + } + + } + + case 66: + localctx = NewShowTableIdContext(p, localctx) + p.EnterOuterAlt(localctx, 66) + { + p.SetState(2559) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2560) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2561) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowTableIdContext).tableId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + localctx = NewShowTrashContext(p, localctx) + p.EnterOuterAlt(localctx, 67) + { + p.SetState(2562) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2563) + p.Match(DorisParserTRASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(2564) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2565) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowTrashContext).backend = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 68: + localctx = NewShowTypeCastContext(p, localctx) + p.EnterOuterAlt(localctx, 68) + { + p.SetState(2568) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2569) + p.Match(DorisParserTYPECAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2570) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2571) + + var _x = p.Identifier() + + localctx.(*ShowTypeCastContext).database = _x + } + + } + + case 69: + localctx = NewShowClustersContext(p, localctx) + p.EnterOuterAlt(localctx, 69) + { + p.SetState(2574) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCLUSTERS: + { + p.SetState(2575) + p.Match(DorisParserCLUSTERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOMPUTE: + { + p.SetState(2576) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2577) + p.Match(DorisParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 70: + localctx = NewShowStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 70) + { + p.SetState(2580) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(2581) + p.StatementScope() + } + + } + { + p.SetState(2584) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + localctx = NewShowWhitelistContext(p, localctx) + p.EnterOuterAlt(localctx, 71) + { + p.SetState(2585) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2586) + p.Match(DorisParserWHITELIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + localctx = NewShowTabletsBelongContext(p, localctx) + p.EnterOuterAlt(localctx, 72) + { + p.SetState(2587) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2588) + p.Match(DorisParserTABLETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2589) + p.Match(DorisParserBELONG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2590) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowTabletsBelongContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*ShowTabletsBelongContext).tabletIds = append(localctx.(*ShowTabletsBelongContext).tabletIds, localctx.(*ShowTabletsBelongContext)._INTEGER_VALUE) + p.SetState(2595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(2591) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2592) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowTabletsBelongContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*ShowTabletsBelongContext).tabletIds = append(localctx.(*ShowTabletsBelongContext).tabletIds, localctx.(*ShowTabletsBelongContext)._INTEGER_VALUE) + + p.SetState(2597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 73: + localctx = NewShowDataSkewContext(p, localctx) + p.EnterOuterAlt(localctx, 73) + { + p.SetState(2598) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2599) + p.Match(DorisParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2600) + p.Match(DorisParserSKEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2601) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2602) + p.BaseTableRef() + } + + case 74: + localctx = NewShowTableCreationContext(p, localctx) + p.EnterOuterAlt(localctx, 74) + { + p.SetState(2603) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2604) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2605) + p.Match(DorisParserCREATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2606) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2607) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTableCreationContext).database = _x + } + + } + p.SetState(2612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2610) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2611) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 75: + localctx = NewShowTabletStorageFormatContext(p, localctx) + p.EnterOuterAlt(localctx, 75) + { + p.SetState(2614) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2615) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2616) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2617) + p.Match(DorisParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserVERBOSE { + { + p.SetState(2618) + p.Match(DorisParserVERBOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 76: + localctx = NewShowQueryProfileContext(p, localctx) + p.EnterOuterAlt(localctx, 76) + { + p.SetState(2621) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2622) + p.Match(DorisParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2623) + p.Match(DorisParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTRING_LITERAL { + { + p.SetState(2624) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowQueryProfileContext).queryIdPath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2627) + p.LimitClause() + } + + } + + case 77: + localctx = NewShowConvertLscContext(p, localctx) + p.EnterOuterAlt(localctx, 77) + { + p.SetState(2630) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2631) + p.Match(DorisParserCONVERT_LSC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2632) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2633) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowConvertLscContext).database = _x + } + + } + + case 78: + localctx = NewShowTablesContext(p, localctx) + p.EnterOuterAlt(localctx, 78) + { + p.SetState(2636) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2637) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2640) + p.Match(DorisParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2641) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2642) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTablesContext).database = _x + } + + } + p.SetState(2646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2645) + p.WildWhere() + } + + } + + case 79: + localctx = NewShowViewsContext(p, localctx) + p.EnterOuterAlt(localctx, 79) + { + p.SetState(2648) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFULL { + { + p.SetState(2649) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2652) + p.Match(DorisParserVIEWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2653) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2654) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowViewsContext).database = _x + } + + } + p.SetState(2658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2657) + p.WildWhere() + } + + } + + case 80: + localctx = NewShowTableStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 80) + { + p.SetState(2660) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2661) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2662) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2663) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2664) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTableStatusContext).database = _x + } + + } + p.SetState(2668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2667) + p.WildWhere() + } + + } + + case 81: + localctx = NewShowDatabasesContext(p, localctx) + p.EnterOuterAlt(localctx, 81) + { + p.SetState(2670) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2671) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDATABASES || _la == DorisParserSCHEMAS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(2672) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2673) + + var _x = p.Identifier() + + localctx.(*ShowDatabasesContext).catalog = _x + } + + } + p.SetState(2677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2676) + p.WildWhere() + } + + } + + case 82: + localctx = NewShowTabletsFromTableContext(p, localctx) + p.EnterOuterAlt(localctx, 82) + { + p.SetState(2679) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2680) + p.Match(DorisParserTABLETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2681) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2682) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTabletsFromTableContext).tableName = _x + } + p.SetState(2684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(2683) + p.PartitionSpec() + } + + } + p.SetState(2687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2686) + p.WildWhere() + } + + } + p.SetState(2690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2689) + p.SortClause() + } + + } + p.SetState(2693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2692) + p.LimitClause() + } + + } + + case 83: + localctx = NewShowCatalogRecycleBinContext(p, localctx) + p.EnterOuterAlt(localctx, 83) + { + p.SetState(2695) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2696) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2697) + p.Match(DorisParserRECYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2698) + p.Match(DorisParserBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(2699) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2700) + p.Expression() + } + + } + + case 84: + localctx = NewShowTabletIdContext(p, localctx) + p.EnterOuterAlt(localctx, 84) + { + p.SetState(2703) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2704) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2705) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowTabletIdContext).tabletId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + localctx = NewShowDictionariesContext(p, localctx) + p.EnterOuterAlt(localctx, 85) + { + p.SetState(2706) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2707) + p.Match(DorisParserDICTIONARIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2708) + p.WildWhere() + } + + } + + case 86: + localctx = NewShowTransactionContext(p, localctx) + p.EnterOuterAlt(localctx, 86) + { + p.SetState(2711) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2712) + p.Match(DorisParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2713) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2714) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTransactionContext).database = _x + } + + } + p.SetState(2718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2717) + p.WildWhere() + } + + } + + case 87: + localctx = NewShowReplicaStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 87) + { + p.SetState(2720) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2721) + p.Match(DorisParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2722) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2723) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2724) + p.BaseTableRef() + } + p.SetState(2726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(2725) + p.WhereClause() + } + + } + + case 88: + localctx = NewShowWorkloadGroupsContext(p, localctx) + p.EnterOuterAlt(localctx, 88) + { + p.SetState(2728) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2729) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2730) + p.Match(DorisParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2731) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2732) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 89: + localctx = NewShowCopyContext(p, localctx) + p.EnterOuterAlt(localctx, 89) + { + p.SetState(2735) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2736) + p.Match(DorisParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2737) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2738) + + var _x = p.Identifier() + + localctx.(*ShowCopyContext).database = _x + } + + } + p.SetState(2742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(2741) + p.WhereClause() + } + + } + p.SetState(2745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(2744) + p.SortClause() + } + + } + p.SetState(2748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIMIT { + { + p.SetState(2747) + p.LimitClause() + } + + } + + case 90: + localctx = NewShowQueryStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 90) + { + p.SetState(2750) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2751) + p.Match(DorisParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2752) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case DorisParserFOR: + { + p.SetState(2753) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2754) + + var _x = p.Identifier() + + localctx.(*ShowQueryStatsContext).database = _x + } + + case DorisParserFROM: + { + p.SetState(2755) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2756) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowQueryStatsContext).tableName = _x + } + p.SetState(2761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL { + { + p.SetState(2757) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserVERBOSE { + { + p.SetState(2758) + p.Match(DorisParserVERBOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + + case DorisParserEOF, DorisParserSEMICOLON: + + default: + } + + case 91: + localctx = NewShowIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 91) + { + p.SetState(2765) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2766) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-233)) & ^0x3f) == 0 && ((int64(1)<<(_la-233))&201326595) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2767) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2768) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowIndexContext).tableName = _x + } + p.SetState(2771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2769) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2770) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowIndexContext).database = _x + } + + } + + case 92: + localctx = NewShowWarmUpJobContext(p, localctx) + p.EnterOuterAlt(localctx, 92) + { + p.SetState(2773) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2774) + p.Match(DorisParserWARM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2775) + p.Match(DorisParserUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2776) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2777) + p.WildWhere() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedLoadStatementContext is an interface to support dynamic dispatch. +type ISupportedLoadStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedLoadStatementContext differentiates from other interfaces. + IsSupportedLoadStatementContext() +} + +type SupportedLoadStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedLoadStatementContext() *SupportedLoadStatementContext { + var p = new(SupportedLoadStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedLoadStatement + return p +} + +func InitEmptySupportedLoadStatementContext(p *SupportedLoadStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedLoadStatement +} + +func (*SupportedLoadStatementContext) IsSupportedLoadStatementContext() {} + +func NewSupportedLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedLoadStatementContext { + var p = new(SupportedLoadStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedLoadStatement + + return p +} + +func (s *SupportedLoadStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedLoadStatementContext) CopyAll(ctx *SupportedLoadStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedLoadStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedLoadStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ShowRoutineLoadContext struct { + SupportedLoadStatementContext + label IMultipartIdentifierContext +} + +func NewShowRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRoutineLoadContext { + var p = new(ShowRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowRoutineLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *ShowRoutineLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *ShowRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRoutineLoadContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *ShowRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowRoutineLoadContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ShowRoutineLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowRoutineLoadContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *ShowRoutineLoadContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowRoutineLoad(s) + } +} + +func (s *ShowRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowRoutineLoad(s) + } +} + +func (s *ShowRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateLoadContext struct { + SupportedLoadStatementContext + label IMultipartIdentifierContext +} + +func NewShowCreateLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateLoadContext { + var p = new(ShowCreateLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowCreateLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *ShowCreateLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *ShowCreateLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateLoadContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateLoadContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowCreateLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowCreateLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateLoad(s) + } +} + +func (s *ShowCreateLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateLoad(s) + } +} + +func (s *ShowCreateLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type ResumeRoutineLoadContext struct { + SupportedLoadStatementContext + label IMultipartIdentifierContext +} + +func NewResumeRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ResumeRoutineLoadContext { + var p = new(ResumeRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ResumeRoutineLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *ResumeRoutineLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *ResumeRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResumeRoutineLoadContext) RESUME() antlr.TerminalNode { + return s.GetToken(DorisParserRESUME, 0) +} + +func (s *ResumeRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *ResumeRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ResumeRoutineLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ResumeRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ResumeRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterResumeRoutineLoad(s) + } +} + +func (s *ResumeRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitResumeRoutineLoad(s) + } +} + +func (s *ResumeRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitResumeRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowIndexCharFilterContext struct { + SupportedLoadStatementContext +} + +func NewShowIndexCharFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexCharFilterContext { + var p = new(ShowIndexCharFilterContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowIndexCharFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexCharFilterContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowIndexCharFilterContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *ShowIndexCharFilterContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowIndexCharFilterContext) CHAR_FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR_FILTER, 0) +} + +func (s *ShowIndexCharFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowIndexCharFilter(s) + } +} + +func (s *ShowIndexCharFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowIndexCharFilter(s) + } +} + +func (s *ShowIndexCharFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowIndexCharFilter(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateRoutineLoadAliasContext struct { + SupportedLoadStatementContext +} + +func NewCreateRoutineLoadAliasContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateRoutineLoadAliasContext { + var p = new(CreateRoutineLoadAliasContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *CreateRoutineLoadAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRoutineLoadAliasContext) CreateRoutineLoad() ICreateRoutineLoadContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateRoutineLoadContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateRoutineLoadContext) +} + +func (s *CreateRoutineLoadAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateRoutineLoadAlias(s) + } +} + +func (s *CreateRoutineLoadAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateRoutineLoadAlias(s) + } +} + +func (s *CreateRoutineLoadAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateRoutineLoadAlias(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowIndexTokenizerContext struct { + SupportedLoadStatementContext +} + +func NewShowIndexTokenizerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexTokenizerContext { + var p = new(ShowIndexTokenizerContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowIndexTokenizerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexTokenizerContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowIndexTokenizerContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *ShowIndexTokenizerContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowIndexTokenizerContext) TOKENIZER() antlr.TerminalNode { + return s.GetToken(DorisParserTOKENIZER, 0) +} + +func (s *ShowIndexTokenizerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowIndexTokenizer(s) + } +} + +func (s *ShowIndexTokenizerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowIndexTokenizer(s) + } +} + +func (s *ShowIndexTokenizerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowIndexTokenizer(s) + + default: + return t.VisitChildren(s) + } +} + +type PauseAllRoutineLoadContext struct { + SupportedLoadStatementContext +} + +func NewPauseAllRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PauseAllRoutineLoadContext { + var p = new(PauseAllRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *PauseAllRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PauseAllRoutineLoadContext) PAUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPAUSE, 0) +} + +func (s *PauseAllRoutineLoadContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *PauseAllRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *PauseAllRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *PauseAllRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPauseAllRoutineLoad(s) + } +} + +func (s *PauseAllRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPauseAllRoutineLoad(s) + } +} + +func (s *PauseAllRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPauseAllRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type SyncContext struct { + SupportedLoadStatementContext +} + +func NewSyncContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SyncContext { + var p = new(SyncContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *SyncContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyncContext) SYNC() antlr.TerminalNode { + return s.GetToken(DorisParserSYNC, 0) +} + +func (s *SyncContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSync(s) + } +} + +func (s *SyncContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSync(s) + } +} + +func (s *SyncContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSync(s) + + default: + return t.VisitChildren(s) + } +} + +type MysqlLoadContext struct { + SupportedLoadStatementContext + properties IPropertyItemListContext +} + +func NewMysqlLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MysqlLoadContext { + var p = new(MysqlLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *MysqlLoadContext) GetProperties() IPropertyItemListContext { return s.properties } + +func (s *MysqlLoadContext) SetProperties(v IPropertyItemListContext) { s.properties = v } + +func (s *MysqlLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MysqlLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *MysqlLoadContext) MysqlDataDesc() IMysqlDataDescContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMysqlDataDescContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMysqlDataDescContext) +} + +func (s *MysqlLoadContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *MysqlLoadContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *MysqlLoadContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *MysqlLoadContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *MysqlLoadContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *MysqlLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMysqlLoad(s) + } +} + +func (s *MysqlLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMysqlLoad(s) + } +} + +func (s *MysqlLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMysqlLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowCreateRoutineLoadContext struct { + SupportedLoadStatementContext + label IMultipartIdentifierContext +} + +func NewShowCreateRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowCreateRoutineLoadContext { + var p = new(ShowCreateRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowCreateRoutineLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *ShowCreateRoutineLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *ShowCreateRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowCreateRoutineLoadContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowCreateRoutineLoadContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *ShowCreateRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *ShowCreateRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowCreateRoutineLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *ShowCreateRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowCreateRoutineLoadContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ShowCreateRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowCreateRoutineLoad(s) + } +} + +func (s *ShowCreateRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowCreateRoutineLoad(s) + } +} + +func (s *ShowCreateRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowCreateRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type PauseRoutineLoadContext struct { + SupportedLoadStatementContext + label IMultipartIdentifierContext +} + +func NewPauseRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PauseRoutineLoadContext { + var p = new(PauseRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *PauseRoutineLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *PauseRoutineLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *PauseRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PauseRoutineLoadContext) PAUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPAUSE, 0) +} + +func (s *PauseRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *PauseRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *PauseRoutineLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *PauseRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *PauseRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPauseRoutineLoad(s) + } +} + +func (s *PauseRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPauseRoutineLoad(s) + } +} + +func (s *PauseRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPauseRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowIndexTokenFilterContext struct { + SupportedLoadStatementContext +} + +func NewShowIndexTokenFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexTokenFilterContext { + var p = new(ShowIndexTokenFilterContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowIndexTokenFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexTokenFilterContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowIndexTokenFilterContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *ShowIndexTokenFilterContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowIndexTokenFilterContext) TOKEN_FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserTOKEN_FILTER, 0) +} + +func (s *ShowIndexTokenFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowIndexTokenFilter(s) + } +} + +func (s *ShowIndexTokenFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowIndexTokenFilter(s) + } +} + +func (s *ShowIndexTokenFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowIndexTokenFilter(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowIndexAnalyzerContext struct { + SupportedLoadStatementContext +} + +func NewShowIndexAnalyzerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexAnalyzerContext { + var p = new(ShowIndexAnalyzerContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowIndexAnalyzerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexAnalyzerContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowIndexAnalyzerContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *ShowIndexAnalyzerContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowIndexAnalyzerContext) ANALYZER() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZER, 0) +} + +func (s *ShowIndexAnalyzerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowIndexAnalyzer(s) + } +} + +func (s *ShowIndexAnalyzerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowIndexAnalyzer(s) + } +} + +func (s *ShowIndexAnalyzerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowIndexAnalyzer(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowRoutineLoadTaskContext struct { + SupportedLoadStatementContext + database IIdentifierContext +} + +func NewShowRoutineLoadTaskContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowRoutineLoadTaskContext { + var p = new(ShowRoutineLoadTaskContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ShowRoutineLoadTaskContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *ShowRoutineLoadTaskContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *ShowRoutineLoadTaskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowRoutineLoadTaskContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowRoutineLoadTaskContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *ShowRoutineLoadTaskContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ShowRoutineLoadTaskContext) TASK() antlr.TerminalNode { + return s.GetToken(DorisParserTASK, 0) +} + +func (s *ShowRoutineLoadTaskContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *ShowRoutineLoadTaskContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ShowRoutineLoadTaskContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ShowRoutineLoadTaskContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowRoutineLoadTaskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowRoutineLoadTask(s) + } +} + +func (s *ShowRoutineLoadTaskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowRoutineLoadTask(s) + } +} + +func (s *ShowRoutineLoadTaskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowRoutineLoadTask(s) + + default: + return t.VisitChildren(s) + } +} + +type ResumeAllRoutineLoadContext struct { + SupportedLoadStatementContext +} + +func NewResumeAllRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ResumeAllRoutineLoadContext { + var p = new(ResumeAllRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *ResumeAllRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResumeAllRoutineLoadContext) RESUME() antlr.TerminalNode { + return s.GetToken(DorisParserRESUME, 0) +} + +func (s *ResumeAllRoutineLoadContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *ResumeAllRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *ResumeAllRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *ResumeAllRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterResumeAllRoutineLoad(s) + } +} + +func (s *ResumeAllRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitResumeAllRoutineLoad(s) + } +} + +func (s *ResumeAllRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitResumeAllRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type StopRoutineLoadContext struct { + SupportedLoadStatementContext + label IMultipartIdentifierContext +} + +func NewStopRoutineLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StopRoutineLoadContext { + var p = new(StopRoutineLoadContext) + + InitEmptySupportedLoadStatementContext(&p.SupportedLoadStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedLoadStatementContext)) + + return p +} + +func (s *StopRoutineLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *StopRoutineLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *StopRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StopRoutineLoadContext) STOP() antlr.TerminalNode { + return s.GetToken(DorisParserSTOP, 0) +} + +func (s *StopRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *StopRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *StopRoutineLoadContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *StopRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *StopRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStopRoutineLoad(s) + } +} + +func (s *StopRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStopRoutineLoad(s) + } +} + +func (s *StopRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStopRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedLoadStatement() (localctx ISupportedLoadStatementContext) { + localctx = NewSupportedLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, DorisParserRULE_supportedLoadStatement) + var _la int + + p.SetState(2874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 381, p.GetParserRuleContext()) { + case 1: + localctx = NewSyncContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2782) + p.Match(DorisParserSYNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewShowCreateLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2783) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2784) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2785) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2786) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2787) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateLoadContext).label = _x + } + + case 3: + localctx = NewCreateRoutineLoadAliasContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2788) + p.CreateRoutineLoad() + } + + case 4: + localctx = NewMysqlLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2789) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2790) + p.MysqlDataDesc() + } + p.SetState(2796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(2791) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2792) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2793) + + var _x = p.PropertyItemList() + + localctx.(*MysqlLoadContext).properties = _x + } + { + p.SetState(2794) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(2798) + p.CommentSpec() + } + + } + + case 5: + localctx = NewShowCreateRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2801) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL { + { + p.SetState(2802) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2805) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2806) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2807) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2808) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2809) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowCreateRoutineLoadContext).label = _x + } + + case 6: + localctx = NewPauseRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2810) + p.Match(DorisParserPAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2811) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2812) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2813) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2814) + + var _x = p.MultipartIdentifier() + + localctx.(*PauseRoutineLoadContext).label = _x + } + + case 7: + localctx = NewPauseAllRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2815) + p.Match(DorisParserPAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2816) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2817) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2818) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewResumeRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2819) + p.Match(DorisParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2820) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2821) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2822) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2823) + + var _x = p.MultipartIdentifier() + + localctx.(*ResumeRoutineLoadContext).label = _x + } + + case 9: + localctx = NewResumeAllRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2824) + p.Match(DorisParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2825) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2826) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2827) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewStopRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2828) + p.Match(DorisParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2829) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2830) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2831) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2832) + + var _x = p.MultipartIdentifier() + + localctx.(*StopRoutineLoadContext).label = _x + } + + case 11: + localctx = NewShowRoutineLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2833) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL { + { + p.SetState(2834) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2837) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2838) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserFOR: + { + p.SetState(2839) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2840) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowRoutineLoadContext).label = _x + } + + case DorisParserEOF, DorisParserSEMICOLON, DorisParserLIKE: + p.SetState(2843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE { + { + p.SetState(2841) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2842) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 12: + localctx = NewShowRoutineLoadTaskContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2847) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2848) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2849) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2850) + p.Match(DorisParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(2851) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2852) + + var _x = p.Identifier() + + localctx.(*ShowRoutineLoadTaskContext).database = _x + } + + } + p.SetState(2856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(2855) + p.WildWhere() + } + + } + + case 13: + localctx = NewShowIndexAnalyzerContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2858) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2859) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2860) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2861) + p.Match(DorisParserANALYZER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewShowIndexTokenizerContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2862) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2863) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2864) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2865) + p.Match(DorisParserTOKENIZER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewShowIndexTokenFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2866) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2867) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2868) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2869) + p.Match(DorisParserTOKEN_FILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + localctx = NewShowIndexCharFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2870) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2871) + p.Match(DorisParserINVERTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2872) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2873) + p.Match(DorisParserCHAR_FILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedKillStatementContext is an interface to support dynamic dispatch. +type ISupportedKillStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedKillStatementContext differentiates from other interfaces. + IsSupportedKillStatementContext() +} + +type SupportedKillStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedKillStatementContext() *SupportedKillStatementContext { + var p = new(SupportedKillStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedKillStatement + return p +} + +func InitEmptySupportedKillStatementContext(p *SupportedKillStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedKillStatement +} + +func (*SupportedKillStatementContext) IsSupportedKillStatementContext() {} + +func NewSupportedKillStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedKillStatementContext { + var p = new(SupportedKillStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedKillStatement + + return p +} + +func (s *SupportedKillStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedKillStatementContext) CopyAll(ctx *SupportedKillStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedKillStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedKillStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type KillQueryContext struct { + SupportedKillStatementContext +} + +func NewKillQueryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KillQueryContext { + var p = new(KillQueryContext) + + InitEmptySupportedKillStatementContext(&p.SupportedKillStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedKillStatementContext)) + + return p +} + +func (s *KillQueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KillQueryContext) KILL() antlr.TerminalNode { + return s.GetToken(DorisParserKILL, 0) +} + +func (s *KillQueryContext) QUERY() antlr.TerminalNode { + return s.GetToken(DorisParserQUERY, 0) +} + +func (s *KillQueryContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *KillQueryContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *KillQueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterKillQuery(s) + } +} + +func (s *KillQueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitKillQuery(s) + } +} + +func (s *KillQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitKillQuery(s) + + default: + return t.VisitChildren(s) + } +} + +type KillConnectionContext struct { + SupportedKillStatementContext +} + +func NewKillConnectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KillConnectionContext { + var p = new(KillConnectionContext) + + InitEmptySupportedKillStatementContext(&p.SupportedKillStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedKillStatementContext)) + + return p +} + +func (s *KillConnectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KillConnectionContext) KILL() antlr.TerminalNode { + return s.GetToken(DorisParserKILL, 0) +} + +func (s *KillConnectionContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *KillConnectionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(DorisParserCONNECTION, 0) +} + +func (s *KillConnectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterKillConnection(s) + } +} + +func (s *KillConnectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitKillConnection(s) + } +} + +func (s *KillConnectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitKillConnection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedKillStatement() (localctx ISupportedKillStatementContext) { + localctx = NewSupportedKillStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, DorisParserRULE_supportedKillStatement) + var _la int + + p.SetState(2884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 383, p.GetParserRuleContext()) { + case 1: + localctx = NewKillConnectionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2876) + p.Match(DorisParserKILL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCONNECTION { + { + p.SetState(2877) + p.Match(DorisParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2880) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewKillQueryContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2881) + p.Match(DorisParserKILL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2882) + p.Match(DorisParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2883) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserSTRING_LITERAL || _la == DorisParserINTEGER_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedOtherStatementContext is an interface to support dynamic dispatch. +type ISupportedOtherStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedOtherStatementContext differentiates from other interfaces. + IsSupportedOtherStatementContext() +} + +type SupportedOtherStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedOtherStatementContext() *SupportedOtherStatementContext { + var p = new(SupportedOtherStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedOtherStatement + return p +} + +func InitEmptySupportedOtherStatementContext(p *SupportedOtherStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedOtherStatement +} + +func (*SupportedOtherStatementContext) IsSupportedOtherStatementContext() {} + +func NewSupportedOtherStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedOtherStatementContext { + var p = new(SupportedOtherStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedOtherStatement + + return p +} + +func (s *SupportedOtherStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedOtherStatementContext) CopyAll(ctx *SupportedOtherStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedOtherStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedOtherStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type HelpContext struct { + SupportedOtherStatementContext + mark IIdentifierOrTextContext +} + +func NewHelpContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HelpContext { + var p = new(HelpContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *HelpContext) GetMark() IIdentifierOrTextContext { return s.mark } + +func (s *HelpContext) SetMark(v IIdentifierOrTextContext) { s.mark = v } + +func (s *HelpContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HelpContext) HELP() antlr.TerminalNode { + return s.GetToken(DorisParserHELP, 0) +} + +func (s *HelpContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *HelpContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterHelp(s) + } +} + +func (s *HelpContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitHelp(s) + } +} + +func (s *HelpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitHelp(s) + + default: + return t.VisitChildren(s) + } +} + +type UnlockTablesContext struct { + SupportedOtherStatementContext +} + +func NewUnlockTablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnlockTablesContext { + var p = new(UnlockTablesContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *UnlockTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnlockTablesContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(DorisParserUNLOCK, 0) +} + +func (s *UnlockTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *UnlockTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUnlockTables(s) + } +} + +func (s *UnlockTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUnlockTables(s) + } +} + +func (s *UnlockTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUnlockTables(s) + + default: + return t.VisitChildren(s) + } +} + +type UninstallPluginContext struct { + SupportedOtherStatementContext + name IIdentifierOrTextContext +} + +func NewUninstallPluginContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UninstallPluginContext { + var p = new(UninstallPluginContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *UninstallPluginContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *UninstallPluginContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *UninstallPluginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UninstallPluginContext) UNINSTALL() antlr.TerminalNode { + return s.GetToken(DorisParserUNINSTALL, 0) +} + +func (s *UninstallPluginContext) PLUGIN() antlr.TerminalNode { + return s.GetToken(DorisParserPLUGIN, 0) +} + +func (s *UninstallPluginContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *UninstallPluginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUninstallPlugin(s) + } +} + +func (s *UninstallPluginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUninstallPlugin(s) + } +} + +func (s *UninstallPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUninstallPlugin(s) + + default: + return t.VisitChildren(s) + } +} + +type BackupContext struct { + SupportedOtherStatementContext + label IMultipartIdentifierContext + repo IIdentifierContext + properties IPropertyClauseContext +} + +func NewBackupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BackupContext { + var p = new(BackupContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *BackupContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *BackupContext) GetRepo() IIdentifierContext { return s.repo } + +func (s *BackupContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *BackupContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *BackupContext) SetRepo(v IIdentifierContext) { s.repo = v } + +func (s *BackupContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *BackupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BackupContext) BACKUP() antlr.TerminalNode { + return s.GetToken(DorisParserBACKUP, 0) +} + +func (s *BackupContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *BackupContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *BackupContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *BackupContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *BackupContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *BackupContext) AllBaseTableRef() []IBaseTableRefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBaseTableRefContext); ok { + len++ + } + } + + tst := make([]IBaseTableRefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBaseTableRefContext); ok { + tst[i] = t.(IBaseTableRefContext) + i++ + } + } + + return tst +} + +func (s *BackupContext) BaseTableRef(i int) IBaseTableRefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *BackupContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *BackupContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *BackupContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(DorisParserEXCLUDE, 0) +} + +func (s *BackupContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *BackupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *BackupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *BackupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBackup(s) + } +} + +func (s *BackupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBackup(s) + } +} + +func (s *BackupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBackup(s) + + default: + return t.VisitChildren(s) + } +} + +type LockTablesContext struct { + SupportedOtherStatementContext +} + +func NewLockTablesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LockTablesContext { + var p = new(LockTablesContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *LockTablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockTablesContext) LOCK() antlr.TerminalNode { + return s.GetToken(DorisParserLOCK, 0) +} + +func (s *LockTablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *LockTablesContext) AllLockTable() []ILockTableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILockTableContext); ok { + len++ + } + } + + tst := make([]ILockTableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILockTableContext); ok { + tst[i] = t.(ILockTableContext) + i++ + } + } + + return tst +} + +func (s *LockTablesContext) LockTable(i int) ILockTableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockTableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILockTableContext) +} + +func (s *LockTablesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *LockTablesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *LockTablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLockTables(s) + } +} + +func (s *LockTablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLockTables(s) + } +} + +func (s *LockTablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLockTables(s) + + default: + return t.VisitChildren(s) + } +} + +type RestoreContext struct { + SupportedOtherStatementContext + label IMultipartIdentifierContext + repo IIdentifierContext + properties IPropertyClauseContext +} + +func NewRestoreContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RestoreContext { + var p = new(RestoreContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *RestoreContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *RestoreContext) GetRepo() IIdentifierContext { return s.repo } + +func (s *RestoreContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *RestoreContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *RestoreContext) SetRepo(v IIdentifierContext) { s.repo = v } + +func (s *RestoreContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *RestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RestoreContext) RESTORE() antlr.TerminalNode { + return s.GetToken(DorisParserRESTORE, 0) +} + +func (s *RestoreContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *RestoreContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *RestoreContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RestoreContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RestoreContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *RestoreContext) AllBaseTableRef() []IBaseTableRefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBaseTableRefContext); ok { + len++ + } + } + + tst := make([]IBaseTableRefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBaseTableRefContext); ok { + tst[i] = t.(IBaseTableRefContext) + i++ + } + } + + return tst +} + +func (s *RestoreContext) BaseTableRef(i int) IBaseTableRefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *RestoreContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *RestoreContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *RestoreContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(DorisParserEXCLUDE, 0) +} + +func (s *RestoreContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *RestoreContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *RestoreContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *RestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRestore(s) + } +} + +func (s *RestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRestore(s) + } +} + +func (s *RestoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRestore(s) + + default: + return t.VisitChildren(s) + } +} + +type WarmUpSelectContext struct { + SupportedOtherStatementContext +} + +func NewWarmUpSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WarmUpSelectContext { + var p = new(WarmUpSelectContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *WarmUpSelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WarmUpSelectContext) WARM() antlr.TerminalNode { + return s.GetToken(DorisParserWARM, 0) +} + +func (s *WarmUpSelectContext) UP() antlr.TerminalNode { + return s.GetToken(DorisParserUP, 0) +} + +func (s *WarmUpSelectContext) SELECT() antlr.TerminalNode { + return s.GetToken(DorisParserSELECT, 0) +} + +func (s *WarmUpSelectContext) NamedExpressionSeq() INamedExpressionSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamedExpressionSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamedExpressionSeqContext) +} + +func (s *WarmUpSelectContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *WarmUpSelectContext) WarmUpSingleTableRef() IWarmUpSingleTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWarmUpSingleTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWarmUpSingleTableRefContext) +} + +func (s *WarmUpSelectContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *WarmUpSelectContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *WarmUpSelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWarmUpSelect(s) + } +} + +func (s *WarmUpSelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWarmUpSelect(s) + } +} + +func (s *WarmUpSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWarmUpSelect(s) + + default: + return t.VisitChildren(s) + } +} + +type InstallPluginContext struct { + SupportedOtherStatementContext + source IIdentifierOrTextContext + properties IPropertyClauseContext +} + +func NewInstallPluginContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InstallPluginContext { + var p = new(InstallPluginContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *InstallPluginContext) GetSource() IIdentifierOrTextContext { return s.source } + +func (s *InstallPluginContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *InstallPluginContext) SetSource(v IIdentifierOrTextContext) { s.source = v } + +func (s *InstallPluginContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *InstallPluginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InstallPluginContext) INSTALL() antlr.TerminalNode { + return s.GetToken(DorisParserINSTALL, 0) +} + +func (s *InstallPluginContext) PLUGIN() antlr.TerminalNode { + return s.GetToken(DorisParserPLUGIN, 0) +} + +func (s *InstallPluginContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *InstallPluginContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *InstallPluginContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *InstallPluginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterInstallPlugin(s) + } +} + +func (s *InstallPluginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitInstallPlugin(s) + } +} + +func (s *InstallPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitInstallPlugin(s) + + default: + return t.VisitChildren(s) + } +} + +type WarmUpClusterContext struct { + SupportedOtherStatementContext + destination IIdentifierContext + source IIdentifierContext + properties IPropertyClauseContext +} + +func NewWarmUpClusterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WarmUpClusterContext { + var p = new(WarmUpClusterContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *WarmUpClusterContext) GetDestination() IIdentifierContext { return s.destination } + +func (s *WarmUpClusterContext) GetSource() IIdentifierContext { return s.source } + +func (s *WarmUpClusterContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *WarmUpClusterContext) SetDestination(v IIdentifierContext) { s.destination = v } + +func (s *WarmUpClusterContext) SetSource(v IIdentifierContext) { s.source = v } + +func (s *WarmUpClusterContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *WarmUpClusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WarmUpClusterContext) WARM() antlr.TerminalNode { + return s.GetToken(DorisParserWARM, 0) +} + +func (s *WarmUpClusterContext) UP() antlr.TerminalNode { + return s.GetToken(DorisParserUP, 0) +} + +func (s *WarmUpClusterContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *WarmUpClusterContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *WarmUpClusterContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *WarmUpClusterContext) AllCLUSTER() []antlr.TerminalNode { + return s.GetTokens(DorisParserCLUSTER) +} + +func (s *WarmUpClusterContext) CLUSTER(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, i) +} + +func (s *WarmUpClusterContext) AllCOMPUTE() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMPUTE) +} + +func (s *WarmUpClusterContext) COMPUTE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, i) +} + +func (s *WarmUpClusterContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(DorisParserGROUP) +} + +func (s *WarmUpClusterContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, i) +} + +func (s *WarmUpClusterContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *WarmUpClusterContext) AllWarmUpItem() []IWarmUpItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWarmUpItemContext); ok { + len++ + } + } + + tst := make([]IWarmUpItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWarmUpItemContext); ok { + tst[i] = t.(IWarmUpItemContext) + i++ + } + } + + return tst +} + +func (s *WarmUpClusterContext) WarmUpItem(i int) IWarmUpItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWarmUpItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWarmUpItemContext) +} + +func (s *WarmUpClusterContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *WarmUpClusterContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(DorisParserAND) +} + +func (s *WarmUpClusterContext) AND(i int) antlr.TerminalNode { + return s.GetToken(DorisParserAND, i) +} + +func (s *WarmUpClusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWarmUpCluster(s) + } +} + +func (s *WarmUpClusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWarmUpCluster(s) + } +} + +func (s *WarmUpClusterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWarmUpCluster(s) + + default: + return t.VisitChildren(s) + } +} + +type UnsupportedStartTransactionContext struct { + SupportedOtherStatementContext +} + +func NewUnsupportedStartTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnsupportedStartTransactionContext { + var p = new(UnsupportedStartTransactionContext) + + InitEmptySupportedOtherStatementContext(&p.SupportedOtherStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedOtherStatementContext)) + + return p +} + +func (s *UnsupportedStartTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnsupportedStartTransactionContext) START() antlr.TerminalNode { + return s.GetToken(DorisParserSTART, 0) +} + +func (s *UnsupportedStartTransactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(DorisParserTRANSACTION, 0) +} + +func (s *UnsupportedStartTransactionContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *UnsupportedStartTransactionContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(DorisParserCONSISTENT, 0) +} + +func (s *UnsupportedStartTransactionContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *UnsupportedStartTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUnsupportedStartTransaction(s) + } +} + +func (s *UnsupportedStartTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUnsupportedStartTransaction(s) + } +} + +func (s *UnsupportedStartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUnsupportedStartTransaction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedOtherStatement() (localctx ISupportedOtherStatementContext) { + localctx = NewSupportedOtherStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, DorisParserRULE_supportedOtherStatement) + var _la int + + p.SetState(3006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 402, p.GetParserRuleContext()) { + case 1: + localctx = NewHelpContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2886) + p.Match(DorisParserHELP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2887) + + var _x = p.IdentifierOrText() + + localctx.(*HelpContext).mark = _x + } + + case 2: + localctx = NewUnlockTablesContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2888) + p.Match(DorisParserUNLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2889) + p.Match(DorisParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewInstallPluginContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2890) + p.Match(DorisParserINSTALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2891) + p.Match(DorisParserPLUGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2892) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2893) + + var _x = p.IdentifierOrText() + + localctx.(*InstallPluginContext).source = _x + } + p.SetState(2895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(2894) + + var _x = p.PropertyClause() + + localctx.(*InstallPluginContext).properties = _x + } + + } + + case 4: + localctx = NewUninstallPluginContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2897) + p.Match(DorisParserUNINSTALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2898) + p.Match(DorisParserPLUGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2899) + + var _x = p.IdentifierOrText() + + localctx.(*UninstallPluginContext).name = _x + } + + case 5: + localctx = NewLockTablesContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2900) + p.Match(DorisParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2901) + p.Match(DorisParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(2902) + p.LockTable() + } + p.SetState(2907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(2903) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2904) + p.LockTable() + } + + p.SetState(2909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case 6: + localctx = NewRestoreContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2912) + p.Match(DorisParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2913) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2914) + + var _x = p.MultipartIdentifier() + + localctx.(*RestoreContext).label = _x + } + { + p.SetState(2915) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2916) + + var _x = p.Identifier() + + localctx.(*RestoreContext).repo = _x + } + p.SetState(2929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEXCLUDE || _la == DorisParserON { + { + p.SetState(2917) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserEXCLUDE || _la == DorisParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2918) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2919) + p.BaseTableRef() + } + p.SetState(2924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(2920) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2921) + p.BaseTableRef() + } + + p.SetState(2926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2927) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(2931) + + var _x = p.PropertyClause() + + localctx.(*RestoreContext).properties = _x + } + + } + + case 7: + localctx = NewWarmUpClusterContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2934) + p.Match(DorisParserWARM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2935) + p.Match(DorisParserUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCLUSTER: + { + p.SetState(2936) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOMPUTE: + { + p.SetState(2937) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2938) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2941) + + var _x = p.Identifier() + + localctx.(*WarmUpClusterContext).destination = _x + } + { + p.SetState(2942) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCLUSTER, DorisParserCOMPUTE: + p.SetState(2946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCLUSTER: + { + p.SetState(2943) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOMPUTE: + { + p.SetState(2944) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2945) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2948) + + var _x = p.Identifier() + + localctx.(*WarmUpClusterContext).source = _x + } + + case DorisParserTABLE: + { + p.SetState(2949) + p.WarmUpItem() + } + p.SetState(2954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserAND { + { + p.SetState(2950) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2951) + p.WarmUpItem() + } + + p.SetState(2956) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(2959) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(2962) + + var _x = p.PropertyClause() + + localctx.(*WarmUpClusterContext).properties = _x + } + + } + + case 8: + localctx = NewWarmUpSelectContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + p.SetState(2966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0 { + { + p.SetState(2965) + p.Explain() + } + + } + { + p.SetState(2968) + p.Match(DorisParserWARM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2969) + p.Match(DorisParserUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2970) + p.Match(DorisParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2971) + p.NamedExpressionSeq() + } + { + p.SetState(2972) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2973) + p.WarmUpSingleTableRef() + } + p.SetState(2975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(2974) + p.WhereClause() + } + + } + + case 9: + localctx = NewBackupContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2977) + p.Match(DorisParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2978) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2979) + + var _x = p.MultipartIdentifier() + + localctx.(*BackupContext).label = _x + } + { + p.SetState(2980) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2981) + + var _x = p.Identifier() + + localctx.(*BackupContext).repo = _x + } + p.SetState(2994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEXCLUDE || _la == DorisParserON { + { + p.SetState(2982) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserEXCLUDE || _la == DorisParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2983) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2984) + p.BaseTableRef() + } + p.SetState(2989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(2985) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2986) + p.BaseTableRef() + } + + p.SetState(2991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2992) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(2996) + + var _x = p.PropertyClause() + + localctx.(*BackupContext).properties = _x + } + + } + + case 10: + localctx = NewUnsupportedStartTransactionContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2999) + p.Match(DorisParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3000) + p.Match(DorisParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(3001) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3002) + p.Match(DorisParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3003) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWarmUpItemContext is an interface to support dynamic dispatch. +type IWarmUpItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTableName returns the tableName rule contexts. + GetTableName() IMultipartIdentifierContext + + // GetPartitionName returns the partitionName rule contexts. + GetPartitionName() IIdentifierContext + + // SetTableName sets the tableName rule contexts. + SetTableName(IMultipartIdentifierContext) + + // SetPartitionName sets the partitionName rule contexts. + SetPartitionName(IIdentifierContext) + + // Getter signatures + TABLE() antlr.TerminalNode + MultipartIdentifier() IMultipartIdentifierContext + PARTITION() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsWarmUpItemContext differentiates from other interfaces. + IsWarmUpItemContext() +} + +type WarmUpItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tableName IMultipartIdentifierContext + partitionName IIdentifierContext +} + +func NewEmptyWarmUpItemContext() *WarmUpItemContext { + var p = new(WarmUpItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_warmUpItem + return p +} + +func InitEmptyWarmUpItemContext(p *WarmUpItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_warmUpItem +} + +func (*WarmUpItemContext) IsWarmUpItemContext() {} + +func NewWarmUpItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WarmUpItemContext { + var p = new(WarmUpItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_warmUpItem + + return p +} + +func (s *WarmUpItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *WarmUpItemContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *WarmUpItemContext) GetPartitionName() IIdentifierContext { return s.partitionName } + +func (s *WarmUpItemContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *WarmUpItemContext) SetPartitionName(v IIdentifierContext) { s.partitionName = v } + +func (s *WarmUpItemContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *WarmUpItemContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *WarmUpItemContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *WarmUpItemContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *WarmUpItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WarmUpItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WarmUpItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWarmUpItem(s) + } +} + +func (s *WarmUpItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWarmUpItem(s) + } +} + +func (s *WarmUpItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWarmUpItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WarmUpItem() (localctx IWarmUpItemContext) { + localctx = NewWarmUpItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, DorisParserRULE_warmUpItem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3008) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3009) + + var _x = p.MultipartIdentifier() + + localctx.(*WarmUpItemContext).tableName = _x + } + p.SetState(3012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION { + { + p.SetState(3010) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3011) + + var _x = p.Identifier() + + localctx.(*WarmUpItemContext).partitionName = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWarmUpSingleTableRefContext is an interface to support dynamic dispatch. +type IWarmUpSingleTableRefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MultipartIdentifier() IMultipartIdentifierContext + TableAlias() ITableAliasContext + + // IsWarmUpSingleTableRefContext differentiates from other interfaces. + IsWarmUpSingleTableRefContext() +} + +type WarmUpSingleTableRefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWarmUpSingleTableRefContext() *WarmUpSingleTableRefContext { + var p = new(WarmUpSingleTableRefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_warmUpSingleTableRef + return p +} + +func InitEmptyWarmUpSingleTableRefContext(p *WarmUpSingleTableRefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_warmUpSingleTableRef +} + +func (*WarmUpSingleTableRefContext) IsWarmUpSingleTableRefContext() {} + +func NewWarmUpSingleTableRefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WarmUpSingleTableRefContext { + var p = new(WarmUpSingleTableRefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_warmUpSingleTableRef + + return p +} + +func (s *WarmUpSingleTableRefContext) GetParser() antlr.Parser { return s.parser } + +func (s *WarmUpSingleTableRefContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *WarmUpSingleTableRefContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *WarmUpSingleTableRefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WarmUpSingleTableRefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WarmUpSingleTableRefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWarmUpSingleTableRef(s) + } +} + +func (s *WarmUpSingleTableRefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWarmUpSingleTableRef(s) + } +} + +func (s *WarmUpSingleTableRefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWarmUpSingleTableRef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WarmUpSingleTableRef() (localctx IWarmUpSingleTableRefContext) { + localctx = NewWarmUpSingleTableRefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, DorisParserRULE_warmUpSingleTableRef) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3014) + p.MultipartIdentifier() + } + p.SetState(3016) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 404, p.GetParserRuleContext()) == 1 { + { + p.SetState(3015) + p.TableAlias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockTableContext is an interface to support dynamic dispatch. +type ILockTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IMultipartIdentifierContext + + // GetAlias returns the alias rule contexts. + GetAlias() IIdentifierOrTextContext + + // SetName sets the name rule contexts. + SetName(IMultipartIdentifierContext) + + // SetAlias sets the alias rule contexts. + SetAlias(IIdentifierOrTextContext) + + // Getter signatures + MultipartIdentifier() IMultipartIdentifierContext + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + AS() antlr.TerminalNode + IdentifierOrText() IIdentifierOrTextContext + LOCAL() antlr.TerminalNode + LOW_PRIORITY() antlr.TerminalNode + + // IsLockTableContext differentiates from other interfaces. + IsLockTableContext() +} + +type LockTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IMultipartIdentifierContext + alias IIdentifierOrTextContext +} + +func NewEmptyLockTableContext() *LockTableContext { + var p = new(LockTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lockTable + return p +} + +func InitEmptyLockTableContext(p *LockTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lockTable +} + +func (*LockTableContext) IsLockTableContext() {} + +func NewLockTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockTableContext { + var p = new(LockTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_lockTable + + return p +} + +func (s *LockTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *LockTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *LockTableContext) GetAlias() IIdentifierOrTextContext { return s.alias } + +func (s *LockTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *LockTableContext) SetAlias(v IIdentifierOrTextContext) { s.alias = v } + +func (s *LockTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *LockTableContext) READ() antlr.TerminalNode { + return s.GetToken(DorisParserREAD, 0) +} + +func (s *LockTableContext) WRITE() antlr.TerminalNode { + return s.GetToken(DorisParserWRITE, 0) +} + +func (s *LockTableContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *LockTableContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *LockTableContext) LOCAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOCAL, 0) +} + +func (s *LockTableContext) LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(DorisParserLOW_PRIORITY, 0) +} + +func (s *LockTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LockTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLockTable(s) + } +} + +func (s *LockTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLockTable(s) + } +} + +func (s *LockTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLockTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) LockTable() (localctx ILockTableContext) { + localctx = NewLockTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, DorisParserRULE_lockTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3018) + + var _x = p.MultipartIdentifier() + + localctx.(*LockTableContext).name = _x + } + p.SetState(3021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(3019) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3020) + + var _x = p.IdentifierOrText() + + localctx.(*LockTableContext).alias = _x + } + + } + p.SetState(3031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserREAD: + { + p.SetState(3023) + p.Match(DorisParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLOCAL { + { + p.SetState(3024) + p.Match(DorisParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case DorisParserLOW_PRIORITY, DorisParserWRITE: + p.SetState(3028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLOW_PRIORITY { + { + p.SetState(3027) + p.Match(DorisParserLOW_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3030) + p.Match(DorisParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateRoutineLoadContext is an interface to support dynamic dispatch. +type ICreateRoutineLoadContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLabel returns the label rule contexts. + GetLabel() IMultipartIdentifierContext + + // GetTable returns the table rule contexts. + GetTable() IIdentifierContext + + // GetType_ returns the type_ rule contexts. + GetType_() IIdentifierContext + + // GetCustomProperties returns the customProperties rule contexts. + GetCustomProperties() IPropertyItemListContext + + // SetLabel sets the label rule contexts. + SetLabel(IMultipartIdentifierContext) + + // SetTable sets the table rule contexts. + SetTable(IIdentifierContext) + + // SetType_ sets the type_ rule contexts. + SetType_(IIdentifierContext) + + // SetCustomProperties sets the customProperties rule contexts. + SetCustomProperties(IPropertyItemListContext) + + // Getter signatures + CREATE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + LOAD() antlr.TerminalNode + FROM() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + MultipartIdentifier() IMultipartIdentifierContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + PropertyItemList() IPropertyItemListContext + ON() antlr.TerminalNode + WITH() antlr.TerminalNode + AllLoadProperty() []ILoadPropertyContext + LoadProperty(i int) ILoadPropertyContext + PropertyClause() IPropertyClauseContext + CommentSpec() ICommentSpecContext + APPEND() antlr.TerminalNode + DELETE() antlr.TerminalNode + MERGE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreateRoutineLoadContext differentiates from other interfaces. + IsCreateRoutineLoadContext() +} + +type CreateRoutineLoadContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + label IMultipartIdentifierContext + table IIdentifierContext + type_ IIdentifierContext + customProperties IPropertyItemListContext +} + +func NewEmptyCreateRoutineLoadContext() *CreateRoutineLoadContext { + var p = new(CreateRoutineLoadContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_createRoutineLoad + return p +} + +func InitEmptyCreateRoutineLoadContext(p *CreateRoutineLoadContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_createRoutineLoad +} + +func (*CreateRoutineLoadContext) IsCreateRoutineLoadContext() {} + +func NewCreateRoutineLoadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateRoutineLoadContext { + var p = new(CreateRoutineLoadContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_createRoutineLoad + + return p +} + +func (s *CreateRoutineLoadContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateRoutineLoadContext) GetLabel() IMultipartIdentifierContext { return s.label } + +func (s *CreateRoutineLoadContext) GetTable() IIdentifierContext { return s.table } + +func (s *CreateRoutineLoadContext) GetType_() IIdentifierContext { return s.type_ } + +func (s *CreateRoutineLoadContext) GetCustomProperties() IPropertyItemListContext { + return s.customProperties +} + +func (s *CreateRoutineLoadContext) SetLabel(v IMultipartIdentifierContext) { s.label = v } + +func (s *CreateRoutineLoadContext) SetTable(v IIdentifierContext) { s.table = v } + +func (s *CreateRoutineLoadContext) SetType_(v IIdentifierContext) { s.type_ = v } + +func (s *CreateRoutineLoadContext) SetCustomProperties(v IPropertyItemListContext) { + s.customProperties = v +} + +func (s *CreateRoutineLoadContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateRoutineLoadContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *CreateRoutineLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *CreateRoutineLoadContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CreateRoutineLoadContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CreateRoutineLoadContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CreateRoutineLoadContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CreateRoutineLoadContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CreateRoutineLoadContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateRoutineLoadContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *CreateRoutineLoadContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *CreateRoutineLoadContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *CreateRoutineLoadContext) AllLoadProperty() []ILoadPropertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILoadPropertyContext); ok { + len++ + } + } + + tst := make([]ILoadPropertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILoadPropertyContext); ok { + tst[i] = t.(ILoadPropertyContext) + i++ + } + } + + return tst +} + +func (s *CreateRoutineLoadContext) LoadProperty(i int) ILoadPropertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadPropertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILoadPropertyContext) +} + +func (s *CreateRoutineLoadContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *CreateRoutineLoadContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *CreateRoutineLoadContext) APPEND() antlr.TerminalNode { + return s.GetToken(DorisParserAPPEND, 0) +} + +func (s *CreateRoutineLoadContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *CreateRoutineLoadContext) MERGE() antlr.TerminalNode { + return s.GetToken(DorisParserMERGE, 0) +} + +func (s *CreateRoutineLoadContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CreateRoutineLoadContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CreateRoutineLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRoutineLoadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateRoutineLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateRoutineLoad(s) + } +} + +func (s *CreateRoutineLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateRoutineLoad(s) + } +} + +func (s *CreateRoutineLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateRoutineLoad(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) CreateRoutineLoad() (localctx ICreateRoutineLoadContext) { + localctx = NewCreateRoutineLoadContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, DorisParserRULE_createRoutineLoad) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3033) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3034) + p.Match(DorisParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3035) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3036) + + var _x = p.MultipartIdentifier() + + localctx.(*CreateRoutineLoadContext).label = _x + } + p.SetState(3039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(3037) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3038) + + var _x = p.Identifier() + + localctx.(*CreateRoutineLoadContext).table = _x + } + + } + p.SetState(3043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(3041) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3042) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAPPEND || _la == DorisParserDELETE || _la == DorisParserMERGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOLUMNS || _la == DorisParserDELETE || ((int64((_la-338)) & ^0x3f) == 0 && ((int64(1)<<(_la-338))&1073742209) != 0) || _la == DorisParserTEMPORARY || _la == DorisParserWHERE { + { + p.SetState(3045) + p.LoadProperty() + } + p.SetState(3050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3046) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3047) + p.LoadProperty() + } + + p.SetState(3052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(3056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3055) + p.PropertyClause() + } + + } + { + p.SetState(3058) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3059) + + var _x = p.Identifier() + + localctx.(*CreateRoutineLoadContext).type_ = _x + } + { + p.SetState(3060) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3061) + + var _x = p.PropertyItemList() + + localctx.(*CreateRoutineLoadContext).customProperties = _x + } + { + p.SetState(3062) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(3063) + p.CommentSpec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoadPropertyContext is an interface to support dynamic dispatch. +type ILoadPropertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsLoadPropertyContext differentiates from other interfaces. + IsLoadPropertyContext() +} + +type LoadPropertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoadPropertyContext() *LoadPropertyContext { + var p = new(LoadPropertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_loadProperty + return p +} + +func InitEmptyLoadPropertyContext(p *LoadPropertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_loadProperty +} + +func (*LoadPropertyContext) IsLoadPropertyContext() {} + +func NewLoadPropertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadPropertyContext { + var p = new(LoadPropertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_loadProperty + + return p +} + +func (s *LoadPropertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoadPropertyContext) CopyAll(ctx *LoadPropertyContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *LoadPropertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadPropertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ImportPrecedingFilterContext struct { + LoadPropertyContext +} + +func NewImportPrecedingFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportPrecedingFilterContext { + var p = new(ImportPrecedingFilterContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *ImportPrecedingFilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportPrecedingFilterContext) ImportPrecedingFilterStatement() IImportPrecedingFilterStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportPrecedingFilterStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportPrecedingFilterStatementContext) +} + +func (s *ImportPrecedingFilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportPrecedingFilter(s) + } +} + +func (s *ImportPrecedingFilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportPrecedingFilter(s) + } +} + +func (s *ImportPrecedingFilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportPrecedingFilter(s) + + default: + return t.VisitChildren(s) + } +} + +type ImportSequenceContext struct { + LoadPropertyContext +} + +func NewImportSequenceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportSequenceContext { + var p = new(ImportSequenceContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *ImportSequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportSequenceContext) ImportSequenceStatement() IImportSequenceStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportSequenceStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportSequenceStatementContext) +} + +func (s *ImportSequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportSequence(s) + } +} + +func (s *ImportSequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportSequence(s) + } +} + +func (s *ImportSequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportSequence(s) + + default: + return t.VisitChildren(s) + } +} + +type ImportColumnsContext struct { + LoadPropertyContext +} + +func NewImportColumnsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportColumnsContext { + var p = new(ImportColumnsContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *ImportColumnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportColumnsContext) ImportColumnsStatement() IImportColumnsStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportColumnsStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportColumnsStatementContext) +} + +func (s *ImportColumnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportColumns(s) + } +} + +func (s *ImportColumnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportColumns(s) + } +} + +func (s *ImportColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportColumns(s) + + default: + return t.VisitChildren(s) + } +} + +type ImportWhereContext struct { + LoadPropertyContext +} + +func NewImportWhereContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportWhereContext { + var p = new(ImportWhereContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *ImportWhereContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportWhereContext) ImportWhereStatement() IImportWhereStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportWhereStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportWhereStatementContext) +} + +func (s *ImportWhereContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportWhere(s) + } +} + +func (s *ImportWhereContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportWhere(s) + } +} + +func (s *ImportWhereContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportWhere(s) + + default: + return t.VisitChildren(s) + } +} + +type SeparatorContext struct { + LoadPropertyContext +} + +func NewSeparatorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SeparatorContext { + var p = new(SeparatorContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *SeparatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SeparatorContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *SeparatorContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(DorisParserTERMINATED, 0) +} + +func (s *SeparatorContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *SeparatorContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *SeparatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSeparator(s) + } +} + +func (s *SeparatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSeparator(s) + } +} + +func (s *SeparatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSeparator(s) + + default: + return t.VisitChildren(s) + } +} + +type ImportPartitionsContext struct { + LoadPropertyContext +} + +func NewImportPartitionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportPartitionsContext { + var p = new(ImportPartitionsContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *ImportPartitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportPartitionsContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *ImportPartitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportPartitions(s) + } +} + +func (s *ImportPartitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportPartitions(s) + } +} + +func (s *ImportPartitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportPartitions(s) + + default: + return t.VisitChildren(s) + } +} + +type ImportDeleteOnContext struct { + LoadPropertyContext +} + +func NewImportDeleteOnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ImportDeleteOnContext { + var p = new(ImportDeleteOnContext) + + InitEmptyLoadPropertyContext(&p.LoadPropertyContext) + p.parser = parser + p.CopyAll(ctx.(*LoadPropertyContext)) + + return p +} + +func (s *ImportDeleteOnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportDeleteOnContext) ImportDeleteOnStatement() IImportDeleteOnStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportDeleteOnStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportDeleteOnStatementContext) +} + +func (s *ImportDeleteOnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportDeleteOn(s) + } +} + +func (s *ImportDeleteOnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportDeleteOn(s) + } +} + +func (s *ImportDeleteOnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportDeleteOn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) LoadProperty() (localctx ILoadPropertyContext) { + localctx = NewLoadPropertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, DorisParserRULE_loadProperty) + p.SetState(3076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 415, p.GetParserRuleContext()) { + case 1: + localctx = NewSeparatorContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3066) + p.Match(DorisParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3067) + p.Match(DorisParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3068) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3069) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewImportColumnsContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3070) + p.ImportColumnsStatement() + } + + case 3: + localctx = NewImportPrecedingFilterContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3071) + p.ImportPrecedingFilterStatement() + } + + case 4: + localctx = NewImportWhereContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3072) + p.ImportWhereStatement() + } + + case 5: + localctx = NewImportDeleteOnContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3073) + p.ImportDeleteOnStatement() + } + + case 6: + localctx = NewImportSequenceContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3074) + p.ImportSequenceStatement() + } + + case 7: + localctx = NewImportPartitionsContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3075) + p.PartitionSpec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportSequenceStatementContext is an interface to support dynamic dispatch. +type IImportSequenceStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsImportSequenceStatementContext differentiates from other interfaces. + IsImportSequenceStatementContext() +} + +type ImportSequenceStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportSequenceStatementContext() *ImportSequenceStatementContext { + var p = new(ImportSequenceStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importSequenceStatement + return p +} + +func InitEmptyImportSequenceStatementContext(p *ImportSequenceStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importSequenceStatement +} + +func (*ImportSequenceStatementContext) IsImportSequenceStatementContext() {} + +func NewImportSequenceStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportSequenceStatementContext { + var p = new(ImportSequenceStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_importSequenceStatement + + return p +} + +func (s *ImportSequenceStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportSequenceStatementContext) ORDER() antlr.TerminalNode { + return s.GetToken(DorisParserORDER, 0) +} + +func (s *ImportSequenceStatementContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *ImportSequenceStatementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ImportSequenceStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportSequenceStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportSequenceStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportSequenceStatement(s) + } +} + +func (s *ImportSequenceStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportSequenceStatement(s) + } +} + +func (s *ImportSequenceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportSequenceStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ImportSequenceStatement() (localctx IImportSequenceStatementContext) { + localctx = NewImportSequenceStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, DorisParserRULE_importSequenceStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3078) + p.Match(DorisParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3079) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3080) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportDeleteOnStatementContext is an interface to support dynamic dispatch. +type IImportDeleteOnStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + ON() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + + // IsImportDeleteOnStatementContext differentiates from other interfaces. + IsImportDeleteOnStatementContext() +} + +type ImportDeleteOnStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportDeleteOnStatementContext() *ImportDeleteOnStatementContext { + var p = new(ImportDeleteOnStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importDeleteOnStatement + return p +} + +func InitEmptyImportDeleteOnStatementContext(p *ImportDeleteOnStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importDeleteOnStatement +} + +func (*ImportDeleteOnStatementContext) IsImportDeleteOnStatementContext() {} + +func NewImportDeleteOnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportDeleteOnStatementContext { + var p = new(ImportDeleteOnStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_importDeleteOnStatement + + return p +} + +func (s *ImportDeleteOnStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportDeleteOnStatementContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *ImportDeleteOnStatementContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ImportDeleteOnStatementContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *ImportDeleteOnStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportDeleteOnStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportDeleteOnStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportDeleteOnStatement(s) + } +} + +func (s *ImportDeleteOnStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportDeleteOnStatement(s) + } +} + +func (s *ImportDeleteOnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportDeleteOnStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ImportDeleteOnStatement() (localctx IImportDeleteOnStatementContext) { + localctx = NewImportDeleteOnStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, DorisParserRULE_importDeleteOnStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3082) + p.Match(DorisParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3083) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3084) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportWhereStatementContext is an interface to support dynamic dispatch. +type IImportWhereStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + + // IsImportWhereStatementContext differentiates from other interfaces. + IsImportWhereStatementContext() +} + +type ImportWhereStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportWhereStatementContext() *ImportWhereStatementContext { + var p = new(ImportWhereStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importWhereStatement + return p +} + +func InitEmptyImportWhereStatementContext(p *ImportWhereStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importWhereStatement +} + +func (*ImportWhereStatementContext) IsImportWhereStatementContext() {} + +func NewImportWhereStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportWhereStatementContext { + var p = new(ImportWhereStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_importWhereStatement + + return p +} + +func (s *ImportWhereStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportWhereStatementContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *ImportWhereStatementContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *ImportWhereStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportWhereStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportWhereStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportWhereStatement(s) + } +} + +func (s *ImportWhereStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportWhereStatement(s) + } +} + +func (s *ImportWhereStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportWhereStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ImportWhereStatement() (localctx IImportWhereStatementContext) { + localctx = NewImportWhereStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, DorisParserRULE_importWhereStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3086) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3087) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportPrecedingFilterStatementContext is an interface to support dynamic dispatch. +type IImportPrecedingFilterStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRECEDING() antlr.TerminalNode + FILTER() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + + // IsImportPrecedingFilterStatementContext differentiates from other interfaces. + IsImportPrecedingFilterStatementContext() +} + +type ImportPrecedingFilterStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportPrecedingFilterStatementContext() *ImportPrecedingFilterStatementContext { + var p = new(ImportPrecedingFilterStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importPrecedingFilterStatement + return p +} + +func InitEmptyImportPrecedingFilterStatementContext(p *ImportPrecedingFilterStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importPrecedingFilterStatement +} + +func (*ImportPrecedingFilterStatementContext) IsImportPrecedingFilterStatementContext() {} + +func NewImportPrecedingFilterStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportPrecedingFilterStatementContext { + var p = new(ImportPrecedingFilterStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_importPrecedingFilterStatement + + return p +} + +func (s *ImportPrecedingFilterStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportPrecedingFilterStatementContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(DorisParserPRECEDING, 0) +} + +func (s *ImportPrecedingFilterStatementContext) FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserFILTER, 0) +} + +func (s *ImportPrecedingFilterStatementContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *ImportPrecedingFilterStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportPrecedingFilterStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportPrecedingFilterStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportPrecedingFilterStatement(s) + } +} + +func (s *ImportPrecedingFilterStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportPrecedingFilterStatement(s) + } +} + +func (s *ImportPrecedingFilterStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportPrecedingFilterStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ImportPrecedingFilterStatement() (localctx IImportPrecedingFilterStatementContext) { + localctx = NewImportPrecedingFilterStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, DorisParserRULE_importPrecedingFilterStatement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3089) + p.Match(DorisParserPRECEDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3090) + p.Match(DorisParserFILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3091) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportColumnsStatementContext is an interface to support dynamic dispatch. +type IImportColumnsStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMNS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllImportColumnDesc() []IImportColumnDescContext + ImportColumnDesc(i int) IImportColumnDescContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsImportColumnsStatementContext differentiates from other interfaces. + IsImportColumnsStatementContext() +} + +type ImportColumnsStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportColumnsStatementContext() *ImportColumnsStatementContext { + var p = new(ImportColumnsStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importColumnsStatement + return p +} + +func InitEmptyImportColumnsStatementContext(p *ImportColumnsStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importColumnsStatement +} + +func (*ImportColumnsStatementContext) IsImportColumnsStatementContext() {} + +func NewImportColumnsStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportColumnsStatementContext { + var p = new(ImportColumnsStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_importColumnsStatement + + return p +} + +func (s *ImportColumnsStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportColumnsStatementContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *ImportColumnsStatementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ImportColumnsStatementContext) AllImportColumnDesc() []IImportColumnDescContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IImportColumnDescContext); ok { + len++ + } + } + + tst := make([]IImportColumnDescContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IImportColumnDescContext); ok { + tst[i] = t.(IImportColumnDescContext) + i++ + } + } + + return tst +} + +func (s *ImportColumnsStatementContext) ImportColumnDesc(i int) IImportColumnDescContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportColumnDescContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IImportColumnDescContext) +} + +func (s *ImportColumnsStatementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ImportColumnsStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ImportColumnsStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ImportColumnsStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportColumnsStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportColumnsStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportColumnsStatement(s) + } +} + +func (s *ImportColumnsStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportColumnsStatement(s) + } +} + +func (s *ImportColumnsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportColumnsStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ImportColumnsStatement() (localctx IImportColumnsStatementContext) { + localctx = NewImportColumnsStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, DorisParserRULE_importColumnsStatement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3093) + p.Match(DorisParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3094) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3095) + p.ImportColumnDesc() + } + p.SetState(3100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3096) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3097) + p.ImportColumnDesc() + } + + p.SetState(3102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3103) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportColumnDescContext is an interface to support dynamic dispatch. +type IImportColumnDescContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // Getter signatures + Identifier() IIdentifierContext + EQ() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsImportColumnDescContext differentiates from other interfaces. + IsImportColumnDescContext() +} + +type ImportColumnDescContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext +} + +func NewEmptyImportColumnDescContext() *ImportColumnDescContext { + var p = new(ImportColumnDescContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importColumnDesc + return p +} + +func InitEmptyImportColumnDescContext(p *ImportColumnDescContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_importColumnDesc +} + +func (*ImportColumnDescContext) IsImportColumnDescContext() {} + +func NewImportColumnDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportColumnDescContext { + var p = new(ImportColumnDescContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_importColumnDesc + + return p +} + +func (s *ImportColumnDescContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportColumnDescContext) GetName() IIdentifierContext { return s.name } + +func (s *ImportColumnDescContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ImportColumnDescContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ImportColumnDescContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *ImportColumnDescContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *ImportColumnDescContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ImportColumnDescContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ImportColumnDescContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportColumnDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportColumnDescContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterImportColumnDesc(s) + } +} + +func (s *ImportColumnDescContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitImportColumnDesc(s) + } +} + +func (s *ImportColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitImportColumnDesc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ImportColumnDesc() (localctx IImportColumnDescContext) { + localctx = NewImportColumnDescContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, DorisParserRULE_importColumnDesc) + var _la int + + p.SetState(3118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3105) + + var _x = p.Identifier() + + localctx.(*ImportColumnDescContext).name = _x + } + p.SetState(3108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEQ { + { + p.SetState(3106) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3107) + p.booleanExpression(0) + } + + } + + case DorisParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3110) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3111) + + var _x = p.Identifier() + + localctx.(*ImportColumnDescContext).name = _x + } + p.SetState(3114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEQ { + { + p.SetState(3112) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3113) + p.booleanExpression(0) + } + + } + { + p.SetState(3116) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedRefreshStatementContext is an interface to support dynamic dispatch. +type ISupportedRefreshStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedRefreshStatementContext differentiates from other interfaces. + IsSupportedRefreshStatementContext() +} + +type SupportedRefreshStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedRefreshStatementContext() *SupportedRefreshStatementContext { + var p = new(SupportedRefreshStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedRefreshStatement + return p +} + +func InitEmptySupportedRefreshStatementContext(p *SupportedRefreshStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedRefreshStatement +} + +func (*SupportedRefreshStatementContext) IsSupportedRefreshStatementContext() {} + +func NewSupportedRefreshStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedRefreshStatementContext { + var p = new(SupportedRefreshStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedRefreshStatement + + return p +} + +func (s *SupportedRefreshStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedRefreshStatementContext) CopyAll(ctx *SupportedRefreshStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedRefreshStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedRefreshStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type RefreshCatalogContext struct { + SupportedRefreshStatementContext + name IIdentifierContext +} + +func NewRefreshCatalogContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RefreshCatalogContext { + var p = new(RefreshCatalogContext) + + InitEmptySupportedRefreshStatementContext(&p.SupportedRefreshStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRefreshStatementContext)) + + return p +} + +func (s *RefreshCatalogContext) GetName() IIdentifierContext { return s.name } + +func (s *RefreshCatalogContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *RefreshCatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshCatalogContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *RefreshCatalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *RefreshCatalogContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RefreshCatalogContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *RefreshCatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshCatalog(s) + } +} + +func (s *RefreshCatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshCatalog(s) + } +} + +func (s *RefreshCatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshCatalog(s) + + default: + return t.VisitChildren(s) + } +} + +type RefreshDictionaryContext struct { + SupportedRefreshStatementContext + name IMultipartIdentifierContext +} + +func NewRefreshDictionaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RefreshDictionaryContext { + var p = new(RefreshDictionaryContext) + + InitEmptySupportedRefreshStatementContext(&p.SupportedRefreshStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRefreshStatementContext)) + + return p +} + +func (s *RefreshDictionaryContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *RefreshDictionaryContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *RefreshDictionaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshDictionaryContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *RefreshDictionaryContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARY, 0) +} + +func (s *RefreshDictionaryContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RefreshDictionaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshDictionary(s) + } +} + +func (s *RefreshDictionaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshDictionary(s) + } +} + +func (s *RefreshDictionaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshDictionary(s) + + default: + return t.VisitChildren(s) + } +} + +type RefreshDatabaseContext struct { + SupportedRefreshStatementContext + name IMultipartIdentifierContext +} + +func NewRefreshDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RefreshDatabaseContext { + var p = new(RefreshDatabaseContext) + + InitEmptySupportedRefreshStatementContext(&p.SupportedRefreshStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRefreshStatementContext)) + + return p +} + +func (s *RefreshDatabaseContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *RefreshDatabaseContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *RefreshDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshDatabaseContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *RefreshDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *RefreshDatabaseContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RefreshDatabaseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *RefreshDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshDatabase(s) + } +} + +func (s *RefreshDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshDatabase(s) + } +} + +func (s *RefreshDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +type RefreshTableContext struct { + SupportedRefreshStatementContext + name IMultipartIdentifierContext +} + +func NewRefreshTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RefreshTableContext { + var p = new(RefreshTableContext) + + InitEmptySupportedRefreshStatementContext(&p.SupportedRefreshStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRefreshStatementContext)) + + return p +} + +func (s *RefreshTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *RefreshTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *RefreshTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshTableContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *RefreshTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *RefreshTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RefreshTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshTable(s) + } +} + +func (s *RefreshTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshTable(s) + } +} + +func (s *RefreshTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshTable(s) + + default: + return t.VisitChildren(s) + } +} + +type RefreshLdapContext struct { + SupportedRefreshStatementContext + user IIdentifierOrTextContext +} + +func NewRefreshLdapContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RefreshLdapContext { + var p = new(RefreshLdapContext) + + InitEmptySupportedRefreshStatementContext(&p.SupportedRefreshStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRefreshStatementContext)) + + return p +} + +func (s *RefreshLdapContext) GetUser() IIdentifierOrTextContext { return s.user } + +func (s *RefreshLdapContext) SetUser(v IIdentifierOrTextContext) { s.user = v } + +func (s *RefreshLdapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshLdapContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *RefreshLdapContext) LDAP() antlr.TerminalNode { + return s.GetToken(DorisParserLDAP, 0) +} + +func (s *RefreshLdapContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *RefreshLdapContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *RefreshLdapContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *RefreshLdapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshLdap(s) + } +} + +func (s *RefreshLdapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshLdap(s) + } +} + +func (s *RefreshLdapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshLdap(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedRefreshStatement() (localctx ISupportedRefreshStatementContext) { + localctx = NewSupportedRefreshStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, DorisParserRULE_supportedRefreshStatement) + var _la int + + p.SetState(3145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 423, p.GetParserRuleContext()) { + case 1: + localctx = NewRefreshCatalogContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3120) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3121) + p.Match(DorisParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3122) + + var _x = p.Identifier() + + localctx.(*RefreshCatalogContext).name = _x + } + p.SetState(3124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3123) + p.PropertyClause() + } + + } + + case 2: + localctx = NewRefreshDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3126) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3127) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3128) + + var _x = p.MultipartIdentifier() + + localctx.(*RefreshDatabaseContext).name = _x + } + p.SetState(3130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3129) + p.PropertyClause() + } + + } + + case 3: + localctx = NewRefreshTableContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3132) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3133) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3134) + + var _x = p.MultipartIdentifier() + + localctx.(*RefreshTableContext).name = _x + } + + case 4: + localctx = NewRefreshDictionaryContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3135) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3136) + p.Match(DorisParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3137) + + var _x = p.MultipartIdentifier() + + localctx.(*RefreshDictionaryContext).name = _x + } + + case 5: + localctx = NewRefreshLdapContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3138) + p.Match(DorisParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3139) + p.Match(DorisParserLDAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserALL: + { + p.SetState(3140) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserFOR: + { + p.SetState(3141) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3142) + + var _x = p.IdentifierOrText() + + localctx.(*RefreshLdapContext).user = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedCleanStatementContext is an interface to support dynamic dispatch. +type ISupportedCleanStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedCleanStatementContext differentiates from other interfaces. + IsSupportedCleanStatementContext() +} + +type SupportedCleanStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedCleanStatementContext() *SupportedCleanStatementContext { + var p = new(SupportedCleanStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedCleanStatement + return p +} + +func InitEmptySupportedCleanStatementContext(p *SupportedCleanStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedCleanStatement +} + +func (*SupportedCleanStatementContext) IsSupportedCleanStatementContext() {} + +func NewSupportedCleanStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedCleanStatementContext { + var p = new(SupportedCleanStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedCleanStatement + + return p +} + +func (s *SupportedCleanStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedCleanStatementContext) CopyAll(ctx *SupportedCleanStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedCleanStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedCleanStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CleanLabelContext struct { + SupportedCleanStatementContext + label IIdentifierContext + database IIdentifierContext +} + +func NewCleanLabelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CleanLabelContext { + var p = new(CleanLabelContext) + + InitEmptySupportedCleanStatementContext(&p.SupportedCleanStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCleanStatementContext)) + + return p +} + +func (s *CleanLabelContext) GetLabel() IIdentifierContext { return s.label } + +func (s *CleanLabelContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CleanLabelContext) SetLabel(v IIdentifierContext) { s.label = v } + +func (s *CleanLabelContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CleanLabelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CleanLabelContext) CLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserCLEAN, 0) +} + +func (s *CleanLabelContext) LABEL() antlr.TerminalNode { + return s.GetToken(DorisParserLABEL, 0) +} + +func (s *CleanLabelContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CleanLabelContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CleanLabelContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CleanLabelContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CleanLabelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCleanLabel(s) + } +} + +func (s *CleanLabelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCleanLabel(s) + } +} + +func (s *CleanLabelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCleanLabel(s) + + default: + return t.VisitChildren(s) + } +} + +type CleanQueryStatsContext struct { + SupportedCleanStatementContext + database IIdentifierContext + table IMultipartIdentifierContext +} + +func NewCleanQueryStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CleanQueryStatsContext { + var p = new(CleanQueryStatsContext) + + InitEmptySupportedCleanStatementContext(&p.SupportedCleanStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCleanStatementContext)) + + return p +} + +func (s *CleanQueryStatsContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CleanQueryStatsContext) GetTable() IMultipartIdentifierContext { return s.table } + +func (s *CleanQueryStatsContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CleanQueryStatsContext) SetTable(v IMultipartIdentifierContext) { s.table = v } + +func (s *CleanQueryStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CleanQueryStatsContext) CLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserCLEAN, 0) +} + +func (s *CleanQueryStatsContext) QUERY() antlr.TerminalNode { + return s.GetToken(DorisParserQUERY, 0) +} + +func (s *CleanQueryStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *CleanQueryStatsContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *CleanQueryStatsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CleanQueryStatsContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CleanQueryStatsContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CleanQueryStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CleanQueryStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCleanQueryStats(s) + } +} + +func (s *CleanQueryStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCleanQueryStats(s) + } +} + +func (s *CleanQueryStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCleanQueryStats(s) + + default: + return t.VisitChildren(s) + } +} + +type CleanAllProfileContext struct { + SupportedCleanStatementContext +} + +func NewCleanAllProfileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CleanAllProfileContext { + var p = new(CleanAllProfileContext) + + InitEmptySupportedCleanStatementContext(&p.SupportedCleanStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCleanStatementContext)) + + return p +} + +func (s *CleanAllProfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CleanAllProfileContext) CLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserCLEAN, 0) +} + +func (s *CleanAllProfileContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *CleanAllProfileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(DorisParserPROFILE, 0) +} + +func (s *CleanAllProfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCleanAllProfile(s) + } +} + +func (s *CleanAllProfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCleanAllProfile(s) + } +} + +func (s *CleanAllProfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCleanAllProfile(s) + + default: + return t.VisitChildren(s) + } +} + +type CleanAllQueryStatsContext struct { + SupportedCleanStatementContext +} + +func NewCleanAllQueryStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CleanAllQueryStatsContext { + var p = new(CleanAllQueryStatsContext) + + InitEmptySupportedCleanStatementContext(&p.SupportedCleanStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCleanStatementContext)) + + return p +} + +func (s *CleanAllQueryStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CleanAllQueryStatsContext) CLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserCLEAN, 0) +} + +func (s *CleanAllQueryStatsContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *CleanAllQueryStatsContext) QUERY() antlr.TerminalNode { + return s.GetToken(DorisParserQUERY, 0) +} + +func (s *CleanAllQueryStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *CleanAllQueryStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCleanAllQueryStats(s) + } +} + +func (s *CleanAllQueryStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCleanAllQueryStats(s) + } +} + +func (s *CleanAllQueryStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCleanAllQueryStats(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedCleanStatement() (localctx ISupportedCleanStatementContext) { + localctx = NewSupportedCleanStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, DorisParserRULE_supportedCleanStatement) + var _la int + + p.SetState(3170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) { + case 1: + localctx = NewCleanAllProfileContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3147) + p.Match(DorisParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3148) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3149) + p.Match(DorisParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewCleanLabelContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3150) + p.Match(DorisParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3151) + p.Match(DorisParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(3152) + + var _x = p.Identifier() + + localctx.(*CleanLabelContext).label = _x + } + + } + { + p.SetState(3155) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3156) + + var _x = p.Identifier() + + localctx.(*CleanLabelContext).database = _x + } + + case 3: + localctx = NewCleanQueryStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3157) + p.Match(DorisParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3158) + p.Match(DorisParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3159) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserFOR: + { + p.SetState(3160) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3161) + + var _x = p.Identifier() + + localctx.(*CleanQueryStatsContext).database = _x + } + + case DorisParserFROM, DorisParserIN: + { + p.SetState(3162) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3163) + + var _x = p.MultipartIdentifier() + + localctx.(*CleanQueryStatsContext).table = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + localctx = NewCleanAllQueryStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3166) + p.Match(DorisParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3167) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3168) + p.Match(DorisParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3169) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedCancelStatementContext is an interface to support dynamic dispatch. +type ISupportedCancelStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedCancelStatementContext differentiates from other interfaces. + IsSupportedCancelStatementContext() +} + +type SupportedCancelStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedCancelStatementContext() *SupportedCancelStatementContext { + var p = new(SupportedCancelStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedCancelStatement + return p +} + +func InitEmptySupportedCancelStatementContext(p *SupportedCancelStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedCancelStatement +} + +func (*SupportedCancelStatementContext) IsSupportedCancelStatementContext() {} + +func NewSupportedCancelStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedCancelStatementContext { + var p = new(SupportedCancelStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedCancelStatement + + return p +} + +func (s *SupportedCancelStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedCancelStatementContext) CopyAll(ctx *SupportedCancelStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedCancelStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedCancelStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type CancelBackupContext struct { + SupportedCancelStatementContext + database IIdentifierContext +} + +func NewCancelBackupContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelBackupContext { + var p = new(CancelBackupContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelBackupContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CancelBackupContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CancelBackupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelBackupContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelBackupContext) BACKUP() antlr.TerminalNode { + return s.GetToken(DorisParserBACKUP, 0) +} + +func (s *CancelBackupContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CancelBackupContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CancelBackupContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CancelBackupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelBackup(s) + } +} + +func (s *CancelBackupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelBackup(s) + } +} + +func (s *CancelBackupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelBackup(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelWarmUpJobContext struct { + SupportedCancelStatementContext +} + +func NewCancelWarmUpJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelWarmUpJobContext { + var p = new(CancelWarmUpJobContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelWarmUpJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelWarmUpJobContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelWarmUpJobContext) WARM() antlr.TerminalNode { + return s.GetToken(DorisParserWARM, 0) +} + +func (s *CancelWarmUpJobContext) UP() antlr.TerminalNode { + return s.GetToken(DorisParserUP, 0) +} + +func (s *CancelWarmUpJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *CancelWarmUpJobContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *CancelWarmUpJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelWarmUpJob(s) + } +} + +func (s *CancelWarmUpJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelWarmUpJob(s) + } +} + +func (s *CancelWarmUpJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelWarmUpJob(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelExportContext struct { + SupportedCancelStatementContext + database IIdentifierContext +} + +func NewCancelExportContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelExportContext { + var p = new(CancelExportContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelExportContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CancelExportContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CancelExportContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelExportContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelExportContext) EXPORT() antlr.TerminalNode { + return s.GetToken(DorisParserEXPORT, 0) +} + +func (s *CancelExportContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *CancelExportContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CancelExportContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CancelExportContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CancelExportContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelExport(s) + } +} + +func (s *CancelExportContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelExport(s) + } +} + +func (s *CancelExportContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelExport(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelBuildIndexContext struct { + SupportedCancelStatementContext + tableName IMultipartIdentifierContext + _INTEGER_VALUE antlr.Token + jobIds []antlr.Token +} + +func NewCancelBuildIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelBuildIndexContext { + var p = new(CancelBuildIndexContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelBuildIndexContext) Get_INTEGER_VALUE() antlr.Token { return s._INTEGER_VALUE } + +func (s *CancelBuildIndexContext) Set_INTEGER_VALUE(v antlr.Token) { s._INTEGER_VALUE = v } + +func (s *CancelBuildIndexContext) GetJobIds() []antlr.Token { return s.jobIds } + +func (s *CancelBuildIndexContext) SetJobIds(v []antlr.Token) { s.jobIds = v } + +func (s *CancelBuildIndexContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *CancelBuildIndexContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *CancelBuildIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelBuildIndexContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelBuildIndexContext) BUILD() antlr.TerminalNode { + return s.GetToken(DorisParserBUILD, 0) +} + +func (s *CancelBuildIndexContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *CancelBuildIndexContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *CancelBuildIndexContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CancelBuildIndexContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CancelBuildIndexContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CancelBuildIndexContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *CancelBuildIndexContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *CancelBuildIndexContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CancelBuildIndexContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CancelBuildIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelBuildIndex(s) + } +} + +func (s *CancelBuildIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelBuildIndex(s) + } +} + +func (s *CancelBuildIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelBuildIndex(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelRestoreContext struct { + SupportedCancelStatementContext + database IIdentifierContext +} + +func NewCancelRestoreContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelRestoreContext { + var p = new(CancelRestoreContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelRestoreContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CancelRestoreContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CancelRestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelRestoreContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelRestoreContext) RESTORE() antlr.TerminalNode { + return s.GetToken(DorisParserRESTORE, 0) +} + +func (s *CancelRestoreContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CancelRestoreContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CancelRestoreContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CancelRestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelRestore(s) + } +} + +func (s *CancelRestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelRestore(s) + } +} + +func (s *CancelRestoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelRestore(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelLoadContext struct { + SupportedCancelStatementContext + database IIdentifierContext +} + +func NewCancelLoadContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelLoadContext { + var p = new(CancelLoadContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelLoadContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *CancelLoadContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *CancelLoadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelLoadContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelLoadContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *CancelLoadContext) WildWhere() IWildWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWildWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWildWhereContext) +} + +func (s *CancelLoadContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CancelLoadContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *CancelLoadContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CancelLoadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelLoad(s) + } +} + +func (s *CancelLoadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelLoad(s) + } +} + +func (s *CancelLoadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelLoad(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelDecommisionBackendContext struct { + SupportedCancelStatementContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token +} + +func NewCancelDecommisionBackendContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelDecommisionBackendContext { + var p = new(CancelDecommisionBackendContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelDecommisionBackendContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *CancelDecommisionBackendContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *CancelDecommisionBackendContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *CancelDecommisionBackendContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *CancelDecommisionBackendContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelDecommisionBackendContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelDecommisionBackendContext) DECOMMISSION() antlr.TerminalNode { + return s.GetToken(DorisParserDECOMMISSION, 0) +} + +func (s *CancelDecommisionBackendContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *CancelDecommisionBackendContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *CancelDecommisionBackendContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *CancelDecommisionBackendContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CancelDecommisionBackendContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CancelDecommisionBackendContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelDecommisionBackend(s) + } +} + +func (s *CancelDecommisionBackendContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelDecommisionBackend(s) + } +} + +func (s *CancelDecommisionBackendContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelDecommisionBackend(s) + + default: + return t.VisitChildren(s) + } +} + +type CancelAlterTableContext struct { + SupportedCancelStatementContext + tableName IMultipartIdentifierContext + _INTEGER_VALUE antlr.Token + jobIds []antlr.Token +} + +func NewCancelAlterTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CancelAlterTableContext { + var p = new(CancelAlterTableContext) + + InitEmptySupportedCancelStatementContext(&p.SupportedCancelStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedCancelStatementContext)) + + return p +} + +func (s *CancelAlterTableContext) Get_INTEGER_VALUE() antlr.Token { return s._INTEGER_VALUE } + +func (s *CancelAlterTableContext) Set_INTEGER_VALUE(v antlr.Token) { s._INTEGER_VALUE = v } + +func (s *CancelAlterTableContext) GetJobIds() []antlr.Token { return s.jobIds } + +func (s *CancelAlterTableContext) SetJobIds(v []antlr.Token) { s.jobIds = v } + +func (s *CancelAlterTableContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *CancelAlterTableContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *CancelAlterTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelAlterTableContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *CancelAlterTableContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *CancelAlterTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *CancelAlterTableContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *CancelAlterTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *CancelAlterTableContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *CancelAlterTableContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *CancelAlterTableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CancelAlterTableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CancelAlterTableContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *CancelAlterTableContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *CancelAlterTableContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *CancelAlterTableContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *CancelAlterTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CancelAlterTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CancelAlterTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCancelAlterTable(s) + } +} + +func (s *CancelAlterTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCancelAlterTable(s) + } +} + +func (s *CancelAlterTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCancelAlterTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedCancelStatement() (localctx ISupportedCancelStatementContext) { + localctx = NewSupportedCancelStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, DorisParserRULE_supportedCancelStatement) + var _la int + + p.SetState(3260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) { + case 1: + localctx = NewCancelLoadContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3172) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3173) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(3174) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3175) + + var _x = p.Identifier() + + localctx.(*CancelLoadContext).database = _x + } + + } + p.SetState(3179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(3178) + p.WildWhere() + } + + } + + case 2: + localctx = NewCancelExportContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3181) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3182) + p.Match(DorisParserEXPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(3183) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3184) + + var _x = p.Identifier() + + localctx.(*CancelExportContext).database = _x + } + + } + p.SetState(3188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(3187) + p.WildWhere() + } + + } + + case 3: + localctx = NewCancelWarmUpJobContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3190) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3191) + p.Match(DorisParserWARM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3192) + p.Match(DorisParserUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3193) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIKE || _la == DorisParserWHERE { + { + p.SetState(3194) + p.WildWhere() + } + + } + + case 4: + localctx = NewCancelDecommisionBackendContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3197) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3198) + p.Match(DorisParserDECOMMISSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3199) + p.Match(DorisParserBACKEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3200) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CancelDecommisionBackendContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*CancelDecommisionBackendContext).hostPorts = append(localctx.(*CancelDecommisionBackendContext).hostPorts, localctx.(*CancelDecommisionBackendContext)._STRING_LITERAL) + p.SetState(3205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3201) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3202) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*CancelDecommisionBackendContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*CancelDecommisionBackendContext).hostPorts = append(localctx.(*CancelDecommisionBackendContext).hostPorts, localctx.(*CancelDecommisionBackendContext)._STRING_LITERAL) + + p.SetState(3207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 5: + localctx = NewCancelBackupContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3208) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3209) + p.Match(DorisParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(3210) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3211) + + var _x = p.Identifier() + + localctx.(*CancelBackupContext).database = _x + } + + } + + case 6: + localctx = NewCancelRestoreContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3214) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3215) + p.Match(DorisParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserIN { + { + p.SetState(3216) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFROM || _la == DorisParserIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3217) + + var _x = p.Identifier() + + localctx.(*CancelRestoreContext).database = _x + } + + } + + case 7: + localctx = NewCancelBuildIndexContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3220) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3221) + p.Match(DorisParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3222) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3223) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3224) + + var _x = p.MultipartIdentifier() + + localctx.(*CancelBuildIndexContext).tableName = _x + } + p.SetState(3235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(3225) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3226) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CancelBuildIndexContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*CancelBuildIndexContext).jobIds = append(localctx.(*CancelBuildIndexContext).jobIds, localctx.(*CancelBuildIndexContext)._INTEGER_VALUE) + p.SetState(3231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3227) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3228) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CancelBuildIndexContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*CancelBuildIndexContext).jobIds = append(localctx.(*CancelBuildIndexContext).jobIds, localctx.(*CancelBuildIndexContext)._INTEGER_VALUE) + + p.SetState(3233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3234) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 8: + localctx = NewCancelAlterTableContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3237) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3238) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3239) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserROLLUP: + { + p.SetState(3240) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserMATERIALIZED: + { + p.SetState(3241) + p.Match(DorisParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3242) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOLUMN: + { + p.SetState(3243) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3246) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3247) + + var _x = p.MultipartIdentifier() + + localctx.(*CancelAlterTableContext).tableName = _x + } + p.SetState(3258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(3248) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3249) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CancelAlterTableContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*CancelAlterTableContext).jobIds = append(localctx.(*CancelAlterTableContext).jobIds, localctx.(*CancelAlterTableContext)._INTEGER_VALUE) + p.SetState(3254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3250) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3251) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*CancelAlterTableContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*CancelAlterTableContext).jobIds = append(localctx.(*CancelAlterTableContext).jobIds, localctx.(*CancelAlterTableContext)._INTEGER_VALUE) + + p.SetState(3256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3257) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedAdminStatementContext is an interface to support dynamic dispatch. +type ISupportedAdminStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedAdminStatementContext differentiates from other interfaces. + IsSupportedAdminStatementContext() +} + +type SupportedAdminStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedAdminStatementContext() *SupportedAdminStatementContext { + var p = new(SupportedAdminStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedAdminStatement + return p +} + +func InitEmptySupportedAdminStatementContext(p *SupportedAdminStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedAdminStatement +} + +func (*SupportedAdminStatementContext) IsSupportedAdminStatementContext() {} + +func NewSupportedAdminStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedAdminStatementContext { + var p = new(SupportedAdminStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedAdminStatement + + return p +} + +func (s *SupportedAdminStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedAdminStatementContext) CopyAll(ctx *SupportedAdminStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedAdminStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedAdminStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type AdminShowReplicaDistributionContext struct { + SupportedAdminStatementContext +} + +func NewAdminShowReplicaDistributionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminShowReplicaDistributionContext { + var p = new(AdminShowReplicaDistributionContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminShowReplicaDistributionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminShowReplicaDistributionContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminShowReplicaDistributionContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *AdminShowReplicaDistributionContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *AdminShowReplicaDistributionContext) DISTRIBUTION() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTION, 0) +} + +func (s *AdminShowReplicaDistributionContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *AdminShowReplicaDistributionContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *AdminShowReplicaDistributionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminShowReplicaDistribution(s) + } +} + +func (s *AdminShowReplicaDistributionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminShowReplicaDistribution(s) + } +} + +func (s *AdminShowReplicaDistributionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminShowReplicaDistribution(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminShowTabletStorageFormatContext struct { + SupportedAdminStatementContext +} + +func NewAdminShowTabletStorageFormatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminShowTabletStorageFormatContext { + var p = new(AdminShowTabletStorageFormatContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminShowTabletStorageFormatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminShowTabletStorageFormatContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminShowTabletStorageFormatContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *AdminShowTabletStorageFormatContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *AdminShowTabletStorageFormatContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *AdminShowTabletStorageFormatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserFORMAT, 0) +} + +func (s *AdminShowTabletStorageFormatContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(DorisParserVERBOSE, 0) +} + +func (s *AdminShowTabletStorageFormatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminShowTabletStorageFormat(s) + } +} + +func (s *AdminShowTabletStorageFormatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminShowTabletStorageFormat(s) + } +} + +func (s *AdminShowTabletStorageFormatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminShowTabletStorageFormat(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetClusterSnapshotFeatureSwitchContext struct { + SupportedAdminStatementContext +} + +func NewAdminSetClusterSnapshotFeatureSwitchContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetClusterSnapshotFeatureSwitchContext { + var p = new(AdminSetClusterSnapshotFeatureSwitchContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) FEATURE() antlr.TerminalNode { + return s.GetToken(DorisParserFEATURE, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) OFF() antlr.TerminalNode { + return s.GetToken(DorisParserOFF, 0) +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetClusterSnapshotFeatureSwitch(s) + } +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetClusterSnapshotFeatureSwitch(s) + } +} + +func (s *AdminSetClusterSnapshotFeatureSwitchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetClusterSnapshotFeatureSwitch(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminRebalanceDiskContext struct { + SupportedAdminStatementContext + _STRING_LITERAL antlr.Token + backends []antlr.Token +} + +func NewAdminRebalanceDiskContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminRebalanceDiskContext { + var p = new(AdminRebalanceDiskContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminRebalanceDiskContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *AdminRebalanceDiskContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *AdminRebalanceDiskContext) GetBackends() []antlr.Token { return s.backends } + +func (s *AdminRebalanceDiskContext) SetBackends(v []antlr.Token) { s.backends = v } + +func (s *AdminRebalanceDiskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminRebalanceDiskContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminRebalanceDiskContext) REBALANCE() antlr.TerminalNode { + return s.GetToken(DorisParserREBALANCE, 0) +} + +func (s *AdminRebalanceDiskContext) DISK() antlr.TerminalNode { + return s.GetToken(DorisParserDISK, 0) +} + +func (s *AdminRebalanceDiskContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *AdminRebalanceDiskContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminRebalanceDiskContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminRebalanceDiskContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *AdminRebalanceDiskContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *AdminRebalanceDiskContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AdminRebalanceDiskContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AdminRebalanceDiskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminRebalanceDisk(s) + } +} + +func (s *AdminRebalanceDiskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminRebalanceDisk(s) + } +} + +func (s *AdminRebalanceDiskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminRebalanceDisk(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetReplicaStatusContext struct { + SupportedAdminStatementContext +} + +func NewAdminSetReplicaStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetReplicaStatusContext { + var p = new(AdminSetReplicaStatusContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetReplicaStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetReplicaStatusContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetReplicaStatusContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetReplicaStatusContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *AdminSetReplicaStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *AdminSetReplicaStatusContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *AdminSetReplicaStatusContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminSetReplicaStatusContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AdminSetReplicaStatusContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminSetReplicaStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetReplicaStatus(s) + } +} + +func (s *AdminSetReplicaStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetReplicaStatus(s) + } +} + +func (s *AdminSetReplicaStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetReplicaStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetReplicaVersionContext struct { + SupportedAdminStatementContext +} + +func NewAdminSetReplicaVersionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetReplicaVersionContext { + var p = new(AdminSetReplicaVersionContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetReplicaVersionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetReplicaVersionContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetReplicaVersionContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetReplicaVersionContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *AdminSetReplicaVersionContext) VERSION() antlr.TerminalNode { + return s.GetToken(DorisParserVERSION, 0) +} + +func (s *AdminSetReplicaVersionContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *AdminSetReplicaVersionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminSetReplicaVersionContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AdminSetReplicaVersionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminSetReplicaVersionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetReplicaVersion(s) + } +} + +func (s *AdminSetReplicaVersionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetReplicaVersion(s) + } +} + +func (s *AdminSetReplicaVersionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetReplicaVersion(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetTableStatusContext struct { + SupportedAdminStatementContext + name IMultipartIdentifierContext + properties IPropertyClauseContext +} + +func NewAdminSetTableStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetTableStatusContext { + var p = new(AdminSetTableStatusContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetTableStatusContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AdminSetTableStatusContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AdminSetTableStatusContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AdminSetTableStatusContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AdminSetTableStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetTableStatusContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetTableStatusContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetTableStatusContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AdminSetTableStatusContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *AdminSetTableStatusContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AdminSetTableStatusContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminSetTableStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetTableStatus(s) + } +} + +func (s *AdminSetTableStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetTableStatus(s) + } +} + +func (s *AdminSetTableStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetTableStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetPartitionVersionContext struct { + SupportedAdminStatementContext + name IMultipartIdentifierContext + properties IPropertyClauseContext +} + +func NewAdminSetPartitionVersionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetPartitionVersionContext { + var p = new(AdminSetPartitionVersionContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetPartitionVersionContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AdminSetPartitionVersionContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AdminSetPartitionVersionContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AdminSetPartitionVersionContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AdminSetPartitionVersionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetPartitionVersionContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetPartitionVersionContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetPartitionVersionContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AdminSetPartitionVersionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *AdminSetPartitionVersionContext) VERSION() antlr.TerminalNode { + return s.GetToken(DorisParserVERSION, 0) +} + +func (s *AdminSetPartitionVersionContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AdminSetPartitionVersionContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminSetPartitionVersionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetPartitionVersion(s) + } +} + +func (s *AdminSetPartitionVersionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetPartitionVersion(s) + } +} + +func (s *AdminSetPartitionVersionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetPartitionVersion(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCancelRepairTableContext struct { + SupportedAdminStatementContext +} + +func NewAdminCancelRepairTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCancelRepairTableContext { + var p = new(AdminCancelRepairTableContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCancelRepairTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCancelRepairTableContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCancelRepairTableContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *AdminCancelRepairTableContext) REPAIR() antlr.TerminalNode { + return s.GetToken(DorisParserREPAIR, 0) +} + +func (s *AdminCancelRepairTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AdminCancelRepairTableContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *AdminCancelRepairTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCancelRepairTable(s) + } +} + +func (s *AdminCancelRepairTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCancelRepairTable(s) + } +} + +func (s *AdminCancelRepairTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCancelRepairTable(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCopyTabletContext struct { + SupportedAdminStatementContext + tabletId antlr.Token + properties IPropertyClauseContext +} + +func NewAdminCopyTabletContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCopyTabletContext { + var p = new(AdminCopyTabletContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCopyTabletContext) GetTabletId() antlr.Token { return s.tabletId } + +func (s *AdminCopyTabletContext) SetTabletId(v antlr.Token) { s.tabletId = v } + +func (s *AdminCopyTabletContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AdminCopyTabletContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AdminCopyTabletContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCopyTabletContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCopyTabletContext) COPY() antlr.TerminalNode { + return s.GetToken(DorisParserCOPY, 0) +} + +func (s *AdminCopyTabletContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *AdminCopyTabletContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *AdminCopyTabletContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminCopyTabletContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCopyTablet(s) + } +} + +func (s *AdminCopyTabletContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCopyTablet(s) + } +} + +func (s *AdminCopyTabletContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCopyTablet(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetEncryptionRootKeyContext struct { + SupportedAdminStatementContext +} + +func NewAdminSetEncryptionRootKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetEncryptionRootKeyContext { + var p = new(AdminSetEncryptionRootKeyContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetEncryptionRootKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetEncryptionRootKeyContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTION, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) ROOT() antlr.TerminalNode { + return s.GetToken(DorisParserROOT, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AdminSetEncryptionRootKeyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminSetEncryptionRootKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetEncryptionRootKey(s) + } +} + +func (s *AdminSetEncryptionRootKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetEncryptionRootKey(s) + } +} + +func (s *AdminSetEncryptionRootKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetEncryptionRootKey(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminRepairTableContext struct { + SupportedAdminStatementContext +} + +func NewAdminRepairTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminRepairTableContext { + var p = new(AdminRepairTableContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminRepairTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminRepairTableContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminRepairTableContext) REPAIR() antlr.TerminalNode { + return s.GetToken(DorisParserREPAIR, 0) +} + +func (s *AdminRepairTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AdminRepairTableContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *AdminRepairTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminRepairTable(s) + } +} + +func (s *AdminRepairTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminRepairTable(s) + } +} + +func (s *AdminRepairTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminRepairTable(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetFrontendConfigContext struct { + SupportedAdminStatementContext +} + +func NewAdminSetFrontendConfigContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetFrontendConfigContext { + var p = new(AdminSetFrontendConfigContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetFrontendConfigContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetFrontendConfigContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetFrontendConfigContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetFrontendConfigContext) CONFIG() antlr.TerminalNode { + return s.GetToken(DorisParserCONFIG, 0) +} + +func (s *AdminSetFrontendConfigContext) FRONTEND() antlr.TerminalNode { + return s.GetToken(DorisParserFRONTEND, 0) +} + +func (s *AdminSetFrontendConfigContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminSetFrontendConfigContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AdminSetFrontendConfigContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminSetFrontendConfigContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(DorisParserALL) +} + +func (s *AdminSetFrontendConfigContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserALL, i) +} + +func (s *AdminSetFrontendConfigContext) FRONTENDS() antlr.TerminalNode { + return s.GetToken(DorisParserFRONTENDS, 0) +} + +func (s *AdminSetFrontendConfigContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetFrontendConfig(s) + } +} + +func (s *AdminSetFrontendConfigContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetFrontendConfig(s) + } +} + +func (s *AdminSetFrontendConfigContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetFrontendConfig(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCreateClusterSnapshotContext struct { + SupportedAdminStatementContext +} + +func NewAdminCreateClusterSnapshotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCreateClusterSnapshotContext { + var p = new(AdminCreateClusterSnapshotContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCreateClusterSnapshotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCreateClusterSnapshotContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCreateClusterSnapshotContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *AdminCreateClusterSnapshotContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *AdminCreateClusterSnapshotContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *AdminCreateClusterSnapshotContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminCreateClusterSnapshotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCreateClusterSnapshot(s) + } +} + +func (s *AdminCreateClusterSnapshotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCreateClusterSnapshot(s) + } +} + +func (s *AdminCreateClusterSnapshotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCreateClusterSnapshot(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCheckTabletsContext struct { + SupportedAdminStatementContext + properties IPropertyClauseContext +} + +func NewAdminCheckTabletsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCheckTabletsContext { + var p = new(AdminCheckTabletsContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCheckTabletsContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AdminCheckTabletsContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AdminCheckTabletsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCheckTabletsContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCheckTabletsContext) CHECK() antlr.TerminalNode { + return s.GetToken(DorisParserCHECK, 0) +} + +func (s *AdminCheckTabletsContext) TabletList() ITabletListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITabletListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITabletListContext) +} + +func (s *AdminCheckTabletsContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminCheckTabletsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCheckTablets(s) + } +} + +func (s *AdminCheckTabletsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCheckTablets(s) + } +} + +func (s *AdminCheckTabletsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCheckTablets(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminDropClusterSnapshotContext struct { + SupportedAdminStatementContext + key IIdentifierContext + value antlr.Token +} + +func NewAdminDropClusterSnapshotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminDropClusterSnapshotContext { + var p = new(AdminDropClusterSnapshotContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminDropClusterSnapshotContext) GetValue() antlr.Token { return s.value } + +func (s *AdminDropClusterSnapshotContext) SetValue(v antlr.Token) { s.value = v } + +func (s *AdminDropClusterSnapshotContext) GetKey() IIdentifierContext { return s.key } + +func (s *AdminDropClusterSnapshotContext) SetKey(v IIdentifierContext) { s.key = v } + +func (s *AdminDropClusterSnapshotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminDropClusterSnapshotContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminDropClusterSnapshotContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *AdminDropClusterSnapshotContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *AdminDropClusterSnapshotContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *AdminDropClusterSnapshotContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *AdminDropClusterSnapshotContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *AdminDropClusterSnapshotContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AdminDropClusterSnapshotContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AdminDropClusterSnapshotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminDropClusterSnapshot(s) + } +} + +func (s *AdminDropClusterSnapshotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminDropClusterSnapshot(s) + } +} + +func (s *AdminDropClusterSnapshotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminDropClusterSnapshot(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCleanTrashContext struct { + SupportedAdminStatementContext + _STRING_LITERAL antlr.Token + backends []antlr.Token +} + +func NewAdminCleanTrashContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCleanTrashContext { + var p = new(AdminCleanTrashContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCleanTrashContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *AdminCleanTrashContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *AdminCleanTrashContext) GetBackends() []antlr.Token { return s.backends } + +func (s *AdminCleanTrashContext) SetBackends(v []antlr.Token) { s.backends = v } + +func (s *AdminCleanTrashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCleanTrashContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCleanTrashContext) CLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserCLEAN, 0) +} + +func (s *AdminCleanTrashContext) TRASH() antlr.TerminalNode { + return s.GetToken(DorisParserTRASH, 0) +} + +func (s *AdminCleanTrashContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *AdminCleanTrashContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminCleanTrashContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminCleanTrashContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *AdminCleanTrashContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *AdminCleanTrashContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AdminCleanTrashContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AdminCleanTrashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCleanTrash(s) + } +} + +func (s *AdminCleanTrashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCleanTrash(s) + } +} + +func (s *AdminCleanTrashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCleanTrash(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCompactTableContext struct { + SupportedAdminStatementContext +} + +func NewAdminCompactTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCompactTableContext { + var p = new(AdminCompactTableContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCompactTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCompactTableContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCompactTableContext) COMPACT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPACT, 0) +} + +func (s *AdminCompactTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AdminCompactTableContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *AdminCompactTableContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *AdminCompactTableContext) TYPE() antlr.TerminalNode { + return s.GetToken(DorisParserTYPE, 0) +} + +func (s *AdminCompactTableContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *AdminCompactTableContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AdminCompactTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCompactTable(s) + } +} + +func (s *AdminCompactTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCompactTable(s) + } +} + +func (s *AdminCompactTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCompactTable(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminSetAutoClusterSnapshotContext struct { + SupportedAdminStatementContext +} + +func NewAdminSetAutoClusterSnapshotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminSetAutoClusterSnapshotContext { + var p = new(AdminSetAutoClusterSnapshotContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminSetAutoClusterSnapshotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminSetAutoClusterSnapshotContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminSetAutoClusterSnapshotContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AdminSetAutoClusterSnapshotContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *AdminSetAutoClusterSnapshotContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *AdminSetAutoClusterSnapshotContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *AdminSetAutoClusterSnapshotContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminSetAutoClusterSnapshotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminSetAutoClusterSnapshot(s) + } +} + +func (s *AdminSetAutoClusterSnapshotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminSetAutoClusterSnapshot(s) + } +} + +func (s *AdminSetAutoClusterSnapshotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminSetAutoClusterSnapshot(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminDiagnoseTabletContext struct { + SupportedAdminStatementContext + tabletId antlr.Token +} + +func NewAdminDiagnoseTabletContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminDiagnoseTabletContext { + var p = new(AdminDiagnoseTabletContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminDiagnoseTabletContext) GetTabletId() antlr.Token { return s.tabletId } + +func (s *AdminDiagnoseTabletContext) SetTabletId(v antlr.Token) { s.tabletId = v } + +func (s *AdminDiagnoseTabletContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminDiagnoseTabletContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminDiagnoseTabletContext) DIAGNOSE() antlr.TerminalNode { + return s.GetToken(DorisParserDIAGNOSE, 0) +} + +func (s *AdminDiagnoseTabletContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *AdminDiagnoseTabletContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *AdminDiagnoseTabletContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminDiagnoseTablet(s) + } +} + +func (s *AdminDiagnoseTabletContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminDiagnoseTablet(s) + } +} + +func (s *AdminDiagnoseTabletContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminDiagnoseTablet(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminCancelRebalanceDiskContext struct { + SupportedAdminStatementContext + _STRING_LITERAL antlr.Token + backends []antlr.Token +} + +func NewAdminCancelRebalanceDiskContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminCancelRebalanceDiskContext { + var p = new(AdminCancelRebalanceDiskContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminCancelRebalanceDiskContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *AdminCancelRebalanceDiskContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *AdminCancelRebalanceDiskContext) GetBackends() []antlr.Token { return s.backends } + +func (s *AdminCancelRebalanceDiskContext) SetBackends(v []antlr.Token) { s.backends = v } + +func (s *AdminCancelRebalanceDiskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminCancelRebalanceDiskContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminCancelRebalanceDiskContext) CANCEL() antlr.TerminalNode { + return s.GetToken(DorisParserCANCEL, 0) +} + +func (s *AdminCancelRebalanceDiskContext) REBALANCE() antlr.TerminalNode { + return s.GetToken(DorisParserREBALANCE, 0) +} + +func (s *AdminCancelRebalanceDiskContext) DISK() antlr.TerminalNode { + return s.GetToken(DorisParserDISK, 0) +} + +func (s *AdminCancelRebalanceDiskContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *AdminCancelRebalanceDiskContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AdminCancelRebalanceDiskContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AdminCancelRebalanceDiskContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *AdminCancelRebalanceDiskContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *AdminCancelRebalanceDiskContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AdminCancelRebalanceDiskContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AdminCancelRebalanceDiskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminCancelRebalanceDisk(s) + } +} + +func (s *AdminCancelRebalanceDiskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminCancelRebalanceDisk(s) + } +} + +func (s *AdminCancelRebalanceDiskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminCancelRebalanceDisk(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminShowReplicaStatusContext struct { + SupportedAdminStatementContext +} + +func NewAdminShowReplicaStatusContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminShowReplicaStatusContext { + var p = new(AdminShowReplicaStatusContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminShowReplicaStatusContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminShowReplicaStatusContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminShowReplicaStatusContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *AdminShowReplicaStatusContext) REPLICA() antlr.TerminalNode { + return s.GetToken(DorisParserREPLICA, 0) +} + +func (s *AdminShowReplicaStatusContext) AllSTATUS() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTATUS) +} + +func (s *AdminShowReplicaStatusContext) STATUS(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, i) +} + +func (s *AdminShowReplicaStatusContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *AdminShowReplicaStatusContext) BaseTableRef() IBaseTableRefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBaseTableRefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBaseTableRefContext) +} + +func (s *AdminShowReplicaStatusContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *AdminShowReplicaStatusContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *AdminShowReplicaStatusContext) NEQ() antlr.TerminalNode { + return s.GetToken(DorisParserNEQ, 0) +} + +func (s *AdminShowReplicaStatusContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AdminShowReplicaStatusContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminShowReplicaStatus(s) + } +} + +func (s *AdminShowReplicaStatusContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminShowReplicaStatus(s) + } +} + +func (s *AdminShowReplicaStatusContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminShowReplicaStatus(s) + + default: + return t.VisitChildren(s) + } +} + +type AdminRotateTdeRootKeyContext struct { + SupportedAdminStatementContext + properties IPropertyClauseContext +} + +func NewAdminRotateTdeRootKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AdminRotateTdeRootKeyContext { + var p = new(AdminRotateTdeRootKeyContext) + + InitEmptySupportedAdminStatementContext(&p.SupportedAdminStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedAdminStatementContext)) + + return p +} + +func (s *AdminRotateTdeRootKeyContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AdminRotateTdeRootKeyContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AdminRotateTdeRootKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AdminRotateTdeRootKeyContext) ADMIN() antlr.TerminalNode { + return s.GetToken(DorisParserADMIN, 0) +} + +func (s *AdminRotateTdeRootKeyContext) ROTATE() antlr.TerminalNode { + return s.GetToken(DorisParserROTATE, 0) +} + +func (s *AdminRotateTdeRootKeyContext) TDE() antlr.TerminalNode { + return s.GetToken(DorisParserTDE, 0) +} + +func (s *AdminRotateTdeRootKeyContext) ROOT() antlr.TerminalNode { + return s.GetToken(DorisParserROOT, 0) +} + +func (s *AdminRotateTdeRootKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *AdminRotateTdeRootKeyContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AdminRotateTdeRootKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAdminRotateTdeRootKey(s) + } +} + +func (s *AdminRotateTdeRootKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAdminRotateTdeRootKey(s) + } +} + +func (s *AdminRotateTdeRootKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAdminRotateTdeRootKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedAdminStatement() (localctx ISupportedAdminStatementContext) { + localctx = NewSupportedAdminStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, DorisParserRULE_supportedAdminStatement) + var _la int + + p.SetState(3474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 460, p.GetParserRuleContext()) { + case 1: + localctx = NewAdminShowReplicaDistributionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3262) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3263) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3264) + p.Match(DorisParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3265) + p.Match(DorisParserDISTRIBUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3266) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3267) + p.BaseTableRef() + } + + case 2: + localctx = NewAdminRebalanceDiskContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3268) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3269) + p.Match(DorisParserREBALANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3270) + p.Match(DorisParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(3271) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3272) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3273) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminRebalanceDiskContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AdminRebalanceDiskContext).backends = append(localctx.(*AdminRebalanceDiskContext).backends, localctx.(*AdminRebalanceDiskContext)._STRING_LITERAL) + p.SetState(3278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3274) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3275) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminRebalanceDiskContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AdminRebalanceDiskContext).backends = append(localctx.(*AdminRebalanceDiskContext).backends, localctx.(*AdminRebalanceDiskContext)._STRING_LITERAL) + + p.SetState(3280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3281) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + localctx = NewAdminCancelRebalanceDiskContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3284) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3285) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3286) + p.Match(DorisParserREBALANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3287) + p.Match(DorisParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(3288) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3289) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3290) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminCancelRebalanceDiskContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AdminCancelRebalanceDiskContext).backends = append(localctx.(*AdminCancelRebalanceDiskContext).backends, localctx.(*AdminCancelRebalanceDiskContext)._STRING_LITERAL) + p.SetState(3295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3291) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3292) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminCancelRebalanceDiskContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AdminCancelRebalanceDiskContext).backends = append(localctx.(*AdminCancelRebalanceDiskContext).backends, localctx.(*AdminCancelRebalanceDiskContext)._STRING_LITERAL) + + p.SetState(3297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3298) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + localctx = NewAdminDiagnoseTabletContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3301) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3302) + p.Match(DorisParserDIAGNOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3303) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3304) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*AdminDiagnoseTabletContext).tabletId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewAdminShowReplicaStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3305) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3306) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3307) + p.Match(DorisParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3308) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3309) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3310) + p.BaseTableRef() + } + p.SetState(3316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case DorisParserWHERE: + { + p.SetState(3311) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3312) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3313) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserNEQ: + { + p.SetState(3314) + p.Match(DorisParserNEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3315) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserEOF, DorisParserSEMICOLON: + + default: + } + + case 6: + localctx = NewAdminCompactTableContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3318) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3319) + p.Match(DorisParserCOMPACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3320) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3321) + p.BaseTableRef() + } + p.SetState(3326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(3322) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3323) + p.Match(DorisParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3324) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3325) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 7: + localctx = NewAdminCheckTabletsContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3328) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3329) + p.Match(DorisParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3330) + p.TabletList() + } + p.SetState(3332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3331) + + var _x = p.PropertyClause() + + localctx.(*AdminCheckTabletsContext).properties = _x + } + + } + + case 8: + localctx = NewAdminShowTabletStorageFormatContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3334) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3335) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3336) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3337) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3338) + p.Match(DorisParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserVERBOSE { + { + p.SetState(3339) + p.Match(DorisParserVERBOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 9: + localctx = NewAdminSetFrontendConfigContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3342) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3343) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserFRONTEND: + { + p.SetState(3344) + p.Match(DorisParserFRONTEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserALL: + { + p.SetState(3345) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3346) + p.Match(DorisParserFRONTENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3349) + p.Match(DorisParserCONFIG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(3350) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3351) + p.PropertyItemList() + } + { + p.SetState(3352) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL { + { + p.SetState(3356) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 10: + localctx = NewAdminCleanTrashContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3359) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3360) + p.Match(DorisParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3361) + p.Match(DorisParserTRASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(3362) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3363) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3364) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminCleanTrashContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AdminCleanTrashContext).backends = append(localctx.(*AdminCleanTrashContext).backends, localctx.(*AdminCleanTrashContext)._STRING_LITERAL) + p.SetState(3369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3365) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3366) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminCleanTrashContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AdminCleanTrashContext).backends = append(localctx.(*AdminCleanTrashContext).backends, localctx.(*AdminCleanTrashContext)._STRING_LITERAL) + + p.SetState(3371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3372) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 11: + localctx = NewAdminSetReplicaVersionContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3375) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3376) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3377) + p.Match(DorisParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3378) + p.Match(DorisParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3379) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3380) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3381) + p.PropertyItemList() + } + { + p.SetState(3382) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewAdminSetTableStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3384) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3385) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3386) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3387) + + var _x = p.MultipartIdentifier() + + localctx.(*AdminSetTableStatusContext).name = _x + } + { + p.SetState(3388) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3389) + + var _x = p.PropertyClause() + + localctx.(*AdminSetTableStatusContext).properties = _x + } + + } + + case 13: + localctx = NewAdminSetReplicaStatusContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3392) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3393) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3394) + p.Match(DorisParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3395) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3396) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3397) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3398) + p.PropertyItemList() + } + { + p.SetState(3399) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewAdminRepairTableContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(3401) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3402) + p.Match(DorisParserREPAIR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3403) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3404) + p.BaseTableRef() + } + + case 15: + localctx = NewAdminCancelRepairTableContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(3405) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3406) + p.Match(DorisParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3407) + p.Match(DorisParserREPAIR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3408) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3409) + p.BaseTableRef() + } + + case 16: + localctx = NewAdminCopyTabletContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(3410) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3411) + p.Match(DorisParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3412) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3413) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*AdminCopyTabletContext).tabletId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3414) + + var _x = p.PropertyClause() + + localctx.(*AdminCopyTabletContext).properties = _x + } + + } + + case 17: + localctx = NewAdminSetEncryptionRootKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(3417) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3418) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3419) + p.Match(DorisParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3420) + p.Match(DorisParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3421) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3422) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3423) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3424) + p.PropertyItemList() + } + { + p.SetState(3425) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + localctx = NewAdminSetPartitionVersionContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(3427) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3428) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3429) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3430) + + var _x = p.MultipartIdentifier() + + localctx.(*AdminSetPartitionVersionContext).name = _x + } + { + p.SetState(3431) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3432) + p.Match(DorisParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3433) + + var _x = p.PropertyClause() + + localctx.(*AdminSetPartitionVersionContext).properties = _x + } + + } + + case 19: + localctx = NewAdminCreateClusterSnapshotContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(3436) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3437) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3438) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3439) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3440) + p.PropertyClause() + } + + } + + case 20: + localctx = NewAdminSetAutoClusterSnapshotContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(3443) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3444) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3445) + p.Match(DorisParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3446) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3447) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3448) + p.PropertyClause() + } + + } + + case 21: + localctx = NewAdminDropClusterSnapshotContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(3451) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3452) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3453) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3454) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3455) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(3456) + + var _x = p.Identifier() + + localctx.(*AdminDropClusterSnapshotContext).key = _x + } + + { + p.SetState(3457) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(3458) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AdminDropClusterSnapshotContext).value = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + localctx = NewAdminSetClusterSnapshotFeatureSwitchContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(3460) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3461) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3462) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3463) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3464) + p.Match(DorisParserFEATURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3465) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserON || _la == DorisParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 23: + localctx = NewAdminRotateTdeRootKeyContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(3466) + p.Match(DorisParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3467) + p.Match(DorisParserROTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3468) + p.Match(DorisParserTDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3469) + p.Match(DorisParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3470) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3471) + + var _x = p.PropertyClause() + + localctx.(*AdminRotateTdeRootKeyContext).properties = _x + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedRecoverStatementContext is an interface to support dynamic dispatch. +type ISupportedRecoverStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedRecoverStatementContext differentiates from other interfaces. + IsSupportedRecoverStatementContext() +} + +type SupportedRecoverStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedRecoverStatementContext() *SupportedRecoverStatementContext { + var p = new(SupportedRecoverStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedRecoverStatement + return p +} + +func InitEmptySupportedRecoverStatementContext(p *SupportedRecoverStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedRecoverStatement +} + +func (*SupportedRecoverStatementContext) IsSupportedRecoverStatementContext() {} + +func NewSupportedRecoverStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedRecoverStatementContext { + var p = new(SupportedRecoverStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedRecoverStatement + + return p +} + +func (s *SupportedRecoverStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedRecoverStatementContext) CopyAll(ctx *SupportedRecoverStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedRecoverStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedRecoverStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type RecoverPartitionContext struct { + SupportedRecoverStatementContext + name IIdentifierContext + id antlr.Token + alias IIdentifierContext + tableName IMultipartIdentifierContext +} + +func NewRecoverPartitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RecoverPartitionContext { + var p = new(RecoverPartitionContext) + + InitEmptySupportedRecoverStatementContext(&p.SupportedRecoverStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRecoverStatementContext)) + + return p +} + +func (s *RecoverPartitionContext) GetId() antlr.Token { return s.id } + +func (s *RecoverPartitionContext) SetId(v antlr.Token) { s.id = v } + +func (s *RecoverPartitionContext) GetName() IIdentifierContext { return s.name } + +func (s *RecoverPartitionContext) GetAlias() IIdentifierContext { return s.alias } + +func (s *RecoverPartitionContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *RecoverPartitionContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *RecoverPartitionContext) SetAlias(v IIdentifierContext) { s.alias = v } + +func (s *RecoverPartitionContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *RecoverPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RecoverPartitionContext) RECOVER() antlr.TerminalNode { + return s.GetToken(DorisParserRECOVER, 0) +} + +func (s *RecoverPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *RecoverPartitionContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *RecoverPartitionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *RecoverPartitionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RecoverPartitionContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RecoverPartitionContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *RecoverPartitionContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *RecoverPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRecoverPartition(s) + } +} + +func (s *RecoverPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRecoverPartition(s) + } +} + +func (s *RecoverPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRecoverPartition(s) + + default: + return t.VisitChildren(s) + } +} + +type RecoverTableContext struct { + SupportedRecoverStatementContext + name IMultipartIdentifierContext + id antlr.Token + alias IIdentifierContext +} + +func NewRecoverTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RecoverTableContext { + var p = new(RecoverTableContext) + + InitEmptySupportedRecoverStatementContext(&p.SupportedRecoverStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRecoverStatementContext)) + + return p +} + +func (s *RecoverTableContext) GetId() antlr.Token { return s.id } + +func (s *RecoverTableContext) SetId(v antlr.Token) { s.id = v } + +func (s *RecoverTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *RecoverTableContext) GetAlias() IIdentifierContext { return s.alias } + +func (s *RecoverTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *RecoverTableContext) SetAlias(v IIdentifierContext) { s.alias = v } + +func (s *RecoverTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RecoverTableContext) RECOVER() antlr.TerminalNode { + return s.GetToken(DorisParserRECOVER, 0) +} + +func (s *RecoverTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *RecoverTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *RecoverTableContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *RecoverTableContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *RecoverTableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RecoverTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRecoverTable(s) + } +} + +func (s *RecoverTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRecoverTable(s) + } +} + +func (s *RecoverTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRecoverTable(s) + + default: + return t.VisitChildren(s) + } +} + +type RecoverDatabaseContext struct { + SupportedRecoverStatementContext + name IIdentifierContext + id antlr.Token + alias IIdentifierContext +} + +func NewRecoverDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RecoverDatabaseContext { + var p = new(RecoverDatabaseContext) + + InitEmptySupportedRecoverStatementContext(&p.SupportedRecoverStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedRecoverStatementContext)) + + return p +} + +func (s *RecoverDatabaseContext) GetId() antlr.Token { return s.id } + +func (s *RecoverDatabaseContext) SetId(v antlr.Token) { s.id = v } + +func (s *RecoverDatabaseContext) GetName() IIdentifierContext { return s.name } + +func (s *RecoverDatabaseContext) GetAlias() IIdentifierContext { return s.alias } + +func (s *RecoverDatabaseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *RecoverDatabaseContext) SetAlias(v IIdentifierContext) { s.alias = v } + +func (s *RecoverDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RecoverDatabaseContext) RECOVER() antlr.TerminalNode { + return s.GetToken(DorisParserRECOVER, 0) +} + +func (s *RecoverDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *RecoverDatabaseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *RecoverDatabaseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RecoverDatabaseContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *RecoverDatabaseContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *RecoverDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRecoverDatabase(s) + } +} + +func (s *RecoverDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRecoverDatabase(s) + } +} + +func (s *RecoverDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRecoverDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedRecoverStatement() (localctx ISupportedRecoverStatementContext) { + localctx = NewSupportedRecoverStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, DorisParserRULE_supportedRecoverStatement) + var _la int + + p.SetState(3509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 467, p.GetParserRuleContext()) { + case 1: + localctx = NewRecoverDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3476) + p.Match(DorisParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3477) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3478) + + var _x = p.Identifier() + + localctx.(*RecoverDatabaseContext).name = _x + } + p.SetState(3480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINTEGER_VALUE { + { + p.SetState(3479) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*RecoverDatabaseContext).id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(3482) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3483) + + var _x = p.Identifier() + + localctx.(*RecoverDatabaseContext).alias = _x + } + + } + + case 2: + localctx = NewRecoverTableContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3486) + p.Match(DorisParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3487) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3488) + + var _x = p.MultipartIdentifier() + + localctx.(*RecoverTableContext).name = _x + } + p.SetState(3490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINTEGER_VALUE { + { + p.SetState(3489) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*RecoverTableContext).id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(3492) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3493) + + var _x = p.Identifier() + + localctx.(*RecoverTableContext).alias = _x + } + + } + + case 3: + localctx = NewRecoverPartitionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3496) + p.Match(DorisParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3497) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3498) + + var _x = p.Identifier() + + localctx.(*RecoverPartitionContext).name = _x + } + p.SetState(3500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINTEGER_VALUE { + { + p.SetState(3499) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*RecoverPartitionContext).id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(3502) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3503) + + var _x = p.Identifier() + + localctx.(*RecoverPartitionContext).alias = _x + } + + } + { + p.SetState(3506) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3507) + + var _x = p.MultipartIdentifier() + + localctx.(*RecoverPartitionContext).tableName = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBaseTableRefContext is an interface to support dynamic dispatch. +type IBaseTableRefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MultipartIdentifier() IMultipartIdentifierContext + TableAlias() ITableAliasContext + OptScanParams() IOptScanParamsContext + TableSnapshot() ITableSnapshotContext + SpecifiedPartition() ISpecifiedPartitionContext + TabletList() ITabletListContext + Sample() ISampleContext + RelationHint() IRelationHintContext + + // IsBaseTableRefContext differentiates from other interfaces. + IsBaseTableRefContext() +} + +type BaseTableRefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBaseTableRefContext() *BaseTableRefContext { + var p = new(BaseTableRefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_baseTableRef + return p +} + +func InitEmptyBaseTableRefContext(p *BaseTableRefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_baseTableRef +} + +func (*BaseTableRefContext) IsBaseTableRefContext() {} + +func NewBaseTableRefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BaseTableRefContext { + var p = new(BaseTableRefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_baseTableRef + + return p +} + +func (s *BaseTableRefContext) GetParser() antlr.Parser { return s.parser } + +func (s *BaseTableRefContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *BaseTableRefContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *BaseTableRefContext) OptScanParams() IOptScanParamsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptScanParamsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptScanParamsContext) +} + +func (s *BaseTableRefContext) TableSnapshot() ITableSnapshotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSnapshotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSnapshotContext) +} + +func (s *BaseTableRefContext) SpecifiedPartition() ISpecifiedPartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecifiedPartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpecifiedPartitionContext) +} + +func (s *BaseTableRefContext) TabletList() ITabletListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITabletListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITabletListContext) +} + +func (s *BaseTableRefContext) Sample() ISampleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISampleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISampleContext) +} + +func (s *BaseTableRefContext) RelationHint() IRelationHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationHintContext) +} + +func (s *BaseTableRefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BaseTableRefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BaseTableRefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBaseTableRef(s) + } +} + +func (s *BaseTableRefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBaseTableRef(s) + } +} + +func (s *BaseTableRefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBaseTableRef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) BaseTableRef() (localctx IBaseTableRefContext) { + localctx = NewBaseTableRefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, DorisParserRULE_baseTableRef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3511) + p.MultipartIdentifier() + } + p.SetState(3513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserATSIGN { + { + p.SetState(3512) + p.OptScanParams() + } + + } + p.SetState(3516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(3515) + p.TableSnapshot() + } + + } + p.SetState(3519) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 470, p.GetParserRuleContext()) == 1 { + { + p.SetState(3518) + p.SpecifiedPartition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTABLET { + { + p.SetState(3521) + p.TabletList() + } + + } + { + p.SetState(3524) + p.TableAlias() + } + p.SetState(3526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTABLESAMPLE { + { + p.SetState(3525) + p.Sample() + } + + } + p.SetState(3529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_BRACKET || _la == DorisParserHINT_START { + { + p.SetState(3528) + p.RelationHint() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWildWhereContext is an interface to support dynamic dispatch. +type IWildWhereContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + WHERE() antlr.TerminalNode + Expression() IExpressionContext + + // IsWildWhereContext differentiates from other interfaces. + IsWildWhereContext() +} + +type WildWhereContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWildWhereContext() *WildWhereContext { + var p = new(WildWhereContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_wildWhere + return p +} + +func InitEmptyWildWhereContext(p *WildWhereContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_wildWhere +} + +func (*WildWhereContext) IsWildWhereContext() {} + +func NewWildWhereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WildWhereContext { + var p = new(WildWhereContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_wildWhere + + return p +} + +func (s *WildWhereContext) GetParser() antlr.Parser { return s.parser } + +func (s *WildWhereContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *WildWhereContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *WildWhereContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *WildWhereContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WildWhereContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WildWhereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WildWhereContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWildWhere(s) + } +} + +func (s *WildWhereContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWildWhere(s) + } +} + +func (s *WildWhereContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWildWhere(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WildWhere() (localctx IWildWhereContext) { + localctx = NewWildWhereContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, DorisParserRULE_wildWhere) + p.SetState(3535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLIKE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3531) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3532) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserWHERE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3533) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3534) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedTransactionStatementContext is an interface to support dynamic dispatch. +type ISupportedTransactionStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedTransactionStatementContext differentiates from other interfaces. + IsSupportedTransactionStatementContext() +} + +type SupportedTransactionStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedTransactionStatementContext() *SupportedTransactionStatementContext { + var p = new(SupportedTransactionStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedTransactionStatement + return p +} + +func InitEmptySupportedTransactionStatementContext(p *SupportedTransactionStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedTransactionStatement +} + +func (*SupportedTransactionStatementContext) IsSupportedTransactionStatementContext() {} + +func NewSupportedTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedTransactionStatementContext { + var p = new(SupportedTransactionStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedTransactionStatement + + return p +} + +func (s *SupportedTransactionStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedTransactionStatementContext) CopyAll(ctx *SupportedTransactionStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedTransactionStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedTransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type TranscationCommitContext struct { + SupportedTransactionStatementContext +} + +func NewTranscationCommitContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TranscationCommitContext { + var p = new(TranscationCommitContext) + + InitEmptySupportedTransactionStatementContext(&p.SupportedTransactionStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedTransactionStatementContext)) + + return p +} + +func (s *TranscationCommitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TranscationCommitContext) COMMIT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMIT, 0) +} + +func (s *TranscationCommitContext) WORK() antlr.TerminalNode { + return s.GetToken(DorisParserWORK, 0) +} + +func (s *TranscationCommitContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *TranscationCommitContext) CHAIN() antlr.TerminalNode { + return s.GetToken(DorisParserCHAIN, 0) +} + +func (s *TranscationCommitContext) RELEASE() antlr.TerminalNode { + return s.GetToken(DorisParserRELEASE, 0) +} + +func (s *TranscationCommitContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(DorisParserNO) +} + +func (s *TranscationCommitContext) NO(i int) antlr.TerminalNode { + return s.GetToken(DorisParserNO, i) +} + +func (s *TranscationCommitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTranscationCommit(s) + } +} + +func (s *TranscationCommitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTranscationCommit(s) + } +} + +func (s *TranscationCommitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTranscationCommit(s) + + default: + return t.VisitChildren(s) + } +} + +type TransactionRollbackContext struct { + SupportedTransactionStatementContext +} + +func NewTransactionRollbackContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TransactionRollbackContext { + var p = new(TransactionRollbackContext) + + InitEmptySupportedTransactionStatementContext(&p.SupportedTransactionStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedTransactionStatementContext)) + + return p +} + +func (s *TransactionRollbackContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionRollbackContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(DorisParserROLLBACK, 0) +} + +func (s *TransactionRollbackContext) WORK() antlr.TerminalNode { + return s.GetToken(DorisParserWORK, 0) +} + +func (s *TransactionRollbackContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *TransactionRollbackContext) CHAIN() antlr.TerminalNode { + return s.GetToken(DorisParserCHAIN, 0) +} + +func (s *TransactionRollbackContext) RELEASE() antlr.TerminalNode { + return s.GetToken(DorisParserRELEASE, 0) +} + +func (s *TransactionRollbackContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(DorisParserNO) +} + +func (s *TransactionRollbackContext) NO(i int) antlr.TerminalNode { + return s.GetToken(DorisParserNO, i) +} + +func (s *TransactionRollbackContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTransactionRollback(s) + } +} + +func (s *TransactionRollbackContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTransactionRollback(s) + } +} + +func (s *TransactionRollbackContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTransactionRollback(s) + + default: + return t.VisitChildren(s) + } +} + +type TransactionBeginContext struct { + SupportedTransactionStatementContext +} + +func NewTransactionBeginContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TransactionBeginContext { + var p = new(TransactionBeginContext) + + InitEmptySupportedTransactionStatementContext(&p.SupportedTransactionStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedTransactionStatementContext)) + + return p +} + +func (s *TransactionBeginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionBeginContext) BEGIN() antlr.TerminalNode { + return s.GetToken(DorisParserBEGIN, 0) +} + +func (s *TransactionBeginContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *TransactionBeginContext) LABEL() antlr.TerminalNode { + return s.GetToken(DorisParserLABEL, 0) +} + +func (s *TransactionBeginContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *TransactionBeginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTransactionBegin(s) + } +} + +func (s *TransactionBeginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTransactionBegin(s) + } +} + +func (s *TransactionBeginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTransactionBegin(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedTransactionStatement() (localctx ISupportedTransactionStatementContext) { + localctx = NewSupportedTransactionStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, DorisParserRULE_supportedTransactionStatement) + var _la int + + p.SetState(3579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserBEGIN: + localctx = NewTransactionBeginContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3537) + p.Match(DorisParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(3538) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3539) + p.Match(DorisParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(3540) + p.Identifier() + } + + } + + } + + case DorisParserCOMMIT: + localctx = NewTranscationCommitContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3545) + p.Match(DorisParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWORK { + { + p.SetState(3546) + p.Match(DorisParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAND { + { + p.SetState(3549) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNO { + { + p.SetState(3550) + p.Match(DorisParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3553) + p.Match(DorisParserCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNO || _la == DorisParserRELEASE { + p.SetState(3557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNO { + { + p.SetState(3556) + p.Match(DorisParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3559) + p.Match(DorisParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case DorisParserROLLBACK: + localctx = NewTransactionRollbackContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3562) + p.Match(DorisParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWORK { + { + p.SetState(3563) + p.Match(DorisParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAND { + { + p.SetState(3566) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNO { + { + p.SetState(3567) + p.Match(DorisParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3570) + p.Match(DorisParserCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNO || _la == DorisParserRELEASE { + p.SetState(3574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNO { + { + p.SetState(3573) + p.Match(DorisParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3576) + p.Match(DorisParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedGrantRevokeStatementContext is an interface to support dynamic dispatch. +type ISupportedGrantRevokeStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedGrantRevokeStatementContext differentiates from other interfaces. + IsSupportedGrantRevokeStatementContext() +} + +type SupportedGrantRevokeStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedGrantRevokeStatementContext() *SupportedGrantRevokeStatementContext { + var p = new(SupportedGrantRevokeStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedGrantRevokeStatement + return p +} + +func InitEmptySupportedGrantRevokeStatementContext(p *SupportedGrantRevokeStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedGrantRevokeStatement +} + +func (*SupportedGrantRevokeStatementContext) IsSupportedGrantRevokeStatementContext() {} + +func NewSupportedGrantRevokeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedGrantRevokeStatementContext { + var p = new(SupportedGrantRevokeStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedGrantRevokeStatement + + return p +} + +func (s *SupportedGrantRevokeStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedGrantRevokeStatementContext) CopyAll(ctx *SupportedGrantRevokeStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedGrantRevokeStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedGrantRevokeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type GrantResourcePrivilegeContext struct { + SupportedGrantRevokeStatementContext +} + +func NewGrantResourcePrivilegeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GrantResourcePrivilegeContext { + var p = new(GrantResourcePrivilegeContext) + + InitEmptySupportedGrantRevokeStatementContext(&p.SupportedGrantRevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedGrantRevokeStatementContext)) + + return p +} + +func (s *GrantResourcePrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantResourcePrivilegeContext) GRANT() antlr.TerminalNode { + return s.GetToken(DorisParserGRANT, 0) +} + +func (s *GrantResourcePrivilegeContext) PrivilegeList() IPrivilegeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeListContext) +} + +func (s *GrantResourcePrivilegeContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *GrantResourcePrivilegeContext) IdentifierOrTextOrAsterisk() IIdentifierOrTextOrAsteriskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextOrAsteriskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextOrAsteriskContext) +} + +func (s *GrantResourcePrivilegeContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *GrantResourcePrivilegeContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *GrantResourcePrivilegeContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *GrantResourcePrivilegeContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, 0) +} + +func (s *GrantResourcePrivilegeContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *GrantResourcePrivilegeContext) STAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGE, 0) +} + +func (s *GrantResourcePrivilegeContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *GrantResourcePrivilegeContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *GrantResourcePrivilegeContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *GrantResourcePrivilegeContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *GrantResourcePrivilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *GrantResourcePrivilegeContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *GrantResourcePrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGrantResourcePrivilege(s) + } +} + +func (s *GrantResourcePrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGrantResourcePrivilege(s) + } +} + +func (s *GrantResourcePrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGrantResourcePrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +type RevokeRoleContext struct { + SupportedGrantRevokeStatementContext + _identifierOrText IIdentifierOrTextContext + roles []IIdentifierOrTextContext +} + +func NewRevokeRoleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RevokeRoleContext { + var p = new(RevokeRoleContext) + + InitEmptySupportedGrantRevokeStatementContext(&p.SupportedGrantRevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedGrantRevokeStatementContext)) + + return p +} + +func (s *RevokeRoleContext) Get_identifierOrText() IIdentifierOrTextContext { + return s._identifierOrText +} + +func (s *RevokeRoleContext) Set_identifierOrText(v IIdentifierOrTextContext) { s._identifierOrText = v } + +func (s *RevokeRoleContext) GetRoles() []IIdentifierOrTextContext { return s.roles } + +func (s *RevokeRoleContext) SetRoles(v []IIdentifierOrTextContext) { s.roles = v } + +func (s *RevokeRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeRoleContext) REVOKE() antlr.TerminalNode { + return s.GetToken(DorisParserREVOKE, 0) +} + +func (s *RevokeRoleContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *RevokeRoleContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *RevokeRoleContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *RevokeRoleContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *RevokeRoleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *RevokeRoleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *RevokeRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRevokeRole(s) + } +} + +func (s *RevokeRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRevokeRole(s) + } +} + +func (s *RevokeRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRevokeRole(s) + + default: + return t.VisitChildren(s) + } +} + +type GrantTablePrivilegeContext struct { + SupportedGrantRevokeStatementContext +} + +func NewGrantTablePrivilegeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GrantTablePrivilegeContext { + var p = new(GrantTablePrivilegeContext) + + InitEmptySupportedGrantRevokeStatementContext(&p.SupportedGrantRevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedGrantRevokeStatementContext)) + + return p +} + +func (s *GrantTablePrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantTablePrivilegeContext) GRANT() antlr.TerminalNode { + return s.GetToken(DorisParserGRANT, 0) +} + +func (s *GrantTablePrivilegeContext) PrivilegeList() IPrivilegeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeListContext) +} + +func (s *GrantTablePrivilegeContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *GrantTablePrivilegeContext) MultipartIdentifierOrAsterisk() IMultipartIdentifierOrAsteriskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierOrAsteriskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierOrAsteriskContext) +} + +func (s *GrantTablePrivilegeContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *GrantTablePrivilegeContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *GrantTablePrivilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *GrantTablePrivilegeContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *GrantTablePrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGrantTablePrivilege(s) + } +} + +func (s *GrantTablePrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGrantTablePrivilege(s) + } +} + +func (s *GrantTablePrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGrantTablePrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +type GrantRoleContext struct { + SupportedGrantRevokeStatementContext + _identifierOrText IIdentifierOrTextContext + roles []IIdentifierOrTextContext +} + +func NewGrantRoleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GrantRoleContext { + var p = new(GrantRoleContext) + + InitEmptySupportedGrantRevokeStatementContext(&p.SupportedGrantRevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedGrantRevokeStatementContext)) + + return p +} + +func (s *GrantRoleContext) Get_identifierOrText() IIdentifierOrTextContext { + return s._identifierOrText +} + +func (s *GrantRoleContext) Set_identifierOrText(v IIdentifierOrTextContext) { s._identifierOrText = v } + +func (s *GrantRoleContext) GetRoles() []IIdentifierOrTextContext { return s.roles } + +func (s *GrantRoleContext) SetRoles(v []IIdentifierOrTextContext) { s.roles = v } + +func (s *GrantRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantRoleContext) GRANT() antlr.TerminalNode { + return s.GetToken(DorisParserGRANT, 0) +} + +func (s *GrantRoleContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *GrantRoleContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *GrantRoleContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *GrantRoleContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *GrantRoleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *GrantRoleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *GrantRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGrantRole(s) + } +} + +func (s *GrantRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGrantRole(s) + } +} + +func (s *GrantRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGrantRole(s) + + default: + return t.VisitChildren(s) + } +} + +type RevokeResourcePrivilegeContext struct { + SupportedGrantRevokeStatementContext +} + +func NewRevokeResourcePrivilegeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RevokeResourcePrivilegeContext { + var p = new(RevokeResourcePrivilegeContext) + + InitEmptySupportedGrantRevokeStatementContext(&p.SupportedGrantRevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedGrantRevokeStatementContext)) + + return p +} + +func (s *RevokeResourcePrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeResourcePrivilegeContext) REVOKE() antlr.TerminalNode { + return s.GetToken(DorisParserREVOKE, 0) +} + +func (s *RevokeResourcePrivilegeContext) PrivilegeList() IPrivilegeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeListContext) +} + +func (s *RevokeResourcePrivilegeContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *RevokeResourcePrivilegeContext) IdentifierOrTextOrAsterisk() IIdentifierOrTextOrAsteriskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextOrAsteriskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextOrAsteriskContext) +} + +func (s *RevokeResourcePrivilegeContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *RevokeResourcePrivilegeContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *RevokeResourcePrivilegeContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *RevokeResourcePrivilegeContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, 0) +} + +func (s *RevokeResourcePrivilegeContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *RevokeResourcePrivilegeContext) STAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGE, 0) +} + +func (s *RevokeResourcePrivilegeContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *RevokeResourcePrivilegeContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *RevokeResourcePrivilegeContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(DorisParserWORKLOAD, 0) +} + +func (s *RevokeResourcePrivilegeContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *RevokeResourcePrivilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *RevokeResourcePrivilegeContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *RevokeResourcePrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRevokeResourcePrivilege(s) + } +} + +func (s *RevokeResourcePrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRevokeResourcePrivilege(s) + } +} + +func (s *RevokeResourcePrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRevokeResourcePrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +type RevokeTablePrivilegeContext struct { + SupportedGrantRevokeStatementContext +} + +func NewRevokeTablePrivilegeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RevokeTablePrivilegeContext { + var p = new(RevokeTablePrivilegeContext) + + InitEmptySupportedGrantRevokeStatementContext(&p.SupportedGrantRevokeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedGrantRevokeStatementContext)) + + return p +} + +func (s *RevokeTablePrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeTablePrivilegeContext) REVOKE() antlr.TerminalNode { + return s.GetToken(DorisParserREVOKE, 0) +} + +func (s *RevokeTablePrivilegeContext) PrivilegeList() IPrivilegeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeListContext) +} + +func (s *RevokeTablePrivilegeContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *RevokeTablePrivilegeContext) MultipartIdentifierOrAsterisk() IMultipartIdentifierOrAsteriskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierOrAsteriskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierOrAsteriskContext) +} + +func (s *RevokeTablePrivilegeContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *RevokeTablePrivilegeContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *RevokeTablePrivilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(DorisParserROLE, 0) +} + +func (s *RevokeTablePrivilegeContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *RevokeTablePrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRevokeTablePrivilege(s) + } +} + +func (s *RevokeTablePrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRevokeTablePrivilege(s) + } +} + +func (s *RevokeTablePrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRevokeTablePrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedGrantRevokeStatement() (localctx ISupportedGrantRevokeStatementContext) { + localctx = NewSupportedGrantRevokeStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, DorisParserRULE_supportedGrantRevokeStatement) + var _la int + + p.SetState(3667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 496, p.GetParserRuleContext()) { + case 1: + localctx = NewGrantTablePrivilegeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3581) + p.Match(DorisParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3582) + p.PrivilegeList() + } + { + p.SetState(3583) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3584) + p.MultipartIdentifierOrAsterisk() + } + { + p.SetState(3585) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(3586) + p.UserIdentify() + } + + case DorisParserROLE: + { + p.SetState(3587) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3588) + p.IdentifierOrText() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + localctx = NewGrantResourcePrivilegeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3591) + p.Match(DorisParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3592) + p.PrivilegeList() + } + { + p.SetState(3593) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserRESOURCE: + { + p.SetState(3594) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCLUSTER: + { + p.SetState(3595) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOMPUTE: + { + p.SetState(3596) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3597) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSTAGE: + { + p.SetState(3598) + p.Match(DorisParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSTORAGE: + { + p.SetState(3599) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3600) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserWORKLOAD: + { + p.SetState(3601) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3602) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3605) + p.IdentifierOrTextOrAsterisk() + } + { + p.SetState(3606) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(3607) + p.UserIdentify() + } + + case DorisParserROLE: + { + p.SetState(3608) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3609) + p.IdentifierOrText() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + localctx = NewGrantRoleContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3612) + p.Match(DorisParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3613) + + var _x = p.IdentifierOrText() + + localctx.(*GrantRoleContext)._identifierOrText = _x + } + localctx.(*GrantRoleContext).roles = append(localctx.(*GrantRoleContext).roles, localctx.(*GrantRoleContext)._identifierOrText) + p.SetState(3618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3614) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3615) + + var _x = p.IdentifierOrText() + + localctx.(*GrantRoleContext)._identifierOrText = _x + } + localctx.(*GrantRoleContext).roles = append(localctx.(*GrantRoleContext).roles, localctx.(*GrantRoleContext)._identifierOrText) + + p.SetState(3620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3621) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3622) + p.UserIdentify() + } + + case 4: + localctx = NewRevokeRoleContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3624) + p.Match(DorisParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3625) + + var _x = p.IdentifierOrText() + + localctx.(*RevokeRoleContext)._identifierOrText = _x + } + localctx.(*RevokeRoleContext).roles = append(localctx.(*RevokeRoleContext).roles, localctx.(*RevokeRoleContext)._identifierOrText) + p.SetState(3630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3626) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3627) + + var _x = p.IdentifierOrText() + + localctx.(*RevokeRoleContext)._identifierOrText = _x + } + localctx.(*RevokeRoleContext).roles = append(localctx.(*RevokeRoleContext).roles, localctx.(*RevokeRoleContext)._identifierOrText) + + p.SetState(3632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3633) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3634) + p.UserIdentify() + } + + case 5: + localctx = NewRevokeResourcePrivilegeContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3636) + p.Match(DorisParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3637) + p.PrivilegeList() + } + { + p.SetState(3638) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserRESOURCE: + { + p.SetState(3639) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCLUSTER: + { + p.SetState(3640) + p.Match(DorisParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCOMPUTE: + { + p.SetState(3641) + p.Match(DorisParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3642) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSTAGE: + { + p.SetState(3643) + p.Match(DorisParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSTORAGE: + { + p.SetState(3644) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3645) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserWORKLOAD: + { + p.SetState(3646) + p.Match(DorisParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3647) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3650) + p.IdentifierOrTextOrAsterisk() + } + { + p.SetState(3651) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(3652) + p.UserIdentify() + } + + case DorisParserROLE: + { + p.SetState(3653) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3654) + p.IdentifierOrText() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + localctx = NewRevokeTablePrivilegeContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3657) + p.Match(DorisParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3658) + p.PrivilegeList() + } + { + p.SetState(3659) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3660) + p.MultipartIdentifierOrAsterisk() + } + { + p.SetState(3661) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(3662) + p.UserIdentify() + } + + case DorisParserROLE: + { + p.SetState(3663) + p.Match(DorisParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3664) + p.IdentifierOrText() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegeContext is an interface to support dynamic dispatch. +type IPrivilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // GetColumns returns the columns rule contexts. + GetColumns() IIdentifierListContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // SetColumns sets the columns rule contexts. + SetColumns(IIdentifierListContext) + + // Getter signatures + Identifier() IIdentifierContext + IdentifierList() IIdentifierListContext + ALL() antlr.TerminalNode + + // IsPrivilegeContext differentiates from other interfaces. + IsPrivilegeContext() +} + +type PrivilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext + columns IIdentifierListContext +} + +func NewEmptyPrivilegeContext() *PrivilegeContext { + var p = new(PrivilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_privilege + return p +} + +func InitEmptyPrivilegeContext(p *PrivilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_privilege +} + +func (*PrivilegeContext) IsPrivilegeContext() {} + +func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext { + var p = new(PrivilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_privilege + + return p +} + +func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegeContext) GetName() IIdentifierContext { return s.name } + +func (s *PrivilegeContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *PrivilegeContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *PrivilegeContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *PrivilegeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PrivilegeContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *PrivilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPrivilege(s) + } +} + +func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPrivilege(s) + } +} + +func (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Privilege() (localctx IPrivilegeContext) { + localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, DorisParserRULE_privilege) + var _la int + + p.SetState(3674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3669) + + var _x = p.Identifier() + + localctx.(*PrivilegeContext).name = _x + } + p.SetState(3671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(3670) + + var _x = p.IdentifierList() + + localctx.(*PrivilegeContext).columns = _x + } + + } + + case DorisParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3673) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegeListContext is an interface to support dynamic dispatch. +type IPrivilegeListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPrivilege() []IPrivilegeContext + Privilege(i int) IPrivilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrivilegeListContext differentiates from other interfaces. + IsPrivilegeListContext() +} + +type PrivilegeListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegeListContext() *PrivilegeListContext { + var p = new(PrivilegeListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_privilegeList + return p +} + +func InitEmptyPrivilegeListContext(p *PrivilegeListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_privilegeList +} + +func (*PrivilegeListContext) IsPrivilegeListContext() {} + +func NewPrivilegeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeListContext { + var p = new(PrivilegeListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_privilegeList + + return p +} + +func (s *PrivilegeListContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegeListContext) AllPrivilege() []IPrivilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivilegeContext); ok { + len++ + } + } + + tst := make([]IPrivilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivilegeContext); ok { + tst[i] = t.(IPrivilegeContext) + i++ + } + } + + return tst +} + +func (s *PrivilegeListContext) Privilege(i int) IPrivilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeContext) +} + +func (s *PrivilegeListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PrivilegeListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PrivilegeListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegeListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPrivilegeList(s) + } +} + +func (s *PrivilegeListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPrivilegeList(s) + } +} + +func (s *PrivilegeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPrivilegeList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PrivilegeList() (localctx IPrivilegeListContext) { + localctx = NewPrivilegeListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, DorisParserRULE_privilegeList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3676) + p.Privilege() + } + p.SetState(3681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3677) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3678) + p.Privilege() + } + + p.SetState(3683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterSystemClauseContext is an interface to support dynamic dispatch. +type IAlterSystemClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAlterSystemClauseContext differentiates from other interfaces. + IsAlterSystemClauseContext() +} + +type AlterSystemClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterSystemClauseContext() *AlterSystemClauseContext { + var p = new(AlterSystemClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_alterSystemClause + return p +} + +func InitEmptyAlterSystemClauseContext(p *AlterSystemClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_alterSystemClause +} + +func (*AlterSystemClauseContext) IsAlterSystemClauseContext() {} + +func NewAlterSystemClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterSystemClauseContext { + var p = new(AlterSystemClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_alterSystemClause + + return p +} + +func (s *AlterSystemClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterSystemClauseContext) CopyAll(ctx *AlterSystemClauseContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AlterSystemClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterSystemClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DropBrokerClauseContext struct { + AlterSystemClauseContext + name IIdentifierOrTextContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token +} + +func NewDropBrokerClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropBrokerClauseContext { + var p = new(DropBrokerClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *DropBrokerClauseContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *DropBrokerClauseContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *DropBrokerClauseContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *DropBrokerClauseContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *DropBrokerClauseContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *DropBrokerClauseContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *DropBrokerClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropBrokerClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropBrokerClauseContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *DropBrokerClauseContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DropBrokerClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *DropBrokerClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *DropBrokerClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *DropBrokerClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *DropBrokerClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropBrokerClause(s) + } +} + +func (s *DropBrokerClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropBrokerClause(s) + } +} + +func (s *DropBrokerClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropBrokerClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyFrontendOrBackendHostNameClauseContext struct { + AlterSystemClauseContext + hostPort antlr.Token + hostName antlr.Token +} + +func NewModifyFrontendOrBackendHostNameClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyFrontendOrBackendHostNameClauseContext { + var p = new(ModifyFrontendOrBackendHostNameClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) GetHostPort() antlr.Token { return s.hostPort } + +func (s *ModifyFrontendOrBackendHostNameClauseContext) GetHostName() antlr.Token { return s.hostName } + +func (s *ModifyFrontendOrBackendHostNameClauseContext) SetHostPort(v antlr.Token) { s.hostPort = v } + +func (s *ModifyFrontendOrBackendHostNameClauseContext) SetHostName(v antlr.Token) { s.hostName = v } + +func (s *ModifyFrontendOrBackendHostNameClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) HOSTNAME() antlr.TerminalNode { + return s.GetToken(DorisParserHOSTNAME, 0) +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) FRONTEND() antlr.TerminalNode { + return s.GetToken(DorisParserFRONTEND, 0) +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyFrontendOrBackendHostNameClause(s) + } +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyFrontendOrBackendHostNameClause(s) + } +} + +func (s *ModifyFrontendOrBackendHostNameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyFrontendOrBackendHostNameClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropObserverClauseContext struct { + AlterSystemClauseContext + hostPort antlr.Token +} + +func NewDropObserverClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropObserverClauseContext { + var p = new(DropObserverClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *DropObserverClauseContext) GetHostPort() antlr.Token { return s.hostPort } + +func (s *DropObserverClauseContext) SetHostPort(v antlr.Token) { s.hostPort = v } + +func (s *DropObserverClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropObserverClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropObserverClauseContext) OBSERVER() antlr.TerminalNode { + return s.GetToken(DorisParserOBSERVER, 0) +} + +func (s *DropObserverClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *DropObserverClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropObserverClause(s) + } +} + +func (s *DropObserverClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropObserverClause(s) + } +} + +func (s *DropObserverClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropObserverClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddFollowerClauseContext struct { + AlterSystemClauseContext + hostPort antlr.Token +} + +func NewAddFollowerClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddFollowerClauseContext { + var p = new(AddFollowerClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *AddFollowerClauseContext) GetHostPort() antlr.Token { return s.hostPort } + +func (s *AddFollowerClauseContext) SetHostPort(v antlr.Token) { s.hostPort = v } + +func (s *AddFollowerClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddFollowerClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddFollowerClauseContext) FOLLOWER() antlr.TerminalNode { + return s.GetToken(DorisParserFOLLOWER, 0) +} + +func (s *AddFollowerClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AddFollowerClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddFollowerClause(s) + } +} + +func (s *AddFollowerClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddFollowerClause(s) + } +} + +func (s *AddFollowerClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddFollowerClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropFollowerClauseContext struct { + AlterSystemClauseContext + hostPort antlr.Token +} + +func NewDropFollowerClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropFollowerClauseContext { + var p = new(DropFollowerClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *DropFollowerClauseContext) GetHostPort() antlr.Token { return s.hostPort } + +func (s *DropFollowerClauseContext) SetHostPort(v antlr.Token) { s.hostPort = v } + +func (s *DropFollowerClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropFollowerClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropFollowerClauseContext) FOLLOWER() antlr.TerminalNode { + return s.GetToken(DorisParserFOLLOWER, 0) +} + +func (s *DropFollowerClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *DropFollowerClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropFollowerClause(s) + } +} + +func (s *DropFollowerClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropFollowerClause(s) + } +} + +func (s *DropFollowerClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropFollowerClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropAllBrokerClauseContext struct { + AlterSystemClauseContext + name IIdentifierOrTextContext +} + +func NewDropAllBrokerClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropAllBrokerClauseContext { + var p = new(DropAllBrokerClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *DropAllBrokerClauseContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *DropAllBrokerClauseContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *DropAllBrokerClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropAllBrokerClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropAllBrokerClauseContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *DropAllBrokerClauseContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *DropAllBrokerClauseContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DropAllBrokerClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropAllBrokerClause(s) + } +} + +func (s *DropAllBrokerClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropAllBrokerClause(s) + } +} + +func (s *DropAllBrokerClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropAllBrokerClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropBackendClauseContext struct { + AlterSystemClauseContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token +} + +func NewDropBackendClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropBackendClauseContext { + var p = new(DropBackendClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *DropBackendClauseContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *DropBackendClauseContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *DropBackendClauseContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *DropBackendClauseContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *DropBackendClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropBackendClauseContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *DropBackendClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropBackendClauseContext) DROPP() antlr.TerminalNode { + return s.GetToken(DorisParserDROPP, 0) +} + +func (s *DropBackendClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *DropBackendClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *DropBackendClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *DropBackendClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *DropBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropBackendClause(s) + } +} + +func (s *DropBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropBackendClause(s) + } +} + +func (s *DropBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropBackendClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterLoadErrorUrlClauseContext struct { + AlterSystemClauseContext + properties IPropertyClauseContext +} + +func NewAlterLoadErrorUrlClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterLoadErrorUrlClauseContext { + var p = new(AlterLoadErrorUrlClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *AlterLoadErrorUrlClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AlterLoadErrorUrlClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterLoadErrorUrlClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterLoadErrorUrlClauseContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterLoadErrorUrlClauseContext) LOAD() antlr.TerminalNode { + return s.GetToken(DorisParserLOAD, 0) +} + +func (s *AlterLoadErrorUrlClauseContext) ERRORS() antlr.TerminalNode { + return s.GetToken(DorisParserERRORS, 0) +} + +func (s *AlterLoadErrorUrlClauseContext) HUB() antlr.TerminalNode { + return s.GetToken(DorisParserHUB, 0) +} + +func (s *AlterLoadErrorUrlClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterLoadErrorUrlClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterLoadErrorUrlClause(s) + } +} + +func (s *AlterLoadErrorUrlClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterLoadErrorUrlClause(s) + } +} + +func (s *AlterLoadErrorUrlClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterLoadErrorUrlClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyBackendClauseContext struct { + AlterSystemClauseContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token +} + +func NewModifyBackendClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyBackendClauseContext { + var p = new(ModifyBackendClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *ModifyBackendClauseContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *ModifyBackendClauseContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *ModifyBackendClauseContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *ModifyBackendClauseContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *ModifyBackendClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyBackendClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyBackendClauseContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *ModifyBackendClauseContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *ModifyBackendClauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ModifyBackendClauseContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *ModifyBackendClauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ModifyBackendClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *ModifyBackendClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *ModifyBackendClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ModifyBackendClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ModifyBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyBackendClause(s) + } +} + +func (s *ModifyBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyBackendClause(s) + } +} + +func (s *ModifyBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyBackendClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddBrokerClauseContext struct { + AlterSystemClauseContext + name IIdentifierOrTextContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token +} + +func NewAddBrokerClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddBrokerClauseContext { + var p = new(AddBrokerClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *AddBrokerClauseContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *AddBrokerClauseContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *AddBrokerClauseContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *AddBrokerClauseContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *AddBrokerClauseContext) GetName() IIdentifierOrTextContext { return s.name } + +func (s *AddBrokerClauseContext) SetName(v IIdentifierOrTextContext) { s.name = v } + +func (s *AddBrokerClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddBrokerClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddBrokerClauseContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *AddBrokerClauseContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *AddBrokerClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *AddBrokerClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *AddBrokerClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AddBrokerClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AddBrokerClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddBrokerClause(s) + } +} + +func (s *AddBrokerClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddBrokerClause(s) + } +} + +func (s *AddBrokerClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddBrokerClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddObserverClauseContext struct { + AlterSystemClauseContext + hostPort antlr.Token +} + +func NewAddObserverClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddObserverClauseContext { + var p = new(AddObserverClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *AddObserverClauseContext) GetHostPort() antlr.Token { return s.hostPort } + +func (s *AddObserverClauseContext) SetHostPort(v antlr.Token) { s.hostPort = v } + +func (s *AddObserverClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddObserverClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddObserverClauseContext) OBSERVER() antlr.TerminalNode { + return s.GetToken(DorisParserOBSERVER, 0) +} + +func (s *AddObserverClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AddObserverClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddObserverClause(s) + } +} + +func (s *AddObserverClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddObserverClause(s) + } +} + +func (s *AddObserverClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddObserverClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DecommissionBackendClauseContext struct { + AlterSystemClauseContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token +} + +func NewDecommissionBackendClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DecommissionBackendClauseContext { + var p = new(DecommissionBackendClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *DecommissionBackendClauseContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *DecommissionBackendClauseContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *DecommissionBackendClauseContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *DecommissionBackendClauseContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *DecommissionBackendClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DecommissionBackendClauseContext) DECOMMISSION() antlr.TerminalNode { + return s.GetToken(DorisParserDECOMMISSION, 0) +} + +func (s *DecommissionBackendClauseContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *DecommissionBackendClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *DecommissionBackendClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *DecommissionBackendClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *DecommissionBackendClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *DecommissionBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDecommissionBackendClause(s) + } +} + +func (s *DecommissionBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDecommissionBackendClause(s) + } +} + +func (s *DecommissionBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDecommissionBackendClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddBackendClauseContext struct { + AlterSystemClauseContext + _STRING_LITERAL antlr.Token + hostPorts []antlr.Token + properties IPropertyClauseContext +} + +func NewAddBackendClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddBackendClauseContext { + var p = new(AddBackendClauseContext) + + InitEmptyAlterSystemClauseContext(&p.AlterSystemClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterSystemClauseContext)) + + return p +} + +func (s *AddBackendClauseContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *AddBackendClauseContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *AddBackendClauseContext) GetHostPorts() []antlr.Token { return s.hostPorts } + +func (s *AddBackendClauseContext) SetHostPorts(v []antlr.Token) { s.hostPorts = v } + +func (s *AddBackendClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AddBackendClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AddBackendClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddBackendClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddBackendClauseContext) BACKEND() antlr.TerminalNode { + return s.GetToken(DorisParserBACKEND, 0) +} + +func (s *AddBackendClauseContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *AddBackendClauseContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *AddBackendClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AddBackendClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AddBackendClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AddBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddBackendClause(s) + } +} + +func (s *AddBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddBackendClause(s) + } +} + +func (s *AddBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddBackendClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AlterSystemClause() (localctx IAlterSystemClauseContext) { + localctx = NewAlterSystemClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, DorisParserRULE_alterSystemClause) + var _la int + + p.SetState(3782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 508, p.GetParserRuleContext()) { + case 1: + localctx = NewAddBackendClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3684) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3685) + p.Match(DorisParserBACKEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3686) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AddBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AddBackendClauseContext).hostPorts = append(localctx.(*AddBackendClauseContext).hostPorts, localctx.(*AddBackendClauseContext)._STRING_LITERAL) + p.SetState(3691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3687) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3688) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AddBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AddBackendClauseContext).hostPorts = append(localctx.(*AddBackendClauseContext).hostPorts, localctx.(*AddBackendClauseContext)._STRING_LITERAL) + + p.SetState(3693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3694) + + var _x = p.PropertyClause() + + localctx.(*AddBackendClauseContext).properties = _x + } + + } + + case 2: + localctx = NewDropBackendClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3697) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDROP || _la == DorisParserDROPP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3698) + p.Match(DorisParserBACKEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3699) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DropBackendClauseContext).hostPorts = append(localctx.(*DropBackendClauseContext).hostPorts, localctx.(*DropBackendClauseContext)._STRING_LITERAL) + p.SetState(3704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3700) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3701) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DropBackendClauseContext).hostPorts = append(localctx.(*DropBackendClauseContext).hostPorts, localctx.(*DropBackendClauseContext)._STRING_LITERAL) + + p.SetState(3706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + localctx = NewDecommissionBackendClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3707) + p.Match(DorisParserDECOMMISSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3708) + p.Match(DorisParserBACKEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3709) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DecommissionBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DecommissionBackendClauseContext).hostPorts = append(localctx.(*DecommissionBackendClauseContext).hostPorts, localctx.(*DecommissionBackendClauseContext)._STRING_LITERAL) + p.SetState(3714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3710) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3711) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DecommissionBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DecommissionBackendClauseContext).hostPorts = append(localctx.(*DecommissionBackendClauseContext).hostPorts, localctx.(*DecommissionBackendClauseContext)._STRING_LITERAL) + + p.SetState(3716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 4: + localctx = NewAddObserverClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3717) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3718) + p.Match(DorisParserOBSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3719) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AddObserverClauseContext).hostPort = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewDropObserverClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3720) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3721) + p.Match(DorisParserOBSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3722) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropObserverClauseContext).hostPort = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewAddFollowerClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3723) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3724) + p.Match(DorisParserFOLLOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3725) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AddFollowerClauseContext).hostPort = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + localctx = NewDropFollowerClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3726) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3727) + p.Match(DorisParserFOLLOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3728) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropFollowerClauseContext).hostPort = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewAddBrokerClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3729) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3730) + p.Match(DorisParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3731) + + var _x = p.IdentifierOrText() + + localctx.(*AddBrokerClauseContext).name = _x + } + { + p.SetState(3732) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AddBrokerClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AddBrokerClauseContext).hostPorts = append(localctx.(*AddBrokerClauseContext).hostPorts, localctx.(*AddBrokerClauseContext)._STRING_LITERAL) + p.SetState(3737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3733) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3734) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AddBrokerClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*AddBrokerClauseContext).hostPorts = append(localctx.(*AddBrokerClauseContext).hostPorts, localctx.(*AddBrokerClauseContext)._STRING_LITERAL) + + p.SetState(3739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 9: + localctx = NewDropBrokerClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3740) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3741) + p.Match(DorisParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3742) + + var _x = p.IdentifierOrText() + + localctx.(*DropBrokerClauseContext).name = _x + } + { + p.SetState(3743) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropBrokerClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DropBrokerClauseContext).hostPorts = append(localctx.(*DropBrokerClauseContext).hostPorts, localctx.(*DropBrokerClauseContext)._STRING_LITERAL) + p.SetState(3748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3744) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3745) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DropBrokerClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DropBrokerClauseContext).hostPorts = append(localctx.(*DropBrokerClauseContext).hostPorts, localctx.(*DropBrokerClauseContext)._STRING_LITERAL) + + p.SetState(3750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 10: + localctx = NewDropAllBrokerClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3751) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3752) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3753) + p.Match(DorisParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3754) + + var _x = p.IdentifierOrText() + + localctx.(*DropAllBrokerClauseContext).name = _x + } + + case 11: + localctx = NewAlterLoadErrorUrlClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3755) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3756) + p.Match(DorisParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3757) + p.Match(DorisParserERRORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3758) + p.Match(DorisParserHUB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3759) + + var _x = p.PropertyClause() + + localctx.(*AlterLoadErrorUrlClauseContext).properties = _x + } + + } + + case 12: + localctx = NewModifyBackendClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3762) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3763) + p.Match(DorisParserBACKEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3764) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ModifyBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*ModifyBackendClauseContext).hostPorts = append(localctx.(*ModifyBackendClauseContext).hostPorts, localctx.(*ModifyBackendClauseContext)._STRING_LITERAL) + p.SetState(3769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(3765) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3766) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ModifyBackendClauseContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*ModifyBackendClauseContext).hostPorts = append(localctx.(*ModifyBackendClauseContext).hostPorts, localctx.(*ModifyBackendClauseContext)._STRING_LITERAL) + + p.SetState(3771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3772) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3773) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3774) + p.PropertyItemList() + } + { + p.SetState(3775) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + localctx = NewModifyFrontendOrBackendHostNameClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3777) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3778) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBACKEND || _la == DorisParserFRONTEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3779) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ModifyFrontendOrBackendHostNameClauseContext).hostPort = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3780) + p.Match(DorisParserHOSTNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3781) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ModifyFrontendOrBackendHostNameClauseContext).hostName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropRollupClauseContext is an interface to support dynamic dispatch. +type IDropRollupClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRollupName returns the rollupName rule contexts. + GetRollupName() IIdentifierContext + + // GetProperties returns the properties rule contexts. + GetProperties() IPropertyClauseContext + + // SetRollupName sets the rollupName rule contexts. + SetRollupName(IIdentifierContext) + + // SetProperties sets the properties rule contexts. + SetProperties(IPropertyClauseContext) + + // Getter signatures + Identifier() IIdentifierContext + PropertyClause() IPropertyClauseContext + + // IsDropRollupClauseContext differentiates from other interfaces. + IsDropRollupClauseContext() +} + +type DropRollupClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rollupName IIdentifierContext + properties IPropertyClauseContext +} + +func NewEmptyDropRollupClauseContext() *DropRollupClauseContext { + var p = new(DropRollupClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dropRollupClause + return p +} + +func InitEmptyDropRollupClauseContext(p *DropRollupClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dropRollupClause +} + +func (*DropRollupClauseContext) IsDropRollupClauseContext() {} + +func NewDropRollupClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropRollupClauseContext { + var p = new(DropRollupClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dropRollupClause + + return p +} + +func (s *DropRollupClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropRollupClauseContext) GetRollupName() IIdentifierContext { return s.rollupName } + +func (s *DropRollupClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *DropRollupClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } + +func (s *DropRollupClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *DropRollupClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropRollupClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *DropRollupClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropRollupClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropRollupClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropRollupClause(s) + } +} + +func (s *DropRollupClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropRollupClause(s) + } +} + +func (s *DropRollupClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropRollupClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DropRollupClause() (localctx IDropRollupClauseContext) { + localctx = NewDropRollupClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, DorisParserRULE_dropRollupClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3784) + + var _x = p.Identifier() + + localctx.(*DropRollupClauseContext).rollupName = _x + } + p.SetState(3786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3785) + + var _x = p.PropertyClause() + + localctx.(*DropRollupClauseContext).properties = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAddRollupClauseContext is an interface to support dynamic dispatch. +type IAddRollupClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRollupName returns the rollupName rule contexts. + GetRollupName() IIdentifierContext + + // GetColumns returns the columns rule contexts. + GetColumns() IIdentifierListContext + + // GetDupKeys returns the dupKeys rule contexts. + GetDupKeys() IIdentifierListContext + + // GetProperties returns the properties rule contexts. + GetProperties() IPropertyClauseContext + + // SetRollupName sets the rollupName rule contexts. + SetRollupName(IIdentifierContext) + + // SetColumns sets the columns rule contexts. + SetColumns(IIdentifierListContext) + + // SetDupKeys sets the dupKeys rule contexts. + SetDupKeys(IIdentifierListContext) + + // SetProperties sets the properties rule contexts. + SetProperties(IPropertyClauseContext) + + // Getter signatures + Identifier() IIdentifierContext + AllIdentifierList() []IIdentifierListContext + IdentifierList(i int) IIdentifierListContext + DUPLICATE() antlr.TerminalNode + KEY() antlr.TerminalNode + FromRollup() IFromRollupContext + PropertyClause() IPropertyClauseContext + + // IsAddRollupClauseContext differentiates from other interfaces. + IsAddRollupClauseContext() +} + +type AddRollupClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rollupName IIdentifierContext + columns IIdentifierListContext + dupKeys IIdentifierListContext + properties IPropertyClauseContext +} + +func NewEmptyAddRollupClauseContext() *AddRollupClauseContext { + var p = new(AddRollupClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_addRollupClause + return p +} + +func InitEmptyAddRollupClauseContext(p *AddRollupClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_addRollupClause +} + +func (*AddRollupClauseContext) IsAddRollupClauseContext() {} + +func NewAddRollupClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddRollupClauseContext { + var p = new(AddRollupClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_addRollupClause + + return p +} + +func (s *AddRollupClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AddRollupClauseContext) GetRollupName() IIdentifierContext { return s.rollupName } + +func (s *AddRollupClauseContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *AddRollupClauseContext) GetDupKeys() IIdentifierListContext { return s.dupKeys } + +func (s *AddRollupClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AddRollupClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } + +func (s *AddRollupClauseContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *AddRollupClauseContext) SetDupKeys(v IIdentifierListContext) { s.dupKeys = v } + +func (s *AddRollupClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AddRollupClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AddRollupClauseContext) AllIdentifierList() []IIdentifierListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierListContext); ok { + len++ + } + } + + tst := make([]IIdentifierListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierListContext); ok { + tst[i] = t.(IIdentifierListContext) + i++ + } + } + + return tst +} + +func (s *AddRollupClauseContext) IdentifierList(i int) IIdentifierListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *AddRollupClauseContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(DorisParserDUPLICATE, 0) +} + +func (s *AddRollupClauseContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *AddRollupClauseContext) FromRollup() IFromRollupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromRollupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromRollupContext) +} + +func (s *AddRollupClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AddRollupClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddRollupClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AddRollupClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddRollupClause(s) + } +} + +func (s *AddRollupClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddRollupClause(s) + } +} + +func (s *AddRollupClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddRollupClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AddRollupClause() (localctx IAddRollupClauseContext) { + localctx = NewAddRollupClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, DorisParserRULE_addRollupClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3788) + + var _x = p.Identifier() + + localctx.(*AddRollupClauseContext).rollupName = _x + } + { + p.SetState(3789) + + var _x = p.IdentifierList() + + localctx.(*AddRollupClauseContext).columns = _x + } + p.SetState(3793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDUPLICATE { + { + p.SetState(3790) + p.Match(DorisParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3791) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3792) + + var _x = p.IdentifierList() + + localctx.(*AddRollupClauseContext).dupKeys = _x + } + + } + p.SetState(3796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(3795) + p.FromRollup() + } + + } + p.SetState(3799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3798) + + var _x = p.PropertyClause() + + localctx.(*AddRollupClauseContext).properties = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableClauseContext is an interface to support dynamic dispatch. +type IAlterTableClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsAlterTableClauseContext differentiates from other interfaces. + IsAlterTableClauseContext() +} + +type AlterTableClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableClauseContext() *AlterTableClauseContext { + var p = new(AlterTableClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_alterTableClause + return p +} + +func InitEmptyAlterTableClauseContext(p *AlterTableClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_alterTableClause +} + +func (*AlterTableClauseContext) IsAlterTableClauseContext() {} + +func NewAlterTableClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableClauseContext { + var p = new(AlterTableClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_alterTableClause + + return p +} + +func (s *AlterTableClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableClauseContext) CopyAll(ctx *AlterTableClauseContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *AlterTableClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ModifyDistributionClauseContext struct { + AlterTableClauseContext + hashKeys IIdentifierListContext + autoBucket antlr.Token +} + +func NewModifyDistributionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyDistributionClauseContext { + var p = new(ModifyDistributionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ModifyDistributionClauseContext) GetAutoBucket() antlr.Token { return s.autoBucket } + +func (s *ModifyDistributionClauseContext) SetAutoBucket(v antlr.Token) { s.autoBucket = v } + +func (s *ModifyDistributionClauseContext) GetHashKeys() IIdentifierListContext { return s.hashKeys } + +func (s *ModifyDistributionClauseContext) SetHashKeys(v IIdentifierListContext) { s.hashKeys = v } + +func (s *ModifyDistributionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyDistributionClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyDistributionClauseContext) DISTRIBUTION() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTION, 0) +} + +func (s *ModifyDistributionClauseContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTED, 0) +} + +func (s *ModifyDistributionClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *ModifyDistributionClauseContext) HASH() antlr.TerminalNode { + return s.GetToken(DorisParserHASH, 0) +} + +func (s *ModifyDistributionClauseContext) RANDOM() antlr.TerminalNode { + return s.GetToken(DorisParserRANDOM, 0) +} + +func (s *ModifyDistributionClauseContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ModifyDistributionClauseContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(DorisParserBUCKETS, 0) +} + +func (s *ModifyDistributionClauseContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ModifyDistributionClauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *ModifyDistributionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyDistributionClause(s) + } +} + +func (s *ModifyDistributionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyDistributionClause(s) + } +} + +func (s *ModifyDistributionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyDistributionClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddPartitionFieldClauseContext struct { + AlterTableClauseContext + partitionFieldName IIdentifierContext +} + +func NewAddPartitionFieldClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddPartitionFieldClauseContext { + var p = new(AddPartitionFieldClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *AddPartitionFieldClauseContext) GetPartitionFieldName() IIdentifierContext { + return s.partitionFieldName +} + +func (s *AddPartitionFieldClauseContext) SetPartitionFieldName(v IIdentifierContext) { + s.partitionFieldName = v +} + +func (s *AddPartitionFieldClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddPartitionFieldClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddPartitionFieldClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *AddPartitionFieldClauseContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *AddPartitionFieldClauseContext) PartitionTransform() IPartitionTransformContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionTransformContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionTransformContext) +} + +func (s *AddPartitionFieldClauseContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *AddPartitionFieldClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AddPartitionFieldClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddPartitionFieldClause(s) + } +} + +func (s *AddPartitionFieldClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddPartitionFieldClause(s) + } +} + +func (s *AddPartitionFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddPartitionFieldClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddColumnClauseContext struct { + AlterTableClauseContext + properties IPropertyClauseContext +} + +func NewAddColumnClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddColumnClauseContext { + var p = new(AddColumnClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *AddColumnClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AddColumnClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AddColumnClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddColumnClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddColumnClauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *AddColumnClauseContext) ColumnDef() IColumnDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefContext) +} + +func (s *AddColumnClauseContext) ColumnPosition() IColumnPositionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnPositionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnPositionContext) +} + +func (s *AddColumnClauseContext) ToRollup() IToRollupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IToRollupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IToRollupContext) +} + +func (s *AddColumnClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AddColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddColumnClause(s) + } +} + +func (s *AddColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddColumnClause(s) + } +} + +func (s *AddColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddColumnClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyColumnClauseContext struct { + AlterTableClauseContext + properties IPropertyClauseContext +} + +func NewModifyColumnClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyColumnClauseContext { + var p = new(ModifyColumnClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ModifyColumnClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *ModifyColumnClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *ModifyColumnClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyColumnClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyColumnClauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *ModifyColumnClauseContext) ColumnDef() IColumnDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefContext) +} + +func (s *ModifyColumnClauseContext) ColumnPosition() IColumnPositionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnPositionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnPositionContext) +} + +func (s *ModifyColumnClauseContext) FromRollup() IFromRollupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromRollupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromRollupContext) +} + +func (s *ModifyColumnClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ModifyColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyColumnClause(s) + } +} + +func (s *ModifyColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyColumnClause(s) + } +} + +func (s *ModifyColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyColumnClause(s) + + default: + return t.VisitChildren(s) + } +} + +type AddColumnsClauseContext struct { + AlterTableClauseContext + properties IPropertyClauseContext +} + +func NewAddColumnsClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddColumnsClauseContext { + var p = new(AddColumnsClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *AddColumnsClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AddColumnsClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AddColumnsClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddColumnsClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddColumnsClauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *AddColumnsClauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AddColumnsClauseContext) ColumnDefs() IColumnDefsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefsContext) +} + +func (s *AddColumnsClauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AddColumnsClauseContext) ToRollup() IToRollupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IToRollupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IToRollupContext) +} + +func (s *AddColumnsClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AddColumnsClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddColumnsClause(s) + } +} + +func (s *AddColumnsClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddColumnsClause(s) + } +} + +func (s *AddColumnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddColumnsClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ReplaceTableClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewReplaceTableClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplaceTableClauseContext { + var p = new(ReplaceTableClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ReplaceTableClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *ReplaceTableClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *ReplaceTableClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ReplaceTableClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *ReplaceTableClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplaceTableClauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *ReplaceTableClauseContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *ReplaceTableClauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ReplaceTableClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ReplaceTableClauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *ReplaceTableClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ReplaceTableClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplaceTableClause(s) + } +} + +func (s *ReplaceTableClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplaceTableClause(s) + } +} + +func (s *ReplaceTableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplaceTableClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropIndexClauseContext struct { + AlterTableClauseContext + name IIdentifierContext +} + +func NewDropIndexClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropIndexClauseContext { + var p = new(DropIndexClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *DropIndexClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *DropIndexClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropIndexClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropIndexClauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropIndexClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropIndexClauseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropIndexClauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropIndexClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropIndexClause(s) + } +} + +func (s *DropIndexClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropIndexClause(s) + } +} + +func (s *DropIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropIndexClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropPartitionClauseContext struct { + AlterTableClauseContext + partitionName IIdentifierContext + indexName IIdentifierContext +} + +func NewDropPartitionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropPartitionClauseContext { + var p = new(DropPartitionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *DropPartitionClauseContext) GetPartitionName() IIdentifierContext { return s.partitionName } + +func (s *DropPartitionClauseContext) GetIndexName() IIdentifierContext { return s.indexName } + +func (s *DropPartitionClauseContext) SetPartitionName(v IIdentifierContext) { s.partitionName = v } + +func (s *DropPartitionClauseContext) SetIndexName(v IIdentifierContext) { s.indexName = v } + +func (s *DropPartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropPartitionClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropPartitionClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *DropPartitionClauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *DropPartitionClauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropPartitionClauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *DropPartitionClauseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropPartitionClauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropPartitionClauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *DropPartitionClauseContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *DropPartitionClauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *DropPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropPartitionClause(s) + } +} + +func (s *DropPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropPartitionClause(s) + } +} + +func (s *DropPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropPartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ReplacePartitionClauseContext struct { + AlterTableClauseContext + partitions IPartitionSpecContext + tempPartitions IPartitionSpecContext + properties IPropertyClauseContext +} + +func NewReplacePartitionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplacePartitionClauseContext { + var p = new(ReplacePartitionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ReplacePartitionClauseContext) GetPartitions() IPartitionSpecContext { return s.partitions } + +func (s *ReplacePartitionClauseContext) GetTempPartitions() IPartitionSpecContext { + return s.tempPartitions +} + +func (s *ReplacePartitionClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *ReplacePartitionClauseContext) SetPartitions(v IPartitionSpecContext) { s.partitions = v } + +func (s *ReplacePartitionClauseContext) SetTempPartitions(v IPartitionSpecContext) { + s.tempPartitions = v +} + +func (s *ReplacePartitionClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *ReplacePartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplacePartitionClauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *ReplacePartitionClauseContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *ReplacePartitionClauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(DorisParserFORCE, 0) +} + +func (s *ReplacePartitionClauseContext) AllPartitionSpec() []IPartitionSpecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionSpecContext); ok { + len++ + } + } + + tst := make([]IPartitionSpecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionSpecContext); ok { + tst[i] = t.(IPartitionSpecContext) + i++ + } + } + + return tst +} + +func (s *ReplacePartitionClauseContext) PartitionSpec(i int) IPartitionSpecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *ReplacePartitionClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ReplacePartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplacePartitionClause(s) + } +} + +func (s *ReplacePartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplacePartitionClause(s) + } +} + +func (s *ReplacePartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplacePartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyTableCommentClauseContext struct { + AlterTableClauseContext + comment antlr.Token +} + +func NewModifyTableCommentClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyTableCommentClauseContext { + var p = new(ModifyTableCommentClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ModifyTableCommentClauseContext) GetComment() antlr.Token { return s.comment } + +func (s *ModifyTableCommentClauseContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *ModifyTableCommentClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyTableCommentClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyTableCommentClauseContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *ModifyTableCommentClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ModifyTableCommentClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyTableCommentClause(s) + } +} + +func (s *ModifyTableCommentClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyTableCommentClause(s) + } +} + +func (s *ModifyTableCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyTableCommentClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ReorderColumnsClauseContext struct { + AlterTableClauseContext + properties IPropertyClauseContext +} + +func NewReorderColumnsClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReorderColumnsClauseContext { + var p = new(ReorderColumnsClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ReorderColumnsClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *ReorderColumnsClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *ReorderColumnsClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReorderColumnsClauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(DorisParserORDER, 0) +} + +func (s *ReorderColumnsClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *ReorderColumnsClauseContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ReorderColumnsClauseContext) FromRollup() IFromRollupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromRollupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromRollupContext) +} + +func (s *ReorderColumnsClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ReorderColumnsClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReorderColumnsClause(s) + } +} + +func (s *ReorderColumnsClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReorderColumnsClause(s) + } +} + +func (s *ReorderColumnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReorderColumnsClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropBranchClausesContext struct { + AlterTableClauseContext +} + +func NewDropBranchClausesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropBranchClausesContext { + var p = new(DropBranchClausesContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *DropBranchClausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropBranchClausesContext) DropBranchClause() IDropBranchClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropBranchClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropBranchClauseContext) +} + +func (s *DropBranchClausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropBranchClauses(s) + } +} + +func (s *DropBranchClausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropBranchClauses(s) + } +} + +func (s *DropBranchClausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropBranchClauses(s) + + default: + return t.VisitChildren(s) + } +} + +type AddIndexClauseContext struct { + AlterTableClauseContext +} + +func NewAddIndexClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddIndexClauseContext { + var p = new(AddIndexClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *AddIndexClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddIndexClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddIndexClauseContext) IndexDef() IIndexDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexDefContext) +} + +func (s *AddIndexClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddIndexClause(s) + } +} + +func (s *AddIndexClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddIndexClause(s) + } +} + +func (s *AddIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddIndexClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyColumnCommentClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + comment antlr.Token +} + +func NewModifyColumnCommentClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyColumnCommentClauseContext { + var p = new(ModifyColumnCommentClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ModifyColumnCommentClauseContext) GetComment() antlr.Token { return s.comment } + +func (s *ModifyColumnCommentClauseContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *ModifyColumnCommentClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *ModifyColumnCommentClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ModifyColumnCommentClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyColumnCommentClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyColumnCommentClauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *ModifyColumnCommentClauseContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *ModifyColumnCommentClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ModifyColumnCommentClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ModifyColumnCommentClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyColumnCommentClause(s) + } +} + +func (s *ModifyColumnCommentClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyColumnCommentClause(s) + } +} + +func (s *ModifyColumnCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyColumnCommentClause(s) + + default: + return t.VisitChildren(s) + } +} + +type RenameColumnClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + newName IIdentifierContext +} + +func NewRenameColumnClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RenameColumnClauseContext { + var p = new(RenameColumnClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *RenameColumnClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *RenameColumnClauseContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *RenameColumnClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *RenameColumnClauseContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *RenameColumnClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameColumnClauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *RenameColumnClauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *RenameColumnClauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *RenameColumnClauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RenameColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRenameColumnClause(s) + } +} + +func (s *RenameColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRenameColumnClause(s) + } +} + +func (s *RenameColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRenameColumnClause(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateOrReplaceTagClausesContext struct { + AlterTableClauseContext +} + +func NewCreateOrReplaceTagClausesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateOrReplaceTagClausesContext { + var p = new(CreateOrReplaceTagClausesContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *CreateOrReplaceTagClausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateOrReplaceTagClausesContext) CreateOrReplaceTagClause() ICreateOrReplaceTagClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateOrReplaceTagClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateOrReplaceTagClauseContext) +} + +func (s *CreateOrReplaceTagClausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateOrReplaceTagClauses(s) + } +} + +func (s *CreateOrReplaceTagClausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateOrReplaceTagClauses(s) + } +} + +func (s *CreateOrReplaceTagClausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateOrReplaceTagClauses(s) + + default: + return t.VisitChildren(s) + } +} + +type DropPartitionFieldClauseContext struct { + AlterTableClauseContext + partitionFieldName IIdentifierContext +} + +func NewDropPartitionFieldClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropPartitionFieldClauseContext { + var p = new(DropPartitionFieldClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *DropPartitionFieldClauseContext) GetPartitionFieldName() IIdentifierContext { + return s.partitionFieldName +} + +func (s *DropPartitionFieldClauseContext) SetPartitionFieldName(v IIdentifierContext) { + s.partitionFieldName = v +} + +func (s *DropPartitionFieldClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropPartitionFieldClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropPartitionFieldClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *DropPartitionFieldClauseContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *DropPartitionFieldClauseContext) PartitionTransform() IPartitionTransformContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionTransformContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionTransformContext) +} + +func (s *DropPartitionFieldClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropPartitionFieldClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropPartitionFieldClause(s) + } +} + +func (s *DropPartitionFieldClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropPartitionFieldClause(s) + } +} + +func (s *DropPartitionFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropPartitionFieldClause(s) + + default: + return t.VisitChildren(s) + } +} + +type EnableFeatureClauseContext struct { + AlterTableClauseContext + name antlr.Token + properties IPropertyClauseContext +} + +func NewEnableFeatureClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EnableFeatureClauseContext { + var p = new(EnableFeatureClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *EnableFeatureClauseContext) GetName() antlr.Token { return s.name } + +func (s *EnableFeatureClauseContext) SetName(v antlr.Token) { s.name = v } + +func (s *EnableFeatureClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *EnableFeatureClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *EnableFeatureClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EnableFeatureClauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(DorisParserENABLE, 0) +} + +func (s *EnableFeatureClauseContext) FEATURE() antlr.TerminalNode { + return s.GetToken(DorisParserFEATURE, 0) +} + +func (s *EnableFeatureClauseContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *EnableFeatureClauseContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *EnableFeatureClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *EnableFeatureClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterEnableFeatureClause(s) + } +} + +func (s *EnableFeatureClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitEnableFeatureClause(s) + } +} + +func (s *EnableFeatureClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitEnableFeatureClause(s) + + default: + return t.VisitChildren(s) + } +} + +type CreateOrReplaceBranchClausesContext struct { + AlterTableClauseContext +} + +func NewCreateOrReplaceBranchClausesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateOrReplaceBranchClausesContext { + var p = new(CreateOrReplaceBranchClausesContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *CreateOrReplaceBranchClausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateOrReplaceBranchClausesContext) CreateOrReplaceBranchClause() ICreateOrReplaceBranchClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateOrReplaceBranchClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateOrReplaceBranchClauseContext) +} + +func (s *CreateOrReplaceBranchClausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateOrReplaceBranchClauses(s) + } +} + +func (s *CreateOrReplaceBranchClausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateOrReplaceBranchClauses(s) + } +} + +func (s *CreateOrReplaceBranchClausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateOrReplaceBranchClauses(s) + + default: + return t.VisitChildren(s) + } +} + +type AddPartitionClauseContext struct { + AlterTableClauseContext + hashKeys IIdentifierListContext + autoBucket antlr.Token + properties IPropertyClauseContext +} + +func NewAddPartitionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AddPartitionClauseContext { + var p = new(AddPartitionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *AddPartitionClauseContext) GetAutoBucket() antlr.Token { return s.autoBucket } + +func (s *AddPartitionClauseContext) SetAutoBucket(v antlr.Token) { s.autoBucket = v } + +func (s *AddPartitionClauseContext) GetHashKeys() IIdentifierListContext { return s.hashKeys } + +func (s *AddPartitionClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *AddPartitionClauseContext) SetHashKeys(v IIdentifierListContext) { s.hashKeys = v } + +func (s *AddPartitionClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AddPartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddPartitionClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AddPartitionClauseContext) PartitionDef() IPartitionDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefContext) +} + +func (s *AddPartitionClauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *AddPartitionClauseContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTED, 0) +} + +func (s *AddPartitionClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *AddPartitionClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AddPartitionClauseContext) HASH() antlr.TerminalNode { + return s.GetToken(DorisParserHASH, 0) +} + +func (s *AddPartitionClauseContext) RANDOM() antlr.TerminalNode { + return s.GetToken(DorisParserRANDOM, 0) +} + +func (s *AddPartitionClauseContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *AddPartitionClauseContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(DorisParserBUCKETS, 0) +} + +func (s *AddPartitionClauseContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *AddPartitionClauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *AddPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAddPartitionClause(s) + } +} + +func (s *AddPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAddPartitionClause(s) + } +} + +func (s *AddPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAddPartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ReplacePartitionFieldClauseContext struct { + AlterTableClauseContext + oldPartitionFieldName IIdentifierContext + oldPartitionTransform IPartitionTransformContext + newPartitionTransform IPartitionTransformContext + newPartitionFieldName IIdentifierContext +} + +func NewReplacePartitionFieldClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplacePartitionFieldClauseContext { + var p = new(ReplacePartitionFieldClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ReplacePartitionFieldClauseContext) GetOldPartitionFieldName() IIdentifierContext { + return s.oldPartitionFieldName +} + +func (s *ReplacePartitionFieldClauseContext) GetOldPartitionTransform() IPartitionTransformContext { + return s.oldPartitionTransform +} + +func (s *ReplacePartitionFieldClauseContext) GetNewPartitionTransform() IPartitionTransformContext { + return s.newPartitionTransform +} + +func (s *ReplacePartitionFieldClauseContext) GetNewPartitionFieldName() IIdentifierContext { + return s.newPartitionFieldName +} + +func (s *ReplacePartitionFieldClauseContext) SetOldPartitionFieldName(v IIdentifierContext) { + s.oldPartitionFieldName = v +} + +func (s *ReplacePartitionFieldClauseContext) SetOldPartitionTransform(v IPartitionTransformContext) { + s.oldPartitionTransform = v +} + +func (s *ReplacePartitionFieldClauseContext) SetNewPartitionTransform(v IPartitionTransformContext) { + s.newPartitionTransform = v +} + +func (s *ReplacePartitionFieldClauseContext) SetNewPartitionFieldName(v IIdentifierContext) { + s.newPartitionFieldName = v +} + +func (s *ReplacePartitionFieldClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplacePartitionFieldClauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *ReplacePartitionFieldClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *ReplacePartitionFieldClauseContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *ReplacePartitionFieldClauseContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *ReplacePartitionFieldClauseContext) AllPartitionTransform() []IPartitionTransformContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionTransformContext); ok { + len++ + } + } + + tst := make([]IPartitionTransformContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionTransformContext); ok { + tst[i] = t.(IPartitionTransformContext) + i++ + } + } + + return tst +} + +func (s *ReplacePartitionFieldClauseContext) PartitionTransform(i int) IPartitionTransformContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionTransformContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionTransformContext) +} + +func (s *ReplacePartitionFieldClauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *ReplacePartitionFieldClauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ReplacePartitionFieldClauseContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *ReplacePartitionFieldClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplacePartitionFieldClause(s) + } +} + +func (s *ReplacePartitionFieldClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplacePartitionFieldClause(s) + } +} + +func (s *ReplacePartitionFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplacePartitionFieldClause(s) + + default: + return t.VisitChildren(s) + } +} + +type RenameRollupClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + newName IIdentifierContext +} + +func NewRenameRollupClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RenameRollupClauseContext { + var p = new(RenameRollupClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *RenameRollupClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *RenameRollupClauseContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *RenameRollupClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *RenameRollupClauseContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *RenameRollupClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameRollupClauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *RenameRollupClauseContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *RenameRollupClauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *RenameRollupClauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RenameRollupClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRenameRollupClause(s) + } +} + +func (s *RenameRollupClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRenameRollupClause(s) + } +} + +func (s *RenameRollupClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRenameRollupClause(s) + + default: + return t.VisitChildren(s) + } +} + +type RenamePartitionClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + newName IIdentifierContext +} + +func NewRenamePartitionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RenamePartitionClauseContext { + var p = new(RenamePartitionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *RenamePartitionClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *RenamePartitionClauseContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *RenamePartitionClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *RenamePartitionClauseContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *RenamePartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenamePartitionClauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *RenamePartitionClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *RenamePartitionClauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *RenamePartitionClauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RenamePartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRenamePartitionClause(s) + } +} + +func (s *RenamePartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRenamePartitionClause(s) + } +} + +func (s *RenamePartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRenamePartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropColumnClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewDropColumnClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropColumnClauseContext { + var p = new(DropColumnClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *DropColumnClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *DropColumnClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *DropColumnClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropColumnClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *DropColumnClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropColumnClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropColumnClauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *DropColumnClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropColumnClauseContext) FromRollup() IFromRollupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromRollupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromRollupContext) +} + +func (s *DropColumnClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *DropColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropColumnClause(s) + } +} + +func (s *DropColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropColumnClause(s) + } +} + +func (s *DropColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropColumnClause(s) + + default: + return t.VisitChildren(s) + } +} + +type RenameClauseContext struct { + AlterTableClauseContext + newName IIdentifierContext +} + +func NewRenameClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RenameClauseContext { + var p = new(RenameClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *RenameClauseContext) GetNewName() IIdentifierContext { return s.newName } + +func (s *RenameClauseContext) SetNewName(v IIdentifierContext) { s.newName = v } + +func (s *RenameClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenameClauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(DorisParserRENAME, 0) +} + +func (s *RenameClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RenameClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRenameClause(s) + } +} + +func (s *RenameClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRenameClause(s) + } +} + +func (s *RenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRenameClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyPartitionClauseContext struct { + AlterTableClauseContext + partitionName IIdentifierContext + partitionNames IIdentifierListContext + partitionProperties IPropertyItemListContext +} + +func NewModifyPartitionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyPartitionClauseContext { + var p = new(ModifyPartitionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ModifyPartitionClauseContext) GetPartitionName() IIdentifierContext { return s.partitionName } + +func (s *ModifyPartitionClauseContext) GetPartitionNames() IIdentifierListContext { + return s.partitionNames +} + +func (s *ModifyPartitionClauseContext) GetPartitionProperties() IPropertyItemListContext { + return s.partitionProperties +} + +func (s *ModifyPartitionClauseContext) SetPartitionName(v IIdentifierContext) { s.partitionName = v } + +func (s *ModifyPartitionClauseContext) SetPartitionNames(v IIdentifierListContext) { + s.partitionNames = v +} + +func (s *ModifyPartitionClauseContext) SetPartitionProperties(v IPropertyItemListContext) { + s.partitionProperties = v +} + +func (s *ModifyPartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyPartitionClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyPartitionClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *ModifyPartitionClauseContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *ModifyPartitionClauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *ModifyPartitionClauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *ModifyPartitionClauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *ModifyPartitionClauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *ModifyPartitionClauseContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *ModifyPartitionClauseContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *ModifyPartitionClauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *ModifyPartitionClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ModifyPartitionClauseContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ModifyPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyPartitionClause(s) + } +} + +func (s *ModifyPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyPartitionClause(s) + } +} + +func (s *ModifyPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyPartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +type ModifyEngineClauseContext struct { + AlterTableClauseContext + name IIdentifierContext + properties IPropertyClauseContext +} + +func NewModifyEngineClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ModifyEngineClauseContext { + var p = new(ModifyEngineClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *ModifyEngineClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *ModifyEngineClauseContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *ModifyEngineClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *ModifyEngineClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *ModifyEngineClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModifyEngineClauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *ModifyEngineClauseContext) ENGINE() antlr.TerminalNode { + return s.GetToken(DorisParserENGINE, 0) +} + +func (s *ModifyEngineClauseContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *ModifyEngineClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ModifyEngineClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *ModifyEngineClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterModifyEngineClause(s) + } +} + +func (s *ModifyEngineClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitModifyEngineClause(s) + } +} + +func (s *ModifyEngineClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitModifyEngineClause(s) + + default: + return t.VisitChildren(s) + } +} + +type DropTagClausesContext struct { + AlterTableClauseContext +} + +func NewDropTagClausesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropTagClausesContext { + var p = new(DropTagClausesContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *DropTagClausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTagClausesContext) DropTagClause() IDropTagClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTagClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTagClauseContext) +} + +func (s *DropTagClausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropTagClauses(s) + } +} + +func (s *DropTagClausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropTagClauses(s) + } +} + +func (s *DropTagClausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropTagClauses(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterMultiPartitionClauseContext struct { + AlterTableClauseContext + from IPartitionValueListContext + to IPartitionValueListContext + unit IIdentifierContext + properties IPropertyClauseContext +} + +func NewAlterMultiPartitionClauseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterMultiPartitionClauseContext { + var p = new(AlterMultiPartitionClauseContext) + + InitEmptyAlterTableClauseContext(&p.AlterTableClauseContext) + p.parser = parser + p.CopyAll(ctx.(*AlterTableClauseContext)) + + return p +} + +func (s *AlterMultiPartitionClauseContext) GetFrom() IPartitionValueListContext { return s.from } + +func (s *AlterMultiPartitionClauseContext) GetTo() IPartitionValueListContext { return s.to } + +func (s *AlterMultiPartitionClauseContext) GetUnit() IIdentifierContext { return s.unit } + +func (s *AlterMultiPartitionClauseContext) GetProperties() IPropertyClauseContext { + return s.properties +} + +func (s *AlterMultiPartitionClauseContext) SetFrom(v IPartitionValueListContext) { s.from = v } + +func (s *AlterMultiPartitionClauseContext) SetTo(v IPartitionValueListContext) { s.to = v } + +func (s *AlterMultiPartitionClauseContext) SetUnit(v IIdentifierContext) { s.unit = v } + +func (s *AlterMultiPartitionClauseContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *AlterMultiPartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterMultiPartitionClauseContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *AlterMultiPartitionClauseContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITIONS, 0) +} + +func (s *AlterMultiPartitionClauseContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *AlterMultiPartitionClauseContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *AlterMultiPartitionClauseContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(DorisParserINTERVAL, 0) +} + +func (s *AlterMultiPartitionClauseContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *AlterMultiPartitionClauseContext) AllPartitionValueList() []IPartitionValueListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionValueListContext); ok { + len++ + } + } + + tst := make([]IPartitionValueListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionValueListContext); ok { + tst[i] = t.(IPartitionValueListContext) + i++ + } + } + + return tst +} + +func (s *AlterMultiPartitionClauseContext) PartitionValueList(i int) IPartitionValueListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionValueListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionValueListContext) +} + +func (s *AlterMultiPartitionClauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *AlterMultiPartitionClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterMultiPartitionClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AlterMultiPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterMultiPartitionClause(s) + } +} + +func (s *AlterMultiPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterMultiPartitionClause(s) + } +} + +func (s *AlterMultiPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterMultiPartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AlterTableClause() (localctx IAlterTableClauseContext) { + localctx = NewAlterTableClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, DorisParserRULE_alterTableClause) + var _la int + + p.SetState(4053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) { + case 1: + localctx = NewAddColumnClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3801) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3802) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3803) + p.ColumnDef() + } + p.SetState(3805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAFTER || _la == DorisParserFIRST { + { + p.SetState(3804) + p.ColumnPosition() + } + + } + p.SetState(3808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIN || _la == DorisParserTO { + { + p.SetState(3807) + p.ToRollup() + } + + } + p.SetState(3811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3810) + + var _x = p.PropertyClause() + + localctx.(*AddColumnClauseContext).properties = _x + } + + } + + case 2: + localctx = NewAddColumnsClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3813) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3814) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3815) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3816) + p.ColumnDefs() + } + { + p.SetState(3817) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIN || _la == DorisParserTO { + { + p.SetState(3818) + p.ToRollup() + } + + } + p.SetState(3822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3821) + + var _x = p.PropertyClause() + + localctx.(*AddColumnsClauseContext).properties = _x + } + + } + + case 3: + localctx = NewDropColumnClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3824) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3825) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3826) + + var _x = p.Identifier() + + localctx.(*DropColumnClauseContext).name = _x + } + p.SetState(3828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(3827) + p.FromRollup() + } + + } + p.SetState(3831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3830) + + var _x = p.PropertyClause() + + localctx.(*DropColumnClauseContext).properties = _x + } + + } + + case 4: + localctx = NewModifyColumnClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3833) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3834) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3835) + p.ColumnDef() + } + p.SetState(3837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAFTER || _la == DorisParserFIRST { + { + p.SetState(3836) + p.ColumnPosition() + } + + } + p.SetState(3840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(3839) + p.FromRollup() + } + + } + p.SetState(3843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3842) + + var _x = p.PropertyClause() + + localctx.(*ModifyColumnClauseContext).properties = _x + } + + } + + case 5: + localctx = NewReorderColumnsClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3845) + p.Match(DorisParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3846) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3847) + p.IdentifierList() + } + p.SetState(3849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(3848) + p.FromRollup() + } + + } + p.SetState(3852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3851) + + var _x = p.PropertyClause() + + localctx.(*ReorderColumnsClauseContext).properties = _x + } + + } + + case 6: + localctx = NewAddPartitionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3854) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(3855) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3858) + p.PartitionDef() + } + p.SetState(3873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDISTRIBUTED { + { + p.SetState(3859) + p.Match(DorisParserDISTRIBUTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3860) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserHASH: + { + p.SetState(3861) + p.Match(DorisParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3862) + + var _x = p.IdentifierList() + + localctx.(*AddPartitionClauseContext).hashKeys = _x + } + + case DorisParserRANDOM: + { + p.SetState(3863) + p.Match(DorisParserRANDOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBUCKETS { + { + p.SetState(3866) + p.Match(DorisParserBUCKETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserINTEGER_VALUE: + { + p.SetState(3867) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserAUTO: + { + p.SetState(3868) + + var _m = p.Match(DorisParserAUTO) + + localctx.(*AddPartitionClauseContext).autoBucket = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + } + p.SetState(3876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3875) + + var _x = p.PropertyClause() + + localctx.(*AddPartitionClauseContext).properties = _x + } + + } + + case 7: + localctx = NewDropPartitionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3878) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(3879) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3882) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(3883) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3884) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3887) + + var _x = p.Identifier() + + localctx.(*DropPartitionClauseContext).partitionName = _x + } + p.SetState(3889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(3888) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM { + { + p.SetState(3891) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3892) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3893) + + var _x = p.Identifier() + + localctx.(*DropPartitionClauseContext).indexName = _x + } + + } + + case 8: + localctx = NewModifyPartitionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3896) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(3897) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3900) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3901) + + var _x = p.Identifier() + + localctx.(*ModifyPartitionClauseContext).partitionName = _x + } + + case 2: + { + p.SetState(3902) + + var _x = p.IdentifierList() + + localctx.(*ModifyPartitionClauseContext).partitionNames = _x + } + + case 3: + { + p.SetState(3903) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3904) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3905) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3908) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3909) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3910) + + var _x = p.PropertyItemList() + + localctx.(*ModifyPartitionClauseContext).partitionProperties = _x + } + { + p.SetState(3911) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewReplacePartitionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3913) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(3914) + + var _x = p.PartitionSpec() + + localctx.(*ReplacePartitionClauseContext).partitions = _x + } + + } + { + p.SetState(3917) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(3918) + + var _x = p.PartitionSpec() + + localctx.(*ReplacePartitionClauseContext).tempPartitions = _x + } + + } + p.SetState(3922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(3921) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3924) + + var _x = p.PropertyClause() + + localctx.(*ReplacePartitionClauseContext).properties = _x + } + + } + + case 10: + localctx = NewReplaceTableClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3927) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3928) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3929) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3930) + + var _x = p.Identifier() + + localctx.(*ReplaceTableClauseContext).name = _x + } + p.SetState(3932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(3931) + + var _x = p.PropertyClause() + + localctx.(*ReplaceTableClauseContext).properties = _x + } + + } + p.SetState(3935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORCE { + { + p.SetState(3934) + p.Match(DorisParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 11: + localctx = NewRenameClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3937) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3938) + + var _x = p.Identifier() + + localctx.(*RenameClauseContext).newName = _x + } + + case 12: + localctx = NewRenameRollupClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3939) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3940) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3941) + + var _x = p.Identifier() + + localctx.(*RenameRollupClauseContext).name = _x + } + { + p.SetState(3942) + + var _x = p.Identifier() + + localctx.(*RenameRollupClauseContext).newName = _x + } + + case 13: + localctx = NewRenamePartitionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3944) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3945) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3946) + + var _x = p.Identifier() + + localctx.(*RenamePartitionClauseContext).name = _x + } + { + p.SetState(3947) + + var _x = p.Identifier() + + localctx.(*RenamePartitionClauseContext).newName = _x + } + + case 14: + localctx = NewRenameColumnClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(3949) + p.Match(DorisParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3950) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3951) + + var _x = p.Identifier() + + localctx.(*RenameColumnClauseContext).name = _x + } + { + p.SetState(3952) + + var _x = p.Identifier() + + localctx.(*RenameColumnClauseContext).newName = _x + } + + case 15: + localctx = NewAddIndexClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(3954) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3955) + p.IndexDef() + } + + case 16: + localctx = NewDropIndexClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(3956) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3957) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(3958) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3959) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3962) + + var _x = p.Identifier() + + localctx.(*DropIndexClauseContext).name = _x + } + + case 17: + localctx = NewEnableFeatureClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(3963) + p.Match(DorisParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3964) + p.Match(DorisParserFEATURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3965) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*EnableFeatureClauseContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(3966) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3967) + + var _x = p.PropertyClause() + + localctx.(*EnableFeatureClauseContext).properties = _x + } + + } + + case 18: + localctx = NewModifyDistributionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(3970) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3971) + p.Match(DorisParserDISTRIBUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDISTRIBUTED { + { + p.SetState(3972) + p.Match(DorisParserDISTRIBUTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3973) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserHASH: + { + p.SetState(3974) + p.Match(DorisParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3975) + + var _x = p.IdentifierList() + + localctx.(*ModifyDistributionClauseContext).hashKeys = _x + } + + case DorisParserRANDOM: + { + p.SetState(3976) + p.Match(DorisParserRANDOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBUCKETS { + { + p.SetState(3979) + p.Match(DorisParserBUCKETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserINTEGER_VALUE: + { + p.SetState(3980) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserAUTO: + { + p.SetState(3981) + + var _m = p.Match(DorisParserAUTO) + + localctx.(*ModifyDistributionClauseContext).autoBucket = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + } + + case 19: + localctx = NewModifyTableCommentClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(3988) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3989) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3990) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ModifyTableCommentClauseContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + localctx = NewModifyColumnCommentClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(3991) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3992) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3993) + + var _x = p.Identifier() + + localctx.(*ModifyColumnCommentClauseContext).name = _x + } + { + p.SetState(3994) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3995) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ModifyColumnCommentClauseContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + localctx = NewModifyEngineClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(3997) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3998) + p.Match(DorisParserENGINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3999) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4000) + + var _x = p.Identifier() + + localctx.(*ModifyEngineClauseContext).name = _x + } + p.SetState(4002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4001) + + var _x = p.PropertyClause() + + localctx.(*ModifyEngineClauseContext).properties = _x + } + + } + + case 22: + localctx = NewAlterMultiPartitionClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(4004) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(4005) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4008) + p.Match(DorisParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4009) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4010) + + var _x = p.PartitionValueList() + + localctx.(*AlterMultiPartitionClauseContext).from = _x + } + { + p.SetState(4011) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4012) + + var _x = p.PartitionValueList() + + localctx.(*AlterMultiPartitionClauseContext).to = _x + } + { + p.SetState(4013) + p.Match(DorisParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4014) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4016) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 551, p.GetParserRuleContext()) == 1 { + { + p.SetState(4015) + + var _x = p.Identifier() + + localctx.(*AlterMultiPartitionClauseContext).unit = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4018) + + var _x = p.PropertyClause() + + localctx.(*AlterMultiPartitionClauseContext).properties = _x + } + + } + + case 23: + localctx = NewCreateOrReplaceTagClausesContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(4021) + p.CreateOrReplaceTagClause() + } + + case 24: + localctx = NewCreateOrReplaceBranchClausesContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(4022) + p.CreateOrReplaceBranchClause() + } + + case 25: + localctx = NewDropBranchClausesContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(4023) + p.DropBranchClause() + } + + case 26: + localctx = NewDropTagClausesContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(4024) + p.DropTagClause() + } + + case 27: + localctx = NewAddPartitionFieldClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 27) + { + p.SetState(4025) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4026) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4027) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4028) + p.PartitionTransform() + } + p.SetState(4031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(4029) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4030) + + var _x = p.Identifier() + + localctx.(*AddPartitionFieldClauseContext).partitionFieldName = _x + } + + } + + case 28: + localctx = NewDropPartitionFieldClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 28) + { + p.SetState(4033) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4034) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4035) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 554, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4036) + + var _x = p.Identifier() + + localctx.(*DropPartitionFieldClauseContext).partitionFieldName = _x + } + + case 2: + { + p.SetState(4037) + p.PartitionTransform() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 29: + localctx = NewReplacePartitionFieldClauseContext(p, localctx) + p.EnterOuterAlt(localctx, 29) + { + p.SetState(4040) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4041) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4042) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4043) + + var _x = p.Identifier() + + localctx.(*ReplacePartitionFieldClauseContext).oldPartitionFieldName = _x + } + + case 2: + { + p.SetState(4044) + + var _x = p.PartitionTransform() + + localctx.(*ReplacePartitionFieldClauseContext).oldPartitionTransform = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4047) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4048) + + var _x = p.PartitionTransform() + + localctx.(*ReplacePartitionFieldClauseContext).newPartitionTransform = _x + } + p.SetState(4051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(4049) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4050) + + var _x = p.Identifier() + + localctx.(*ReplacePartitionFieldClauseContext).newPartitionFieldName = _x + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateOrReplaceTagClauseContext is an interface to support dynamic dispatch. +type ICreateOrReplaceTagClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // GetOps returns the ops rule contexts. + GetOps() ITagOptionsContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // SetOps sets the ops rule contexts. + SetOps(ITagOptionsContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TAG() antlr.TerminalNode + Identifier() IIdentifierContext + TagOptions() ITagOptionsContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + REPLACE() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsCreateOrReplaceTagClauseContext differentiates from other interfaces. + IsCreateOrReplaceTagClauseContext() +} + +type CreateOrReplaceTagClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext + ops ITagOptionsContext +} + +func NewEmptyCreateOrReplaceTagClauseContext() *CreateOrReplaceTagClauseContext { + var p = new(CreateOrReplaceTagClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_createOrReplaceTagClause + return p +} + +func InitEmptyCreateOrReplaceTagClauseContext(p *CreateOrReplaceTagClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_createOrReplaceTagClause +} + +func (*CreateOrReplaceTagClauseContext) IsCreateOrReplaceTagClauseContext() {} + +func NewCreateOrReplaceTagClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateOrReplaceTagClauseContext { + var p = new(CreateOrReplaceTagClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_createOrReplaceTagClause + + return p +} + +func (s *CreateOrReplaceTagClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateOrReplaceTagClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateOrReplaceTagClauseContext) GetOps() ITagOptionsContext { return s.ops } + +func (s *CreateOrReplaceTagClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateOrReplaceTagClauseContext) SetOps(v ITagOptionsContext) { s.ops = v } + +func (s *CreateOrReplaceTagClauseContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateOrReplaceTagClauseContext) TAG() antlr.TerminalNode { + return s.GetToken(DorisParserTAG, 0) +} + +func (s *CreateOrReplaceTagClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateOrReplaceTagClauseContext) TagOptions() ITagOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITagOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITagOptionsContext) +} + +func (s *CreateOrReplaceTagClauseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateOrReplaceTagClauseContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateOrReplaceTagClauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateOrReplaceTagClauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *CreateOrReplaceTagClauseContext) OR() antlr.TerminalNode { + return s.GetToken(DorisParserOR, 0) +} + +func (s *CreateOrReplaceTagClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateOrReplaceTagClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateOrReplaceTagClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateOrReplaceTagClause(s) + } +} + +func (s *CreateOrReplaceTagClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateOrReplaceTagClause(s) + } +} + +func (s *CreateOrReplaceTagClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateOrReplaceTagClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTagClauseContext) { + localctx = NewCreateOrReplaceTagClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, DorisParserRULE_createOrReplaceTagClause) + var _la int + + p.SetState(4074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 560, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4055) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4056) + p.Match(DorisParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(4057) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4058) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4059) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4062) + + var _x = p.Identifier() + + localctx.(*CreateOrReplaceTagClauseContext).name = _x + } + { + p.SetState(4063) + + var _x = p.TagOptions() + + localctx.(*CreateOrReplaceTagClauseContext).ops = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(4067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCREATE { + { + p.SetState(4065) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4066) + p.Match(DorisParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4069) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4070) + p.Match(DorisParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4071) + + var _x = p.Identifier() + + localctx.(*CreateOrReplaceTagClauseContext).name = _x + } + { + p.SetState(4072) + + var _x = p.TagOptions() + + localctx.(*CreateOrReplaceTagClauseContext).ops = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateOrReplaceBranchClauseContext is an interface to support dynamic dispatch. +type ICreateOrReplaceBranchClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // GetOps returns the ops rule contexts. + GetOps() IBranchOptionsContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // SetOps sets the ops rule contexts. + SetOps(IBranchOptionsContext) + + // Getter signatures + CREATE() antlr.TerminalNode + BRANCH() antlr.TerminalNode + Identifier() IIdentifierContext + BranchOptions() IBranchOptionsContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + REPLACE() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsCreateOrReplaceBranchClauseContext differentiates from other interfaces. + IsCreateOrReplaceBranchClauseContext() +} + +type CreateOrReplaceBranchClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext + ops IBranchOptionsContext +} + +func NewEmptyCreateOrReplaceBranchClauseContext() *CreateOrReplaceBranchClauseContext { + var p = new(CreateOrReplaceBranchClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_createOrReplaceBranchClause + return p +} + +func InitEmptyCreateOrReplaceBranchClauseContext(p *CreateOrReplaceBranchClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_createOrReplaceBranchClause +} + +func (*CreateOrReplaceBranchClauseContext) IsCreateOrReplaceBranchClauseContext() {} + +func NewCreateOrReplaceBranchClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateOrReplaceBranchClauseContext { + var p = new(CreateOrReplaceBranchClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_createOrReplaceBranchClause + + return p +} + +func (s *CreateOrReplaceBranchClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateOrReplaceBranchClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *CreateOrReplaceBranchClauseContext) GetOps() IBranchOptionsContext { return s.ops } + +func (s *CreateOrReplaceBranchClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *CreateOrReplaceBranchClauseContext) SetOps(v IBranchOptionsContext) { s.ops = v } + +func (s *CreateOrReplaceBranchClauseContext) CREATE() antlr.TerminalNode { + return s.GetToken(DorisParserCREATE, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) BRANCH() antlr.TerminalNode { + return s.GetToken(DorisParserBRANCH, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CreateOrReplaceBranchClauseContext) BranchOptions() IBranchOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBranchOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBranchOptionsContext) +} + +func (s *CreateOrReplaceBranchClauseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) OR() antlr.TerminalNode { + return s.GetToken(DorisParserOR, 0) +} + +func (s *CreateOrReplaceBranchClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateOrReplaceBranchClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateOrReplaceBranchClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCreateOrReplaceBranchClause(s) + } +} + +func (s *CreateOrReplaceBranchClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCreateOrReplaceBranchClause(s) + } +} + +func (s *CreateOrReplaceBranchClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCreateOrReplaceBranchClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplaceBranchClauseContext) { + localctx = NewCreateOrReplaceBranchClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, DorisParserRULE_createOrReplaceBranchClause) + var _la int + + p.SetState(4095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 563, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4076) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4077) + p.Match(DorisParserBRANCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(4078) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4079) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4080) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4083) + + var _x = p.Identifier() + + localctx.(*CreateOrReplaceBranchClauseContext).name = _x + } + { + p.SetState(4084) + + var _x = p.BranchOptions() + + localctx.(*CreateOrReplaceBranchClauseContext).ops = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(4088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCREATE { + { + p.SetState(4086) + p.Match(DorisParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4087) + p.Match(DorisParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4090) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4091) + p.Match(DorisParserBRANCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4092) + + var _x = p.Identifier() + + localctx.(*CreateOrReplaceBranchClauseContext).name = _x + } + { + p.SetState(4093) + + var _x = p.BranchOptions() + + localctx.(*CreateOrReplaceBranchClauseContext).ops = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITagOptionsContext is an interface to support dynamic dispatch. +type ITagOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetVersion returns the version token. + GetVersion() antlr.Token + + // SetVersion sets the version token. + SetVersion(antlr.Token) + + // Getter signatures + AS() antlr.TerminalNode + OF() antlr.TerminalNode + VERSION() antlr.TerminalNode + RetainTime() IRetainTimeContext + INTEGER_VALUE() antlr.TerminalNode + + // IsTagOptionsContext differentiates from other interfaces. + IsTagOptionsContext() +} + +type TagOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + version antlr.Token +} + +func NewEmptyTagOptionsContext() *TagOptionsContext { + var p = new(TagOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tagOptions + return p +} + +func InitEmptyTagOptionsContext(p *TagOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tagOptions +} + +func (*TagOptionsContext) IsTagOptionsContext() {} + +func NewTagOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TagOptionsContext { + var p = new(TagOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_tagOptions + + return p +} + +func (s *TagOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TagOptionsContext) GetVersion() antlr.Token { return s.version } + +func (s *TagOptionsContext) SetVersion(v antlr.Token) { s.version = v } + +func (s *TagOptionsContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *TagOptionsContext) OF() antlr.TerminalNode { + return s.GetToken(DorisParserOF, 0) +} + +func (s *TagOptionsContext) VERSION() antlr.TerminalNode { + return s.GetToken(DorisParserVERSION, 0) +} + +func (s *TagOptionsContext) RetainTime() IRetainTimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRetainTimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRetainTimeContext) +} + +func (s *TagOptionsContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *TagOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TagOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TagOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTagOptions(s) + } +} + +func (s *TagOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTagOptions(s) + } +} + +func (s *TagOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTagOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TagOptions() (localctx ITagOptionsContext) { + localctx = NewTagOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, DorisParserRULE_tagOptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(4097) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4098) + p.Match(DorisParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4099) + p.Match(DorisParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4100) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*TagOptionsContext).version = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserRETAIN { + { + p.SetState(4103) + p.RetainTime() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBranchOptionsContext is an interface to support dynamic dispatch. +type IBranchOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetVersion returns the version token. + GetVersion() antlr.Token + + // SetVersion sets the version token. + SetVersion(antlr.Token) + + // Getter signatures + AS() antlr.TerminalNode + OF() antlr.TerminalNode + VERSION() antlr.TerminalNode + RetainTime() IRetainTimeContext + RetentionSnapshot() IRetentionSnapshotContext + INTEGER_VALUE() antlr.TerminalNode + + // IsBranchOptionsContext differentiates from other interfaces. + IsBranchOptionsContext() +} + +type BranchOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + version antlr.Token +} + +func NewEmptyBranchOptionsContext() *BranchOptionsContext { + var p = new(BranchOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_branchOptions + return p +} + +func InitEmptyBranchOptionsContext(p *BranchOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_branchOptions +} + +func (*BranchOptionsContext) IsBranchOptionsContext() {} + +func NewBranchOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BranchOptionsContext { + var p = new(BranchOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_branchOptions + + return p +} + +func (s *BranchOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *BranchOptionsContext) GetVersion() antlr.Token { return s.version } + +func (s *BranchOptionsContext) SetVersion(v antlr.Token) { s.version = v } + +func (s *BranchOptionsContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *BranchOptionsContext) OF() antlr.TerminalNode { + return s.GetToken(DorisParserOF, 0) +} + +func (s *BranchOptionsContext) VERSION() antlr.TerminalNode { + return s.GetToken(DorisParserVERSION, 0) +} + +func (s *BranchOptionsContext) RetainTime() IRetainTimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRetainTimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRetainTimeContext) +} + +func (s *BranchOptionsContext) RetentionSnapshot() IRetentionSnapshotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRetentionSnapshotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRetentionSnapshotContext) +} + +func (s *BranchOptionsContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *BranchOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BranchOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BranchOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBranchOptions(s) + } +} + +func (s *BranchOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBranchOptions(s) + } +} + +func (s *BranchOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBranchOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) BranchOptions() (localctx IBranchOptionsContext) { + localctx = NewBranchOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, DorisParserRULE_branchOptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(4106) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4107) + p.Match(DorisParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4108) + p.Match(DorisParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4109) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*BranchOptionsContext).version = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserRETAIN { + { + p.SetState(4112) + p.RetainTime() + } + + } + p.SetState(4116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(4115) + p.RetentionSnapshot() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRetainTimeContext is an interface to support dynamic dispatch. +type IRetainTimeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETAIN() antlr.TerminalNode + TimeValueWithUnit() ITimeValueWithUnitContext + + // IsRetainTimeContext differentiates from other interfaces. + IsRetainTimeContext() +} + +type RetainTimeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRetainTimeContext() *RetainTimeContext { + var p = new(RetainTimeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_retainTime + return p +} + +func InitEmptyRetainTimeContext(p *RetainTimeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_retainTime +} + +func (*RetainTimeContext) IsRetainTimeContext() {} + +func NewRetainTimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RetainTimeContext { + var p = new(RetainTimeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_retainTime + + return p +} + +func (s *RetainTimeContext) GetParser() antlr.Parser { return s.parser } + +func (s *RetainTimeContext) RETAIN() antlr.TerminalNode { + return s.GetToken(DorisParserRETAIN, 0) +} + +func (s *RetainTimeContext) TimeValueWithUnit() ITimeValueWithUnitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeValueWithUnitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeValueWithUnitContext) +} + +func (s *RetainTimeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RetainTimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RetainTimeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRetainTime(s) + } +} + +func (s *RetainTimeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRetainTime(s) + } +} + +func (s *RetainTimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRetainTime(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RetainTime() (localctx IRetainTimeContext) { + localctx = NewRetainTimeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, DorisParserRULE_retainTime) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4118) + p.Match(DorisParserRETAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4119) + p.TimeValueWithUnit() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRetentionSnapshotContext is an interface to support dynamic dispatch. +type IRetentionSnapshotContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + RETENTION() antlr.TerminalNode + MinSnapshotsToKeep() IMinSnapshotsToKeepContext + TimeValueWithUnit() ITimeValueWithUnitContext + + // IsRetentionSnapshotContext differentiates from other interfaces. + IsRetentionSnapshotContext() +} + +type RetentionSnapshotContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRetentionSnapshotContext() *RetentionSnapshotContext { + var p = new(RetentionSnapshotContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_retentionSnapshot + return p +} + +func InitEmptyRetentionSnapshotContext(p *RetentionSnapshotContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_retentionSnapshot +} + +func (*RetentionSnapshotContext) IsRetentionSnapshotContext() {} + +func NewRetentionSnapshotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RetentionSnapshotContext { + var p = new(RetentionSnapshotContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_retentionSnapshot + + return p +} + +func (s *RetentionSnapshotContext) GetParser() antlr.Parser { return s.parser } + +func (s *RetentionSnapshotContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *RetentionSnapshotContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *RetentionSnapshotContext) RETENTION() antlr.TerminalNode { + return s.GetToken(DorisParserRETENTION, 0) +} + +func (s *RetentionSnapshotContext) MinSnapshotsToKeep() IMinSnapshotsToKeepContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMinSnapshotsToKeepContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMinSnapshotsToKeepContext) +} + +func (s *RetentionSnapshotContext) TimeValueWithUnit() ITimeValueWithUnitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeValueWithUnitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeValueWithUnitContext) +} + +func (s *RetentionSnapshotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RetentionSnapshotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RetentionSnapshotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRetentionSnapshot(s) + } +} + +func (s *RetentionSnapshotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRetentionSnapshot(s) + } +} + +func (s *RetentionSnapshotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRetentionSnapshot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RetentionSnapshot() (localctx IRetentionSnapshotContext) { + localctx = NewRetentionSnapshotContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, DorisParserRULE_retentionSnapshot) + p.SetState(4135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 569, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4121) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4122) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4123) + p.Match(DorisParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4124) + p.MinSnapshotsToKeep() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4125) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4126) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4127) + p.Match(DorisParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4128) + p.TimeValueWithUnit() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4129) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4130) + p.Match(DorisParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4131) + p.Match(DorisParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4132) + p.MinSnapshotsToKeep() + } + { + p.SetState(4133) + p.TimeValueWithUnit() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMinSnapshotsToKeepContext is an interface to support dynamic dispatch. +type IMinSnapshotsToKeepContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetValue returns the value token. + GetValue() antlr.Token + + // SetValue sets the value token. + SetValue(antlr.Token) + + // Getter signatures + SNAPSHOTS() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + + // IsMinSnapshotsToKeepContext differentiates from other interfaces. + IsMinSnapshotsToKeepContext() +} + +type MinSnapshotsToKeepContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + value antlr.Token +} + +func NewEmptyMinSnapshotsToKeepContext() *MinSnapshotsToKeepContext { + var p = new(MinSnapshotsToKeepContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_minSnapshotsToKeep + return p +} + +func InitEmptyMinSnapshotsToKeepContext(p *MinSnapshotsToKeepContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_minSnapshotsToKeep +} + +func (*MinSnapshotsToKeepContext) IsMinSnapshotsToKeepContext() {} + +func NewMinSnapshotsToKeepContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MinSnapshotsToKeepContext { + var p = new(MinSnapshotsToKeepContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_minSnapshotsToKeep + + return p +} + +func (s *MinSnapshotsToKeepContext) GetParser() antlr.Parser { return s.parser } + +func (s *MinSnapshotsToKeepContext) GetValue() antlr.Token { return s.value } + +func (s *MinSnapshotsToKeepContext) SetValue(v antlr.Token) { s.value = v } + +func (s *MinSnapshotsToKeepContext) SNAPSHOTS() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOTS, 0) +} + +func (s *MinSnapshotsToKeepContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *MinSnapshotsToKeepContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MinSnapshotsToKeepContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MinSnapshotsToKeepContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMinSnapshotsToKeep(s) + } +} + +func (s *MinSnapshotsToKeepContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMinSnapshotsToKeep(s) + } +} + +func (s *MinSnapshotsToKeepContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMinSnapshotsToKeep(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MinSnapshotsToKeep() (localctx IMinSnapshotsToKeepContext) { + localctx = NewMinSnapshotsToKeepContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, DorisParserRULE_minSnapshotsToKeep) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4137) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*MinSnapshotsToKeepContext).value = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4138) + p.Match(DorisParserSNAPSHOTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITimeValueWithUnitContext is an interface to support dynamic dispatch. +type ITimeValueWithUnitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTimeValue returns the timeValue token. + GetTimeValue() antlr.Token + + // GetTimeUnit returns the timeUnit token. + GetTimeUnit() antlr.Token + + // SetTimeValue sets the timeValue token. + SetTimeValue(antlr.Token) + + // SetTimeUnit sets the timeUnit token. + SetTimeUnit(antlr.Token) + + // Getter signatures + INTEGER_VALUE() antlr.TerminalNode + DAYS() antlr.TerminalNode + HOURS() antlr.TerminalNode + MINUTES() antlr.TerminalNode + + // IsTimeValueWithUnitContext differentiates from other interfaces. + IsTimeValueWithUnitContext() +} + +type TimeValueWithUnitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + timeValue antlr.Token + timeUnit antlr.Token +} + +func NewEmptyTimeValueWithUnitContext() *TimeValueWithUnitContext { + var p = new(TimeValueWithUnitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_timeValueWithUnit + return p +} + +func InitEmptyTimeValueWithUnitContext(p *TimeValueWithUnitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_timeValueWithUnit +} + +func (*TimeValueWithUnitContext) IsTimeValueWithUnitContext() {} + +func NewTimeValueWithUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimeValueWithUnitContext { + var p = new(TimeValueWithUnitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_timeValueWithUnit + + return p +} + +func (s *TimeValueWithUnitContext) GetParser() antlr.Parser { return s.parser } + +func (s *TimeValueWithUnitContext) GetTimeValue() antlr.Token { return s.timeValue } + +func (s *TimeValueWithUnitContext) GetTimeUnit() antlr.Token { return s.timeUnit } + +func (s *TimeValueWithUnitContext) SetTimeValue(v antlr.Token) { s.timeValue = v } + +func (s *TimeValueWithUnitContext) SetTimeUnit(v antlr.Token) { s.timeUnit = v } + +func (s *TimeValueWithUnitContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *TimeValueWithUnitContext) DAYS() antlr.TerminalNode { + return s.GetToken(DorisParserDAYS, 0) +} + +func (s *TimeValueWithUnitContext) HOURS() antlr.TerminalNode { + return s.GetToken(DorisParserHOURS, 0) +} + +func (s *TimeValueWithUnitContext) MINUTES() antlr.TerminalNode { + return s.GetToken(DorisParserMINUTES, 0) +} + +func (s *TimeValueWithUnitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TimeValueWithUnitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TimeValueWithUnitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTimeValueWithUnit(s) + } +} + +func (s *TimeValueWithUnitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTimeValueWithUnit(s) + } +} + +func (s *TimeValueWithUnitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTimeValueWithUnit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TimeValueWithUnit() (localctx ITimeValueWithUnitContext) { + localctx = NewTimeValueWithUnitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, DorisParserRULE_timeValueWithUnit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4140) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*TimeValueWithUnitContext).timeValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4141) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TimeValueWithUnitContext).timeUnit = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDAYS || _la == DorisParserHOURS || _la == DorisParserMINUTES) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TimeValueWithUnitContext).timeUnit = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropBranchClauseContext is an interface to support dynamic dispatch. +type IDropBranchClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // Getter signatures + DROP() antlr.TerminalNode + BRANCH() antlr.TerminalNode + Identifier() IIdentifierContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDropBranchClauseContext differentiates from other interfaces. + IsDropBranchClauseContext() +} + +type DropBranchClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext +} + +func NewEmptyDropBranchClauseContext() *DropBranchClauseContext { + var p = new(DropBranchClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dropBranchClause + return p +} + +func InitEmptyDropBranchClauseContext(p *DropBranchClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dropBranchClause +} + +func (*DropBranchClauseContext) IsDropBranchClauseContext() {} + +func NewDropBranchClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropBranchClauseContext { + var p = new(DropBranchClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dropBranchClause + + return p +} + +func (s *DropBranchClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropBranchClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *DropBranchClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropBranchClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropBranchClauseContext) BRANCH() antlr.TerminalNode { + return s.GetToken(DorisParserBRANCH, 0) +} + +func (s *DropBranchClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropBranchClauseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropBranchClauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropBranchClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropBranchClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropBranchClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropBranchClause(s) + } +} + +func (s *DropBranchClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropBranchClause(s) + } +} + +func (s *DropBranchClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropBranchClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DropBranchClause() (localctx IDropBranchClauseContext) { + localctx = NewDropBranchClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, DorisParserRULE_dropBranchClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4143) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4144) + p.Match(DorisParserBRANCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(4145) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4146) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4149) + + var _x = p.Identifier() + + localctx.(*DropBranchClauseContext).name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTagClauseContext is an interface to support dynamic dispatch. +type IDropTagClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IIdentifierContext + + // SetName sets the name rule contexts. + SetName(IIdentifierContext) + + // Getter signatures + DROP() antlr.TerminalNode + TAG() antlr.TerminalNode + Identifier() IIdentifierContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDropTagClauseContext differentiates from other interfaces. + IsDropTagClauseContext() +} + +type DropTagClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IIdentifierContext +} + +func NewEmptyDropTagClauseContext() *DropTagClauseContext { + var p = new(DropTagClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dropTagClause + return p +} + +func InitEmptyDropTagClauseContext(p *DropTagClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dropTagClause +} + +func (*DropTagClauseContext) IsDropTagClauseContext() {} + +func NewDropTagClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTagClauseContext { + var p = new(DropTagClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dropTagClause + + return p +} + +func (s *DropTagClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTagClauseContext) GetName() IIdentifierContext { return s.name } + +func (s *DropTagClauseContext) SetName(v IIdentifierContext) { s.name = v } + +func (s *DropTagClauseContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropTagClauseContext) TAG() antlr.TerminalNode { + return s.GetToken(DorisParserTAG, 0) +} + +func (s *DropTagClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DropTagClauseContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *DropTagClauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *DropTagClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTagClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTagClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropTagClause(s) + } +} + +func (s *DropTagClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropTagClause(s) + } +} + +func (s *DropTagClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropTagClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DropTagClause() (localctx IDropTagClauseContext) { + localctx = NewDropTagClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, DorisParserRULE_dropTagClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4151) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4152) + p.Match(DorisParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(4153) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4154) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4157) + + var _x = p.Identifier() + + localctx.(*DropTagClauseContext).name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionTransformContext is an interface to support dynamic dispatch. +type IPartitionTransformContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPartitionTransformContext differentiates from other interfaces. + IsPartitionTransformContext() +} + +type PartitionTransformContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionTransformContext() *PartitionTransformContext { + var p = new(PartitionTransformContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionTransform + return p +} + +func InitEmptyPartitionTransformContext(p *PartitionTransformContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionTransform +} + +func (*PartitionTransformContext) IsPartitionTransformContext() {} + +func NewPartitionTransformContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionTransformContext { + var p = new(PartitionTransformContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionTransform + + return p +} + +func (s *PartitionTransformContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionTransformContext) CopyAll(ctx *PartitionTransformContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PartitionTransformContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionTransformContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type PartitionTransformWithColumnContext struct { + PartitionTransformContext +} + +func NewPartitionTransformWithColumnContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionTransformWithColumnContext { + var p = new(PartitionTransformWithColumnContext) + + InitEmptyPartitionTransformContext(&p.PartitionTransformContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionTransformContext)) + + return p +} + +func (s *PartitionTransformWithColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionTransformWithColumnContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *PartitionTransformWithColumnContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PartitionTransformWithColumnContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PartitionTransformWithColumnContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PartitionTransformWithColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionTransformWithColumn(s) + } +} + +func (s *PartitionTransformWithColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionTransformWithColumn(s) + } +} + +func (s *PartitionTransformWithColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionTransformWithColumn(s) + + default: + return t.VisitChildren(s) + } +} + +type PartitionTransformWithArgsContext struct { + PartitionTransformContext +} + +func NewPartitionTransformWithArgsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionTransformWithArgsContext { + var p = new(PartitionTransformWithArgsContext) + + InitEmptyPartitionTransformContext(&p.PartitionTransformContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionTransformContext)) + + return p +} + +func (s *PartitionTransformWithArgsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionTransformWithArgsContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *PartitionTransformWithArgsContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PartitionTransformWithArgsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PartitionTransformWithArgsContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *PartitionTransformWithArgsContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *PartitionTransformWithArgsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PartitionTransformWithArgsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionTransformWithArgs(s) + } +} + +func (s *PartitionTransformWithArgsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionTransformWithArgs(s) + } +} + +func (s *PartitionTransformWithArgsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionTransformWithArgs(s) + + default: + return t.VisitChildren(s) + } +} + +type PartitionTransformIdentityContext struct { + PartitionTransformContext +} + +func NewPartitionTransformIdentityContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PartitionTransformIdentityContext { + var p = new(PartitionTransformIdentityContext) + + InitEmptyPartitionTransformContext(&p.PartitionTransformContext) + p.parser = parser + p.CopyAll(ctx.(*PartitionTransformContext)) + + return p +} + +func (s *PartitionTransformIdentityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionTransformIdentityContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PartitionTransformIdentityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionTransformIdentity(s) + } +} + +func (s *PartitionTransformIdentityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionTransformIdentity(s) + } +} + +func (s *PartitionTransformIdentityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionTransformIdentity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionTransform() (localctx IPartitionTransformContext) { + localctx = NewPartitionTransformContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, DorisParserRULE_partitionTransform) + p.SetState(4172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 572, p.GetParserRuleContext()) { + case 1: + localctx = NewPartitionTransformWithArgsContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4159) + p.Identifier() + } + { + p.SetState(4160) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4161) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4162) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4163) + p.Identifier() + } + { + p.SetState(4164) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewPartitionTransformWithColumnContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4166) + p.Identifier() + } + { + p.SetState(4167) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4168) + p.Identifier() + } + { + p.SetState(4169) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewPartitionTransformIdentityContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4171) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnPositionContext is an interface to support dynamic dispatch. +type IColumnPositionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPosition returns the position rule contexts. + GetPosition() IIdentifierContext + + // SetPosition sets the position rule contexts. + SetPosition(IIdentifierContext) + + // Getter signatures + FIRST() antlr.TerminalNode + AFTER() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsColumnPositionContext differentiates from other interfaces. + IsColumnPositionContext() +} + +type ColumnPositionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + position IIdentifierContext +} + +func NewEmptyColumnPositionContext() *ColumnPositionContext { + var p = new(ColumnPositionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnPosition + return p +} + +func InitEmptyColumnPositionContext(p *ColumnPositionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnPosition +} + +func (*ColumnPositionContext) IsColumnPositionContext() {} + +func NewColumnPositionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnPositionContext { + var p = new(ColumnPositionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_columnPosition + + return p +} + +func (s *ColumnPositionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnPositionContext) GetPosition() IIdentifierContext { return s.position } + +func (s *ColumnPositionContext) SetPosition(v IIdentifierContext) { s.position = v } + +func (s *ColumnPositionContext) FIRST() antlr.TerminalNode { + return s.GetToken(DorisParserFIRST, 0) +} + +func (s *ColumnPositionContext) AFTER() antlr.TerminalNode { + return s.GetToken(DorisParserAFTER, 0) +} + +func (s *ColumnPositionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ColumnPositionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnPositionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnPositionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColumnPosition(s) + } +} + +func (s *ColumnPositionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColumnPosition(s) + } +} + +func (s *ColumnPositionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColumnPosition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ColumnPosition() (localctx IColumnPositionContext) { + localctx = NewColumnPositionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, DorisParserRULE_columnPosition) + p.SetState(4177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserFIRST: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4174) + p.Match(DorisParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserAFTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4175) + p.Match(DorisParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4176) + + var _x = p.Identifier() + + localctx.(*ColumnPositionContext).position = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IToRollupContext is an interface to support dynamic dispatch. +type IToRollupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRollup returns the rollup rule contexts. + GetRollup() IIdentifierContext + + // SetRollup sets the rollup rule contexts. + SetRollup(IIdentifierContext) + + // Getter signatures + TO() antlr.TerminalNode + IN() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsToRollupContext differentiates from other interfaces. + IsToRollupContext() +} + +type ToRollupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rollup IIdentifierContext +} + +func NewEmptyToRollupContext() *ToRollupContext { + var p = new(ToRollupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_toRollup + return p +} + +func InitEmptyToRollupContext(p *ToRollupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_toRollup +} + +func (*ToRollupContext) IsToRollupContext() {} + +func NewToRollupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ToRollupContext { + var p = new(ToRollupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_toRollup + + return p +} + +func (s *ToRollupContext) GetParser() antlr.Parser { return s.parser } + +func (s *ToRollupContext) GetRollup() IIdentifierContext { return s.rollup } + +func (s *ToRollupContext) SetRollup(v IIdentifierContext) { s.rollup = v } + +func (s *ToRollupContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *ToRollupContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *ToRollupContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ToRollupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ToRollupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ToRollupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterToRollup(s) + } +} + +func (s *ToRollupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitToRollup(s) + } +} + +func (s *ToRollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitToRollup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ToRollup() (localctx IToRollupContext) { + localctx = NewToRollupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, DorisParserRULE_toRollup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4179) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserIN || _la == DorisParserTO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4180) + + var _x = p.Identifier() + + localctx.(*ToRollupContext).rollup = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromRollupContext is an interface to support dynamic dispatch. +type IFromRollupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRollup returns the rollup rule contexts. + GetRollup() IIdentifierContext + + // SetRollup sets the rollup rule contexts. + SetRollup(IIdentifierContext) + + // Getter signatures + FROM() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsFromRollupContext differentiates from other interfaces. + IsFromRollupContext() +} + +type FromRollupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rollup IIdentifierContext +} + +func NewEmptyFromRollupContext() *FromRollupContext { + var p = new(FromRollupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_fromRollup + return p +} + +func InitEmptyFromRollupContext(p *FromRollupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_fromRollup +} + +func (*FromRollupContext) IsFromRollupContext() {} + +func NewFromRollupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromRollupContext { + var p = new(FromRollupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_fromRollup + + return p +} + +func (s *FromRollupContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromRollupContext) GetRollup() IIdentifierContext { return s.rollup } + +func (s *FromRollupContext) SetRollup(v IIdentifierContext) { s.rollup = v } + +func (s *FromRollupContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *FromRollupContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *FromRollupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromRollupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromRollupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFromRollup(s) + } +} + +func (s *FromRollupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFromRollup(s) + } +} + +func (s *FromRollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFromRollup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FromRollup() (localctx IFromRollupContext) { + localctx = NewFromRollupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, DorisParserRULE_fromRollup) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4182) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4183) + + var _x = p.Identifier() + + localctx.(*FromRollupContext).rollup = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedStatsStatementContext is an interface to support dynamic dispatch. +type ISupportedStatsStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedStatsStatementContext differentiates from other interfaces. + IsSupportedStatsStatementContext() +} + +type SupportedStatsStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedStatsStatementContext() *SupportedStatsStatementContext { + var p = new(SupportedStatsStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedStatsStatement + return p +} + +func InitEmptySupportedStatsStatementContext(p *SupportedStatsStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedStatsStatement +} + +func (*SupportedStatsStatementContext) IsSupportedStatsStatementContext() {} + +func NewSupportedStatsStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedStatsStatementContext { + var p = new(SupportedStatsStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedStatsStatement + + return p +} + +func (s *SupportedStatsStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedStatsStatementContext) CopyAll(ctx *SupportedStatsStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedStatsStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedStatsStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ShowTableStatsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext + columnList IIdentifierListContext + tableId antlr.Token +} + +func NewShowTableStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowTableStatsContext { + var p = new(ShowTableStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowTableStatsContext) GetTableId() antlr.Token { return s.tableId } + +func (s *ShowTableStatsContext) SetTableId(v antlr.Token) { s.tableId = v } + +func (s *ShowTableStatsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowTableStatsContext) GetColumnList() IIdentifierListContext { return s.columnList } + +func (s *ShowTableStatsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowTableStatsContext) SetColumnList(v IIdentifierListContext) { s.columnList = v } + +func (s *ShowTableStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowTableStatsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowTableStatsContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *ShowTableStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *ShowTableStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowTableStatsContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *ShowTableStatsContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ShowTableStatsContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowTableStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowTableStats(s) + } +} + +func (s *ShowTableStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowTableStats(s) + } +} + +func (s *ShowTableStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowTableStats(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowColumnStatsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext + columnList IIdentifierListContext +} + +func NewShowColumnStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowColumnStatsContext { + var p = new(ShowColumnStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowColumnStatsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowColumnStatsContext) GetColumnList() IIdentifierListContext { return s.columnList } + +func (s *ShowColumnStatsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowColumnStatsContext) SetColumnList(v IIdentifierListContext) { s.columnList = v } + +func (s *ShowColumnStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowColumnStatsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowColumnStatsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *ShowColumnStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *ShowColumnStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowColumnStatsContext) CACHED() antlr.TerminalNode { + return s.GetToken(DorisParserCACHED, 0) +} + +func (s *ShowColumnStatsContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *ShowColumnStatsContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ShowColumnStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowColumnStats(s) + } +} + +func (s *ShowColumnStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowColumnStats(s) + } +} + +func (s *ShowColumnStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowColumnStats(s) + + default: + return t.VisitChildren(s) + } +} + +type AnalyzeDatabaseContext struct { + SupportedStatsStatementContext + name IMultipartIdentifierContext +} + +func NewAnalyzeDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AnalyzeDatabaseContext { + var p = new(AnalyzeDatabaseContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *AnalyzeDatabaseContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AnalyzeDatabaseContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AnalyzeDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzeDatabaseContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *AnalyzeDatabaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *AnalyzeDatabaseContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AnalyzeDatabaseContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(DorisParserWITH) +} + +func (s *AnalyzeDatabaseContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(DorisParserWITH, i) +} + +func (s *AnalyzeDatabaseContext) AllAnalyzeProperties() []IAnalyzePropertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnalyzePropertiesContext); ok { + len++ + } + } + + tst := make([]IAnalyzePropertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnalyzePropertiesContext); ok { + tst[i] = t.(IAnalyzePropertiesContext) + i++ + } + } + + return tst +} + +func (s *AnalyzeDatabaseContext) AnalyzeProperties(i int) IAnalyzePropertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzePropertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzePropertiesContext) +} + +func (s *AnalyzeDatabaseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AnalyzeDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAnalyzeDatabase(s) + } +} + +func (s *AnalyzeDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAnalyzeDatabase(s) + } +} + +func (s *AnalyzeDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAnalyzeDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowQueuedAnalyzeJobsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext + stateKey IIdentifierContext + stateValue antlr.Token +} + +func NewShowQueuedAnalyzeJobsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowQueuedAnalyzeJobsContext { + var p = new(ShowQueuedAnalyzeJobsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowQueuedAnalyzeJobsContext) GetStateValue() antlr.Token { return s.stateValue } + +func (s *ShowQueuedAnalyzeJobsContext) SetStateValue(v antlr.Token) { s.stateValue = v } + +func (s *ShowQueuedAnalyzeJobsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowQueuedAnalyzeJobsContext) GetStateKey() IIdentifierContext { return s.stateKey } + +func (s *ShowQueuedAnalyzeJobsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowQueuedAnalyzeJobsContext) SetStateKey(v IIdentifierContext) { s.stateKey = v } + +func (s *ShowQueuedAnalyzeJobsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowQueuedAnalyzeJobsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) QUEUED() antlr.TerminalNode { + return s.GetToken(DorisParserQUEUED, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) JOBS() antlr.TerminalNode { + return s.GetToken(DorisParserJOBS, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowQueuedAnalyzeJobsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowQueuedAnalyzeJobsContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowQueuedAnalyzeJobsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowQueuedAnalyzeJobs(s) + } +} + +func (s *ShowQueuedAnalyzeJobsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowQueuedAnalyzeJobs(s) + } +} + +func (s *ShowQueuedAnalyzeJobsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowQueuedAnalyzeJobs(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowAnalyzeTaskContext struct { + SupportedStatsStatementContext + jobId antlr.Token +} + +func NewShowAnalyzeTaskContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowAnalyzeTaskContext { + var p = new(ShowAnalyzeTaskContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowAnalyzeTaskContext) GetJobId() antlr.Token { return s.jobId } + +func (s *ShowAnalyzeTaskContext) SetJobId(v antlr.Token) { s.jobId = v } + +func (s *ShowAnalyzeTaskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowAnalyzeTaskContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowAnalyzeTaskContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *ShowAnalyzeTaskContext) TASK() antlr.TerminalNode { + return s.GetToken(DorisParserTASK, 0) +} + +func (s *ShowAnalyzeTaskContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *ShowAnalyzeTaskContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowAnalyzeTaskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowAnalyzeTask(s) + } +} + +func (s *ShowAnalyzeTaskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowAnalyzeTask(s) + } +} + +func (s *ShowAnalyzeTaskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowAnalyzeTask(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowIndexStatsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext + indexId IIdentifierContext +} + +func NewShowIndexStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowIndexStatsContext { + var p = new(ShowIndexStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowIndexStatsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowIndexStatsContext) GetIndexId() IIdentifierContext { return s.indexId } + +func (s *ShowIndexStatsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowIndexStatsContext) SetIndexId(v IIdentifierContext) { s.indexId = v } + +func (s *ShowIndexStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowIndexStatsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowIndexStatsContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *ShowIndexStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *ShowIndexStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowIndexStatsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowIndexStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowIndexStats(s) + } +} + +func (s *ShowIndexStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowIndexStats(s) + } +} + +func (s *ShowIndexStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowIndexStats(s) + + default: + return t.VisitChildren(s) + } +} + +type DropStatsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext + columns IIdentifierListContext +} + +func NewDropStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropStatsContext { + var p = new(DropStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *DropStatsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *DropStatsContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *DropStatsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *DropStatsContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *DropStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropStatsContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *DropStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropStatsContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *DropStatsContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *DropStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropStats(s) + } +} + +func (s *DropStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropStats(s) + } +} + +func (s *DropStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropStats(s) + + default: + return t.VisitChildren(s) + } +} + +type DropCachedStatsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext +} + +func NewDropCachedStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropCachedStatsContext { + var p = new(DropCachedStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *DropCachedStatsContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *DropCachedStatsContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *DropCachedStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropCachedStatsContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropCachedStatsContext) CACHED() antlr.TerminalNode { + return s.GetToken(DorisParserCACHED, 0) +} + +func (s *DropCachedStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *DropCachedStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DropCachedStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropCachedStats(s) + } +} + +func (s *DropCachedStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropCachedStats(s) + } +} + +func (s *DropCachedStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropCachedStats(s) + + default: + return t.VisitChildren(s) + } +} + +type KillAnalyzeJobContext struct { + SupportedStatsStatementContext + jobId antlr.Token +} + +func NewKillAnalyzeJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *KillAnalyzeJobContext { + var p = new(KillAnalyzeJobContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *KillAnalyzeJobContext) GetJobId() antlr.Token { return s.jobId } + +func (s *KillAnalyzeJobContext) SetJobId(v antlr.Token) { s.jobId = v } + +func (s *KillAnalyzeJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KillAnalyzeJobContext) KILL() antlr.TerminalNode { + return s.GetToken(DorisParserKILL, 0) +} + +func (s *KillAnalyzeJobContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *KillAnalyzeJobContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *KillAnalyzeJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterKillAnalyzeJob(s) + } +} + +func (s *KillAnalyzeJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitKillAnalyzeJob(s) + } +} + +func (s *KillAnalyzeJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitKillAnalyzeJob(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowAnalyzeContext struct { + SupportedStatsStatementContext + jobId antlr.Token + tableName IMultipartIdentifierContext + stateKey IIdentifierContext + stateValue antlr.Token +} + +func NewShowAnalyzeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowAnalyzeContext { + var p = new(ShowAnalyzeContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowAnalyzeContext) GetJobId() antlr.Token { return s.jobId } + +func (s *ShowAnalyzeContext) GetStateValue() antlr.Token { return s.stateValue } + +func (s *ShowAnalyzeContext) SetJobId(v antlr.Token) { s.jobId = v } + +func (s *ShowAnalyzeContext) SetStateValue(v antlr.Token) { s.stateValue = v } + +func (s *ShowAnalyzeContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *ShowAnalyzeContext) GetStateKey() IIdentifierContext { return s.stateKey } + +func (s *ShowAnalyzeContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *ShowAnalyzeContext) SetStateKey(v IIdentifierContext) { s.stateKey = v } + +func (s *ShowAnalyzeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowAnalyzeContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowAnalyzeContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *ShowAnalyzeContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *ShowAnalyzeContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *ShowAnalyzeContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *ShowAnalyzeContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ShowAnalyzeContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowAnalyzeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ShowAnalyzeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ShowAnalyzeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowAnalyze(s) + } +} + +func (s *ShowAnalyzeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowAnalyze(s) + } +} + +func (s *ShowAnalyzeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowAnalyze(s) + + default: + return t.VisitChildren(s) + } +} + +type DropAnalyzeJobContext struct { + SupportedStatsStatementContext +} + +func NewDropAnalyzeJobContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropAnalyzeJobContext { + var p = new(DropAnalyzeJobContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *DropAnalyzeJobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropAnalyzeJobContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropAnalyzeJobContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *DropAnalyzeJobContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *DropAnalyzeJobContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *DropAnalyzeJobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropAnalyzeJob(s) + } +} + +func (s *DropAnalyzeJobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropAnalyzeJob(s) + } +} + +func (s *DropAnalyzeJobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropAnalyzeJob(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterColumnStatsContext struct { + SupportedStatsStatementContext + name IMultipartIdentifierContext + indexName IIdentifierContext + columnName IIdentifierContext +} + +func NewAlterColumnStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterColumnStatsContext { + var p = new(AlterColumnStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *AlterColumnStatsContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterColumnStatsContext) GetIndexName() IIdentifierContext { return s.indexName } + +func (s *AlterColumnStatsContext) GetColumnName() IIdentifierContext { return s.columnName } + +func (s *AlterColumnStatsContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterColumnStatsContext) SetIndexName(v IIdentifierContext) { s.indexName = v } + +func (s *AlterColumnStatsContext) SetColumnName(v IIdentifierContext) { s.columnName = v } + +func (s *AlterColumnStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterColumnStatsContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterColumnStatsContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterColumnStatsContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *AlterColumnStatsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *AlterColumnStatsContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterColumnStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *AlterColumnStatsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterColumnStatsContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterColumnStatsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterColumnStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterColumnStatsContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *AlterColumnStatsContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlterColumnStatsContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *AlterColumnStatsContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *AlterColumnStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterColumnStats(s) + } +} + +func (s *AlterColumnStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterColumnStats(s) + } +} + +func (s *AlterColumnStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterColumnStats(s) + + default: + return t.VisitChildren(s) + } +} + +type DropExpiredStatsContext struct { + SupportedStatsStatementContext +} + +func NewDropExpiredStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropExpiredStatsContext { + var p = new(DropExpiredStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *DropExpiredStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropExpiredStatsContext) DROP() antlr.TerminalNode { + return s.GetToken(DorisParserDROP, 0) +} + +func (s *DropExpiredStatsContext) EXPIRED() antlr.TerminalNode { + return s.GetToken(DorisParserEXPIRED, 0) +} + +func (s *DropExpiredStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *DropExpiredStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDropExpiredStats(s) + } +} + +func (s *DropExpiredStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDropExpiredStats(s) + } +} + +func (s *DropExpiredStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDropExpiredStats(s) + + default: + return t.VisitChildren(s) + } +} + +type AnalyzeTableContext struct { + SupportedStatsStatementContext + name IMultipartIdentifierContext + columns IIdentifierListContext +} + +func NewAnalyzeTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AnalyzeTableContext { + var p = new(AnalyzeTableContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *AnalyzeTableContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AnalyzeTableContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *AnalyzeTableContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AnalyzeTableContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *AnalyzeTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzeTableContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZE, 0) +} + +func (s *AnalyzeTableContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AnalyzeTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AnalyzeTableContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *AnalyzeTableContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(DorisParserWITH) +} + +func (s *AnalyzeTableContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(DorisParserWITH, i) +} + +func (s *AnalyzeTableContext) AllAnalyzeProperties() []IAnalyzePropertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnalyzePropertiesContext); ok { + len++ + } + } + + tst := make([]IAnalyzePropertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnalyzePropertiesContext); ok { + tst[i] = t.(IAnalyzePropertiesContext) + i++ + } + } + + return tst +} + +func (s *AnalyzeTableContext) AnalyzeProperties(i int) IAnalyzePropertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzePropertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzePropertiesContext) +} + +func (s *AnalyzeTableContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *AnalyzeTableContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *AnalyzeTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAnalyzeTable(s) + } +} + +func (s *AnalyzeTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAnalyzeTable(s) + } +} + +func (s *AnalyzeTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAnalyzeTable(s) + + default: + return t.VisitChildren(s) + } +} + +type AlterTableStatsContext struct { + SupportedStatsStatementContext + name IMultipartIdentifierContext +} + +func NewAlterTableStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AlterTableStatsContext { + var p = new(AlterTableStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *AlterTableStatsContext) GetName() IMultipartIdentifierContext { return s.name } + +func (s *AlterTableStatsContext) SetName(v IMultipartIdentifierContext) { s.name = v } + +func (s *AlterTableStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableStatsContext) ALTER() antlr.TerminalNode { + return s.GetToken(DorisParserALTER, 0) +} + +func (s *AlterTableStatsContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *AlterTableStatsContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *AlterTableStatsContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *AlterTableStatsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AlterTableStatsContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *AlterTableStatsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AlterTableStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *AlterTableStatsContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *AlterTableStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAlterTableStats(s) + } +} + +func (s *AlterTableStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAlterTableStats(s) + } +} + +func (s *AlterTableStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAlterTableStats(s) + + default: + return t.VisitChildren(s) + } +} + +type ShowColumnHistogramStatsContext struct { + SupportedStatsStatementContext + tableName IMultipartIdentifierContext + columnList IIdentifierListContext +} + +func NewShowColumnHistogramStatsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowColumnHistogramStatsContext { + var p = new(ShowColumnHistogramStatsContext) + + InitEmptySupportedStatsStatementContext(&p.SupportedStatsStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedStatsStatementContext)) + + return p +} + +func (s *ShowColumnHistogramStatsContext) GetTableName() IMultipartIdentifierContext { + return s.tableName +} + +func (s *ShowColumnHistogramStatsContext) GetColumnList() IIdentifierListContext { return s.columnList } + +func (s *ShowColumnHistogramStatsContext) SetTableName(v IMultipartIdentifierContext) { + s.tableName = v +} + +func (s *ShowColumnHistogramStatsContext) SetColumnList(v IIdentifierListContext) { s.columnList = v } + +func (s *ShowColumnHistogramStatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowColumnHistogramStatsContext) SHOW() antlr.TerminalNode { + return s.GetToken(DorisParserSHOW, 0) +} + +func (s *ShowColumnHistogramStatsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMN, 0) +} + +func (s *ShowColumnHistogramStatsContext) HISTOGRAM() antlr.TerminalNode { + return s.GetToken(DorisParserHISTOGRAM, 0) +} + +func (s *ShowColumnHistogramStatsContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ShowColumnHistogramStatsContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ShowColumnHistogramStatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterShowColumnHistogramStats(s) + } +} + +func (s *ShowColumnHistogramStatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitShowColumnHistogramStats(s) + } +} + +func (s *ShowColumnHistogramStatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitShowColumnHistogramStats(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedStatsStatement() (localctx ISupportedStatsStatementContext) { + localctx = NewSupportedStatsStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, DorisParserRULE_supportedStatsStatement) + var _la int + + p.SetState(4343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 595, p.GetParserRuleContext()) { + case 1: + localctx = NewShowAnalyzeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4185) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAUTO { + { + p.SetState(4186) + p.Match(DorisParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4189) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case DorisParserINTEGER_VALUE: + { + p.SetState(4190) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowAnalyzeContext).jobId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4191) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowAnalyzeContext).tableName = _x + } + + case DorisParserEOF, DorisParserSEMICOLON, DorisParserWHERE: + + default: + } + p.SetState(4199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(4194) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4195) + + var _x = p.Identifier() + + localctx.(*ShowAnalyzeContext).stateKey = _x + } + + { + p.SetState(4196) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4197) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowAnalyzeContext).stateValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + localctx = NewShowQueuedAnalyzeJobsContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4201) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4202) + p.Match(DorisParserQUEUED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4203) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4204) + p.Match(DorisParserJOBS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(4205) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowQueuedAnalyzeJobsContext).tableName = _x + } + + } + p.SetState(4213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(4208) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4209) + + var _x = p.Identifier() + + localctx.(*ShowQueuedAnalyzeJobsContext).stateKey = _x + } + + { + p.SetState(4210) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4211) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ShowQueuedAnalyzeJobsContext).stateValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + localctx = NewShowColumnHistogramStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4215) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4216) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4217) + p.Match(DorisParserHISTOGRAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4218) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowColumnHistogramStatsContext).tableName = _x + } + { + p.SetState(4219) + + var _x = p.IdentifierList() + + localctx.(*ShowColumnHistogramStatsContext).columnList = _x + } + + case 4: + localctx = NewShowColumnStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4221) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4222) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCACHED { + { + p.SetState(4223) + p.Match(DorisParserCACHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4226) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4227) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowColumnStatsContext).tableName = _x + } + p.SetState(4229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4228) + + var _x = p.IdentifierList() + + localctx.(*ShowColumnStatsContext).columnList = _x + } + + } + p.SetState(4232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4231) + p.PartitionSpec() + } + + } + + case 5: + localctx = NewShowAnalyzeTaskContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4234) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4235) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4236) + p.Match(DorisParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4237) + p.Match(DorisParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4238) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowAnalyzeTaskContext).jobId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewAnalyzeDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4239) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4240) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4241) + + var _x = p.MultipartIdentifier() + + localctx.(*AnalyzeDatabaseContext).name = _x + } + p.SetState(4246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserWITH { + { + p.SetState(4242) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4243) + p.AnalyzeProperties() + } + + p.SetState(4248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4249) + p.PropertyClause() + } + + } + + case 7: + localctx = NewAnalyzeTableContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4252) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4253) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4254) + + var _x = p.MultipartIdentifier() + + localctx.(*AnalyzeTableContext).name = _x + } + p.SetState(4256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4255) + p.PartitionSpec() + } + + } + p.SetState(4259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4258) + + var _x = p.IdentifierList() + + localctx.(*AnalyzeTableContext).columns = _x + } + + } + p.SetState(4265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserWITH { + { + p.SetState(4261) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4262) + p.AnalyzeProperties() + } + + p.SetState(4267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4268) + p.PropertyClause() + } + + } + + case 8: + localctx = NewAlterTableStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4271) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4272) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4273) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterTableStatsContext).name = _x + } + { + p.SetState(4274) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4275) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4276) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4277) + p.PropertyItemList() + } + { + p.SetState(4278) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4279) + p.PartitionSpec() + } + + } + + case 9: + localctx = NewAlterColumnStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4282) + p.Match(DorisParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4283) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4284) + + var _x = p.MultipartIdentifier() + + localctx.(*AlterColumnStatsContext).name = _x + } + p.SetState(4287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINDEX { + { + p.SetState(4285) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4286) + + var _x = p.Identifier() + + localctx.(*AlterColumnStatsContext).indexName = _x + } + + } + { + p.SetState(4289) + p.Match(DorisParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4290) + p.Match(DorisParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4291) + + var _x = p.Identifier() + + localctx.(*AlterColumnStatsContext).columnName = _x + } + { + p.SetState(4292) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4293) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4294) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4295) + p.PropertyItemList() + } + { + p.SetState(4296) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4297) + p.PartitionSpec() + } + + } + + case 10: + localctx = NewShowIndexStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4300) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4301) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4302) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4303) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowIndexStatsContext).tableName = _x + } + { + p.SetState(4304) + + var _x = p.Identifier() + + localctx.(*ShowIndexStatsContext).indexId = _x + } + + case 11: + localctx = NewDropStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4306) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4307) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4308) + + var _x = p.MultipartIdentifier() + + localctx.(*DropStatsContext).tableName = _x + } + p.SetState(4310) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4309) + + var _x = p.IdentifierList() + + localctx.(*DropStatsContext).columns = _x + } + + } + p.SetState(4313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4312) + p.PartitionSpec() + } + + } + + case 12: + localctx = NewDropCachedStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4315) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4316) + p.Match(DorisParserCACHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4317) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4318) + + var _x = p.MultipartIdentifier() + + localctx.(*DropCachedStatsContext).tableName = _x + } + + case 13: + localctx = NewDropExpiredStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4319) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4320) + p.Match(DorisParserEXPIRED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4321) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewKillAnalyzeJobContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(4322) + p.Match(DorisParserKILL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4323) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4324) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*KillAnalyzeJobContext).jobId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewDropAnalyzeJobContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(4325) + p.Match(DorisParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4326) + p.Match(DorisParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4327) + p.Match(DorisParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4328) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + localctx = NewShowTableStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(4329) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4330) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4331) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4332) + + var _x = p.MultipartIdentifier() + + localctx.(*ShowTableStatsContext).tableName = _x + } + p.SetState(4334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4333) + p.PartitionSpec() + } + + } + p.SetState(4337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4336) + + var _x = p.IdentifierList() + + localctx.(*ShowTableStatsContext).columnList = _x + } + + } + + case 17: + localctx = NewShowTableStatsContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(4339) + p.Match(DorisParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4340) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4341) + p.Match(DorisParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4342) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*ShowTableStatsContext).tableId = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalyzePropertiesContext is an interface to support dynamic dispatch. +type IAnalyzePropertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRows returns the rows token. + GetRows() antlr.Token + + // GetPercent returns the percent token. + GetPercent() antlr.Token + + // GetBucket returns the bucket token. + GetBucket() antlr.Token + + // GetPeriodInSecond returns the periodInSecond token. + GetPeriodInSecond() antlr.Token + + // GetCrontabExpr returns the crontabExpr token. + GetCrontabExpr() antlr.Token + + // SetRows sets the rows token. + SetRows(antlr.Token) + + // SetPercent sets the percent token. + SetPercent(antlr.Token) + + // SetBucket sets the bucket token. + SetBucket(antlr.Token) + + // SetPeriodInSecond sets the periodInSecond token. + SetPeriodInSecond(antlr.Token) + + // SetCrontabExpr sets the crontabExpr token. + SetCrontabExpr(antlr.Token) + + // Getter signatures + SYNC() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + FULL() antlr.TerminalNode + SQL() antlr.TerminalNode + HISTOGRAM() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + ROWS() antlr.TerminalNode + PERCENT() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + BUCKETS() antlr.TerminalNode + PERIOD() antlr.TerminalNode + CRON() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsAnalyzePropertiesContext differentiates from other interfaces. + IsAnalyzePropertiesContext() +} + +type AnalyzePropertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rows antlr.Token + percent antlr.Token + bucket antlr.Token + periodInSecond antlr.Token + crontabExpr antlr.Token +} + +func NewEmptyAnalyzePropertiesContext() *AnalyzePropertiesContext { + var p = new(AnalyzePropertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_analyzeProperties + return p +} + +func InitEmptyAnalyzePropertiesContext(p *AnalyzePropertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_analyzeProperties +} + +func (*AnalyzePropertiesContext) IsAnalyzePropertiesContext() {} + +func NewAnalyzePropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzePropertiesContext { + var p = new(AnalyzePropertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_analyzeProperties + + return p +} + +func (s *AnalyzePropertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnalyzePropertiesContext) GetRows() antlr.Token { return s.rows } + +func (s *AnalyzePropertiesContext) GetPercent() antlr.Token { return s.percent } + +func (s *AnalyzePropertiesContext) GetBucket() antlr.Token { return s.bucket } + +func (s *AnalyzePropertiesContext) GetPeriodInSecond() antlr.Token { return s.periodInSecond } + +func (s *AnalyzePropertiesContext) GetCrontabExpr() antlr.Token { return s.crontabExpr } + +func (s *AnalyzePropertiesContext) SetRows(v antlr.Token) { s.rows = v } + +func (s *AnalyzePropertiesContext) SetPercent(v antlr.Token) { s.percent = v } + +func (s *AnalyzePropertiesContext) SetBucket(v antlr.Token) { s.bucket = v } + +func (s *AnalyzePropertiesContext) SetPeriodInSecond(v antlr.Token) { s.periodInSecond = v } + +func (s *AnalyzePropertiesContext) SetCrontabExpr(v antlr.Token) { s.crontabExpr = v } + +func (s *AnalyzePropertiesContext) SYNC() antlr.TerminalNode { + return s.GetToken(DorisParserSYNC, 0) +} + +func (s *AnalyzePropertiesContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(DorisParserINCREMENTAL, 0) +} + +func (s *AnalyzePropertiesContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *AnalyzePropertiesContext) SQL() antlr.TerminalNode { + return s.GetToken(DorisParserSQL, 0) +} + +func (s *AnalyzePropertiesContext) HISTOGRAM() antlr.TerminalNode { + return s.GetToken(DorisParserHISTOGRAM, 0) +} + +func (s *AnalyzePropertiesContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(DorisParserSAMPLE, 0) +} + +func (s *AnalyzePropertiesContext) ROWS() antlr.TerminalNode { + return s.GetToken(DorisParserROWS, 0) +} + +func (s *AnalyzePropertiesContext) PERCENT() antlr.TerminalNode { + return s.GetToken(DorisParserPERCENT, 0) +} + +func (s *AnalyzePropertiesContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *AnalyzePropertiesContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(DorisParserBUCKETS, 0) +} + +func (s *AnalyzePropertiesContext) PERIOD() antlr.TerminalNode { + return s.GetToken(DorisParserPERIOD, 0) +} + +func (s *AnalyzePropertiesContext) CRON() antlr.TerminalNode { + return s.GetToken(DorisParserCRON, 0) +} + +func (s *AnalyzePropertiesContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *AnalyzePropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzePropertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnalyzePropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAnalyzeProperties(s) + } +} + +func (s *AnalyzePropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAnalyzeProperties(s) + } +} + +func (s *AnalyzePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAnalyzeProperties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AnalyzeProperties() (localctx IAnalyzePropertiesContext) { + localctx = NewAnalyzePropertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, DorisParserRULE_analyzeProperties) + p.SetState(4363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSYNC: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4345) + p.Match(DorisParserSYNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserINCREMENTAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4346) + p.Match(DorisParserINCREMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserFULL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4347) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSQL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4348) + p.Match(DorisParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserHISTOGRAM: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4349) + p.Match(DorisParserHISTOGRAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSAMPLE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4350) + p.Match(DorisParserSAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserROWS: + { + p.SetState(4351) + p.Match(DorisParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4352) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*AnalyzePropertiesContext).rows = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserPERCENT: + { + p.SetState(4353) + p.Match(DorisParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4354) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*AnalyzePropertiesContext).percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case DorisParserBUCKETS: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4357) + p.Match(DorisParserBUCKETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4358) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*AnalyzePropertiesContext).bucket = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserPERIOD: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4359) + p.Match(DorisParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4360) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*AnalyzePropertiesContext).periodInSecond = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCRON: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4361) + p.Match(DorisParserCRON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4362) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*AnalyzePropertiesContext).crontabExpr = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkloadPolicyActionsContext is an interface to support dynamic dispatch. +type IWorkloadPolicyActionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWorkloadPolicyAction() []IWorkloadPolicyActionContext + WorkloadPolicyAction(i int) IWorkloadPolicyActionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWorkloadPolicyActionsContext differentiates from other interfaces. + IsWorkloadPolicyActionsContext() +} + +type WorkloadPolicyActionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkloadPolicyActionsContext() *WorkloadPolicyActionsContext { + var p = new(WorkloadPolicyActionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyActions + return p +} + +func InitEmptyWorkloadPolicyActionsContext(p *WorkloadPolicyActionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyActions +} + +func (*WorkloadPolicyActionsContext) IsWorkloadPolicyActionsContext() {} + +func NewWorkloadPolicyActionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkloadPolicyActionsContext { + var p = new(WorkloadPolicyActionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_workloadPolicyActions + + return p +} + +func (s *WorkloadPolicyActionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkloadPolicyActionsContext) AllWorkloadPolicyAction() []IWorkloadPolicyActionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkloadPolicyActionContext); ok { + len++ + } + } + + tst := make([]IWorkloadPolicyActionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkloadPolicyActionContext); ok { + tst[i] = t.(IWorkloadPolicyActionContext) + i++ + } + } + + return tst +} + +func (s *WorkloadPolicyActionsContext) WorkloadPolicyAction(i int) IWorkloadPolicyActionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkloadPolicyActionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkloadPolicyActionContext) +} + +func (s *WorkloadPolicyActionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *WorkloadPolicyActionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *WorkloadPolicyActionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkloadPolicyActionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkloadPolicyActionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWorkloadPolicyActions(s) + } +} + +func (s *WorkloadPolicyActionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWorkloadPolicyActions(s) + } +} + +func (s *WorkloadPolicyActionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWorkloadPolicyActions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WorkloadPolicyActions() (localctx IWorkloadPolicyActionsContext) { + localctx = NewWorkloadPolicyActionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, DorisParserRULE_workloadPolicyActions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4365) + p.WorkloadPolicyAction() + } + p.SetState(4370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(4366) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4367) + p.WorkloadPolicyAction() + } + + p.SetState(4372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkloadPolicyActionContext is an interface to support dynamic dispatch. +type IWorkloadPolicyActionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET_SESSION_VARIABLE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsWorkloadPolicyActionContext differentiates from other interfaces. + IsWorkloadPolicyActionContext() +} + +type WorkloadPolicyActionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkloadPolicyActionContext() *WorkloadPolicyActionContext { + var p = new(WorkloadPolicyActionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyAction + return p +} + +func InitEmptyWorkloadPolicyActionContext(p *WorkloadPolicyActionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyAction +} + +func (*WorkloadPolicyActionContext) IsWorkloadPolicyActionContext() {} + +func NewWorkloadPolicyActionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkloadPolicyActionContext { + var p = new(WorkloadPolicyActionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_workloadPolicyAction + + return p +} + +func (s *WorkloadPolicyActionContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkloadPolicyActionContext) SET_SESSION_VARIABLE() antlr.TerminalNode { + return s.GetToken(DorisParserSET_SESSION_VARIABLE, 0) +} + +func (s *WorkloadPolicyActionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *WorkloadPolicyActionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *WorkloadPolicyActionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkloadPolicyActionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkloadPolicyActionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWorkloadPolicyAction(s) + } +} + +func (s *WorkloadPolicyActionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWorkloadPolicyAction(s) + } +} + +func (s *WorkloadPolicyActionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWorkloadPolicyAction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WorkloadPolicyAction() (localctx IWorkloadPolicyActionContext) { + localctx = NewWorkloadPolicyActionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, DorisParserRULE_workloadPolicyAction) + var _la int + + p.SetState(4379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 600, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4373) + p.Match(DorisParserSET_SESSION_VARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4374) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4375) + p.Identifier() + } + p.SetState(4377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTRING_LITERAL { + { + p.SetState(4376) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkloadPolicyConditionsContext is an interface to support dynamic dispatch. +type IWorkloadPolicyConditionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWorkloadPolicyCondition() []IWorkloadPolicyConditionContext + WorkloadPolicyCondition(i int) IWorkloadPolicyConditionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWorkloadPolicyConditionsContext differentiates from other interfaces. + IsWorkloadPolicyConditionsContext() +} + +type WorkloadPolicyConditionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWorkloadPolicyConditionsContext() *WorkloadPolicyConditionsContext { + var p = new(WorkloadPolicyConditionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyConditions + return p +} + +func InitEmptyWorkloadPolicyConditionsContext(p *WorkloadPolicyConditionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyConditions +} + +func (*WorkloadPolicyConditionsContext) IsWorkloadPolicyConditionsContext() {} + +func NewWorkloadPolicyConditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkloadPolicyConditionsContext { + var p = new(WorkloadPolicyConditionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_workloadPolicyConditions + + return p +} + +func (s *WorkloadPolicyConditionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkloadPolicyConditionsContext) AllWorkloadPolicyCondition() []IWorkloadPolicyConditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWorkloadPolicyConditionContext); ok { + len++ + } + } + + tst := make([]IWorkloadPolicyConditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWorkloadPolicyConditionContext); ok { + tst[i] = t.(IWorkloadPolicyConditionContext) + i++ + } + } + + return tst +} + +func (s *WorkloadPolicyConditionsContext) WorkloadPolicyCondition(i int) IWorkloadPolicyConditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWorkloadPolicyConditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWorkloadPolicyConditionContext) +} + +func (s *WorkloadPolicyConditionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *WorkloadPolicyConditionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *WorkloadPolicyConditionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkloadPolicyConditionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkloadPolicyConditionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWorkloadPolicyConditions(s) + } +} + +func (s *WorkloadPolicyConditionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWorkloadPolicyConditions(s) + } +} + +func (s *WorkloadPolicyConditionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWorkloadPolicyConditions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WorkloadPolicyConditions() (localctx IWorkloadPolicyConditionsContext) { + localctx = NewWorkloadPolicyConditionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, DorisParserRULE_workloadPolicyConditions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4381) + p.WorkloadPolicyCondition() + } + p.SetState(4386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(4382) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4383) + p.WorkloadPolicyCondition() + } + + p.SetState(4388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWorkloadPolicyConditionContext is an interface to support dynamic dispatch. +type IWorkloadPolicyConditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMetricName returns the metricName rule contexts. + GetMetricName() IIdentifierContext + + // SetMetricName sets the metricName rule contexts. + SetMetricName(IIdentifierContext) + + // Getter signatures + ComparisonOperator() IComparisonOperatorContext + Identifier() IIdentifierContext + Number() INumberContext + STRING_LITERAL() antlr.TerminalNode + + // IsWorkloadPolicyConditionContext differentiates from other interfaces. + IsWorkloadPolicyConditionContext() +} + +type WorkloadPolicyConditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + metricName IIdentifierContext +} + +func NewEmptyWorkloadPolicyConditionContext() *WorkloadPolicyConditionContext { + var p = new(WorkloadPolicyConditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyCondition + return p +} + +func InitEmptyWorkloadPolicyConditionContext(p *WorkloadPolicyConditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_workloadPolicyCondition +} + +func (*WorkloadPolicyConditionContext) IsWorkloadPolicyConditionContext() {} + +func NewWorkloadPolicyConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WorkloadPolicyConditionContext { + var p = new(WorkloadPolicyConditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_workloadPolicyCondition + + return p +} + +func (s *WorkloadPolicyConditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *WorkloadPolicyConditionContext) GetMetricName() IIdentifierContext { return s.metricName } + +func (s *WorkloadPolicyConditionContext) SetMetricName(v IIdentifierContext) { s.metricName = v } + +func (s *WorkloadPolicyConditionContext) ComparisonOperator() IComparisonOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparisonOperatorContext) +} + +func (s *WorkloadPolicyConditionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *WorkloadPolicyConditionContext) Number() INumberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumberContext) +} + +func (s *WorkloadPolicyConditionContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *WorkloadPolicyConditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WorkloadPolicyConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WorkloadPolicyConditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWorkloadPolicyCondition(s) + } +} + +func (s *WorkloadPolicyConditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWorkloadPolicyCondition(s) + } +} + +func (s *WorkloadPolicyConditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWorkloadPolicyCondition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WorkloadPolicyCondition() (localctx IWorkloadPolicyConditionContext) { + localctx = NewWorkloadPolicyConditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, DorisParserRULE_workloadPolicyCondition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4389) + + var _x = p.Identifier() + + localctx.(*WorkloadPolicyConditionContext).metricName = _x + } + { + p.SetState(4390) + p.ComparisonOperator() + } + p.SetState(4393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSUBTRACT, DorisParserINTEGER_VALUE, DorisParserEXPONENT_VALUE, DorisParserDECIMAL_VALUE: + { + p.SetState(4391) + p.Number() + } + + case DorisParserSTRING_LITERAL: + { + p.SetState(4392) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStorageBackendContext is an interface to support dynamic dispatch. +type IStorageBackendContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBrokerName returns the brokerName rule contexts. + GetBrokerName() IIdentifierContext + + // GetProperties returns the properties rule contexts. + GetProperties() IPropertyClauseContext + + // SetBrokerName sets the brokerName rule contexts. + SetBrokerName(IIdentifierContext) + + // SetProperties sets the properties rule contexts. + SetProperties(IPropertyClauseContext) + + // Getter signatures + ON() antlr.TerminalNode + LOCATION() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + BROKER() antlr.TerminalNode + S3() antlr.TerminalNode + HDFS() antlr.TerminalNode + LOCAL() antlr.TerminalNode + Identifier() IIdentifierContext + PropertyClause() IPropertyClauseContext + + // IsStorageBackendContext differentiates from other interfaces. + IsStorageBackendContext() +} + +type StorageBackendContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + brokerName IIdentifierContext + properties IPropertyClauseContext +} + +func NewEmptyStorageBackendContext() *StorageBackendContext { + var p = new(StorageBackendContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_storageBackend + return p +} + +func InitEmptyStorageBackendContext(p *StorageBackendContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_storageBackend +} + +func (*StorageBackendContext) IsStorageBackendContext() {} + +func NewStorageBackendContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StorageBackendContext { + var p = new(StorageBackendContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_storageBackend + + return p +} + +func (s *StorageBackendContext) GetParser() antlr.Parser { return s.parser } + +func (s *StorageBackendContext) GetBrokerName() IIdentifierContext { return s.brokerName } + +func (s *StorageBackendContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *StorageBackendContext) SetBrokerName(v IIdentifierContext) { s.brokerName = v } + +func (s *StorageBackendContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *StorageBackendContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *StorageBackendContext) LOCATION() antlr.TerminalNode { + return s.GetToken(DorisParserLOCATION, 0) +} + +func (s *StorageBackendContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *StorageBackendContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *StorageBackendContext) S3() antlr.TerminalNode { + return s.GetToken(DorisParserS3, 0) +} + +func (s *StorageBackendContext) HDFS() antlr.TerminalNode { + return s.GetToken(DorisParserHDFS, 0) +} + +func (s *StorageBackendContext) LOCAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOCAL, 0) +} + +func (s *StorageBackendContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *StorageBackendContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *StorageBackendContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StorageBackendContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StorageBackendContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStorageBackend(s) + } +} + +func (s *StorageBackendContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStorageBackend(s) + } +} + +func (s *StorageBackendContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStorageBackend(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) StorageBackend() (localctx IStorageBackendContext) { + localctx = NewStorageBackendContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, DorisParserRULE_storageBackend) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4395) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBROKER || _la == DorisParserHDFS || _la == DorisParserLOCAL || _la == DorisParserS3) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + { + p.SetState(4396) + + var _x = p.Identifier() + + localctx.(*StorageBackendContext).brokerName = _x + } + + } + { + p.SetState(4399) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4400) + p.Match(DorisParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4401) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4402) + + var _x = p.PropertyClause() + + localctx.(*StorageBackendContext).properties = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPasswordOptionContext is an interface to support dynamic dispatch. +type IPasswordOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHistoryDefault returns the historyDefault token. + GetHistoryDefault() antlr.Token + + // GetHistoryValue returns the historyValue token. + GetHistoryValue() antlr.Token + + // GetExpireDefault returns the expireDefault token. + GetExpireDefault() antlr.Token + + // GetExpireNever returns the expireNever token. + GetExpireNever() antlr.Token + + // GetExpireValue returns the expireValue token. + GetExpireValue() antlr.Token + + // GetExpireTimeUnit returns the expireTimeUnit token. + GetExpireTimeUnit() antlr.Token + + // GetReuseDefault returns the reuseDefault token. + GetReuseDefault() antlr.Token + + // GetReuseValue returns the reuseValue token. + GetReuseValue() antlr.Token + + // GetAttemptsValue returns the attemptsValue token. + GetAttemptsValue() antlr.Token + + // GetLockUnbounded returns the lockUnbounded token. + GetLockUnbounded() antlr.Token + + // GetLockValue returns the lockValue token. + GetLockValue() antlr.Token + + // GetLockTimeUint returns the lockTimeUint token. + GetLockTimeUint() antlr.Token + + // SetHistoryDefault sets the historyDefault token. + SetHistoryDefault(antlr.Token) + + // SetHistoryValue sets the historyValue token. + SetHistoryValue(antlr.Token) + + // SetExpireDefault sets the expireDefault token. + SetExpireDefault(antlr.Token) + + // SetExpireNever sets the expireNever token. + SetExpireNever(antlr.Token) + + // SetExpireValue sets the expireValue token. + SetExpireValue(antlr.Token) + + // SetExpireTimeUnit sets the expireTimeUnit token. + SetExpireTimeUnit(antlr.Token) + + // SetReuseDefault sets the reuseDefault token. + SetReuseDefault(antlr.Token) + + // SetReuseValue sets the reuseValue token. + SetReuseValue(antlr.Token) + + // SetAttemptsValue sets the attemptsValue token. + SetAttemptsValue(antlr.Token) + + // SetLockUnbounded sets the lockUnbounded token. + SetLockUnbounded(antlr.Token) + + // SetLockValue sets the lockValue token. + SetLockValue(antlr.Token) + + // SetLockTimeUint sets the lockTimeUint token. + SetLockTimeUint(antlr.Token) + + // Getter signatures + PASSWORD_HISTORY() antlr.TerminalNode + PASSWORD_EXPIRE() antlr.TerminalNode + PASSWORD_REUSE() antlr.TerminalNode + AllINTERVAL() []antlr.TerminalNode + INTERVAL(i int) antlr.TerminalNode + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + AllINTEGER_VALUE() []antlr.TerminalNode + INTEGER_VALUE(i int) antlr.TerminalNode + ACCOUNT_LOCK() antlr.TerminalNode + ACCOUNT_UNLOCK() antlr.TerminalNode + AllDAY() []antlr.TerminalNode + DAY(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + NEVER() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + AllHOUR() []antlr.TerminalNode + HOUR(i int) antlr.TerminalNode + AllSECOND() []antlr.TerminalNode + SECOND(i int) antlr.TerminalNode + + // IsPasswordOptionContext differentiates from other interfaces. + IsPasswordOptionContext() +} + +type PasswordOptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + historyDefault antlr.Token + historyValue antlr.Token + expireDefault antlr.Token + expireNever antlr.Token + expireValue antlr.Token + expireTimeUnit antlr.Token + reuseDefault antlr.Token + reuseValue antlr.Token + attemptsValue antlr.Token + lockUnbounded antlr.Token + lockValue antlr.Token + lockTimeUint antlr.Token +} + +func NewEmptyPasswordOptionContext() *PasswordOptionContext { + var p = new(PasswordOptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_passwordOption + return p +} + +func InitEmptyPasswordOptionContext(p *PasswordOptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_passwordOption +} + +func (*PasswordOptionContext) IsPasswordOptionContext() {} + +func NewPasswordOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PasswordOptionContext { + var p = new(PasswordOptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_passwordOption + + return p +} + +func (s *PasswordOptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PasswordOptionContext) GetHistoryDefault() antlr.Token { return s.historyDefault } + +func (s *PasswordOptionContext) GetHistoryValue() antlr.Token { return s.historyValue } + +func (s *PasswordOptionContext) GetExpireDefault() antlr.Token { return s.expireDefault } + +func (s *PasswordOptionContext) GetExpireNever() antlr.Token { return s.expireNever } + +func (s *PasswordOptionContext) GetExpireValue() antlr.Token { return s.expireValue } + +func (s *PasswordOptionContext) GetExpireTimeUnit() antlr.Token { return s.expireTimeUnit } + +func (s *PasswordOptionContext) GetReuseDefault() antlr.Token { return s.reuseDefault } + +func (s *PasswordOptionContext) GetReuseValue() antlr.Token { return s.reuseValue } + +func (s *PasswordOptionContext) GetAttemptsValue() antlr.Token { return s.attemptsValue } + +func (s *PasswordOptionContext) GetLockUnbounded() antlr.Token { return s.lockUnbounded } + +func (s *PasswordOptionContext) GetLockValue() antlr.Token { return s.lockValue } + +func (s *PasswordOptionContext) GetLockTimeUint() antlr.Token { return s.lockTimeUint } + +func (s *PasswordOptionContext) SetHistoryDefault(v antlr.Token) { s.historyDefault = v } + +func (s *PasswordOptionContext) SetHistoryValue(v antlr.Token) { s.historyValue = v } + +func (s *PasswordOptionContext) SetExpireDefault(v antlr.Token) { s.expireDefault = v } + +func (s *PasswordOptionContext) SetExpireNever(v antlr.Token) { s.expireNever = v } + +func (s *PasswordOptionContext) SetExpireValue(v antlr.Token) { s.expireValue = v } + +func (s *PasswordOptionContext) SetExpireTimeUnit(v antlr.Token) { s.expireTimeUnit = v } + +func (s *PasswordOptionContext) SetReuseDefault(v antlr.Token) { s.reuseDefault = v } + +func (s *PasswordOptionContext) SetReuseValue(v antlr.Token) { s.reuseValue = v } + +func (s *PasswordOptionContext) SetAttemptsValue(v antlr.Token) { s.attemptsValue = v } + +func (s *PasswordOptionContext) SetLockUnbounded(v antlr.Token) { s.lockUnbounded = v } + +func (s *PasswordOptionContext) SetLockValue(v antlr.Token) { s.lockValue = v } + +func (s *PasswordOptionContext) SetLockTimeUint(v antlr.Token) { s.lockTimeUint = v } + +func (s *PasswordOptionContext) PASSWORD_HISTORY() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_HISTORY, 0) +} + +func (s *PasswordOptionContext) PASSWORD_EXPIRE() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_EXPIRE, 0) +} + +func (s *PasswordOptionContext) PASSWORD_REUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_REUSE, 0) +} + +func (s *PasswordOptionContext) AllINTERVAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTERVAL) +} + +func (s *PasswordOptionContext) INTERVAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTERVAL, i) +} + +func (s *PasswordOptionContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(DorisParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *PasswordOptionContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_LOCK_TIME, 0) +} + +func (s *PasswordOptionContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *PasswordOptionContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *PasswordOptionContext) ACCOUNT_LOCK() antlr.TerminalNode { + return s.GetToken(DorisParserACCOUNT_LOCK, 0) +} + +func (s *PasswordOptionContext) ACCOUNT_UNLOCK() antlr.TerminalNode { + return s.GetToken(DorisParserACCOUNT_UNLOCK, 0) +} + +func (s *PasswordOptionContext) AllDAY() []antlr.TerminalNode { + return s.GetTokens(DorisParserDAY) +} + +func (s *PasswordOptionContext) DAY(i int) antlr.TerminalNode { + return s.GetToken(DorisParserDAY, i) +} + +func (s *PasswordOptionContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(DorisParserDEFAULT) +} + +func (s *PasswordOptionContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, i) +} + +func (s *PasswordOptionContext) NEVER() antlr.TerminalNode { + return s.GetToken(DorisParserNEVER, 0) +} + +func (s *PasswordOptionContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(DorisParserUNBOUNDED, 0) +} + +func (s *PasswordOptionContext) AllHOUR() []antlr.TerminalNode { + return s.GetTokens(DorisParserHOUR) +} + +func (s *PasswordOptionContext) HOUR(i int) antlr.TerminalNode { + return s.GetToken(DorisParserHOUR, i) +} + +func (s *PasswordOptionContext) AllSECOND() []antlr.TerminalNode { + return s.GetTokens(DorisParserSECOND) +} + +func (s *PasswordOptionContext) SECOND(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSECOND, i) +} + +func (s *PasswordOptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PasswordOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PasswordOptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPasswordOption(s) + } +} + +func (s *PasswordOptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPasswordOption(s) + } +} + +func (s *PasswordOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPasswordOption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PasswordOption() (localctx IPasswordOptionContext) { + localctx = NewPasswordOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, DorisParserRULE_passwordOption) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPASSWORD_HISTORY { + { + p.SetState(4405) + p.Match(DorisParserPASSWORD_HISTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserDEFAULT: + { + p.SetState(4406) + + var _m = p.Match(DorisParserDEFAULT) + + localctx.(*PasswordOptionContext).historyDefault = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserINTEGER_VALUE: + { + p.SetState(4407) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*PasswordOptionContext).historyValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPASSWORD_EXPIRE { + { + p.SetState(4412) + p.Match(DorisParserPASSWORD_EXPIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserDEFAULT: + { + p.SetState(4413) + + var _m = p.Match(DorisParserDEFAULT) + + localctx.(*PasswordOptionContext).expireDefault = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserNEVER: + { + p.SetState(4414) + + var _m = p.Match(DorisParserNEVER) + + localctx.(*PasswordOptionContext).expireNever = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserINTERVAL: + { + p.SetState(4415) + p.Match(DorisParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4416) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*PasswordOptionContext).expireValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4417) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PasswordOptionContext).expireTimeUnit = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDAY || _la == DorisParserHOUR || _la == DorisParserSECOND) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PasswordOptionContext).expireTimeUnit = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPASSWORD_REUSE { + { + p.SetState(4422) + p.Match(DorisParserPASSWORD_REUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4423) + p.Match(DorisParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserDEFAULT: + { + p.SetState(4424) + + var _m = p.Match(DorisParserDEFAULT) + + localctx.(*PasswordOptionContext).reuseDefault = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserINTEGER_VALUE: + { + p.SetState(4425) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*PasswordOptionContext).reuseValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4426) + p.Match(DorisParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFAILED_LOGIN_ATTEMPTS { + { + p.SetState(4431) + p.Match(DorisParserFAILED_LOGIN_ATTEMPTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4432) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*PasswordOptionContext).attemptsValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPASSWORD_LOCK_TIME { + { + p.SetState(4435) + p.Match(DorisParserPASSWORD_LOCK_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserUNBOUNDED: + { + p.SetState(4436) + + var _m = p.Match(DorisParserUNBOUNDED) + + localctx.(*PasswordOptionContext).lockUnbounded = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserINTEGER_VALUE: + { + p.SetState(4437) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*PasswordOptionContext).lockValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4438) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PasswordOptionContext).lockTimeUint = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDAY || _la == DorisParserHOUR || _la == DorisParserSECOND) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PasswordOptionContext).lockTimeUint = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserACCOUNT_LOCK || _la == DorisParserACCOUNT_UNLOCK { + { + p.SetState(4443) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserACCOUNT_LOCK || _la == DorisParserACCOUNT_UNLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionArgumentsContext is an interface to support dynamic dispatch. +type IFunctionArgumentsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOTDOTDOT() antlr.TerminalNode + DataTypeList() IDataTypeListContext + COMMA() antlr.TerminalNode + + // IsFunctionArgumentsContext differentiates from other interfaces. + IsFunctionArgumentsContext() +} + +type FunctionArgumentsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionArgumentsContext() *FunctionArgumentsContext { + var p = new(FunctionArgumentsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionArguments + return p +} + +func InitEmptyFunctionArgumentsContext(p *FunctionArgumentsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionArguments +} + +func (*FunctionArgumentsContext) IsFunctionArgumentsContext() {} + +func NewFunctionArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgumentsContext { + var p = new(FunctionArgumentsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_functionArguments + + return p +} + +func (s *FunctionArgumentsContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionArgumentsContext) DOTDOTDOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOTDOTDOT, 0) +} + +func (s *FunctionArgumentsContext) DataTypeList() IDataTypeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeListContext) +} + +func (s *FunctionArgumentsContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *FunctionArgumentsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionArgumentsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFunctionArguments(s) + } +} + +func (s *FunctionArgumentsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFunctionArguments(s) + } +} + +func (s *FunctionArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFunctionArguments(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FunctionArguments() (localctx IFunctionArgumentsContext) { + localctx = NewFunctionArgumentsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, DorisParserRULE_functionArguments) + p.SetState(4452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 615, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4446) + p.Match(DorisParserDOTDOTDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4447) + p.DataTypeList() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4448) + p.DataTypeList() + } + { + p.SetState(4449) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4450) + p.Match(DorisParserDOTDOTDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeListContext is an interface to support dynamic dispatch. +type IDataTypeListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDataType() []IDataTypeContext + DataType(i int) IDataTypeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDataTypeListContext differentiates from other interfaces. + IsDataTypeListContext() +} + +type DataTypeListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeListContext() *DataTypeListContext { + var p = new(DataTypeListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataTypeList + return p +} + +func InitEmptyDataTypeListContext(p *DataTypeListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataTypeList +} + +func (*DataTypeListContext) IsDataTypeListContext() {} + +func NewDataTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeListContext { + var p = new(DataTypeListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dataTypeList + + return p +} + +func (s *DataTypeListContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeListContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *DataTypeListContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *DataTypeListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *DataTypeListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *DataTypeListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataTypeListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDataTypeList(s) + } +} + +func (s *DataTypeListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDataTypeList(s) + } +} + +func (s *DataTypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDataTypeList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DataTypeList() (localctx IDataTypeListContext) { + localctx = NewDataTypeListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, DorisParserRULE_dataTypeList) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4454) + p.DataType() + } + p.SetState(4459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 616, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4455) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4456) + p.DataType() + } + + } + p.SetState(4461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 616, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedSetStatementContext is an interface to support dynamic dispatch. +type ISupportedSetStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedSetStatementContext differentiates from other interfaces. + IsSupportedSetStatementContext() +} + +type SupportedSetStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedSetStatementContext() *SupportedSetStatementContext { + var p = new(SupportedSetStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedSetStatement + return p +} + +func InitEmptySupportedSetStatementContext(p *SupportedSetStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedSetStatement +} + +func (*SupportedSetStatementContext) IsSupportedSetStatementContext() {} + +func NewSupportedSetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedSetStatementContext { + var p = new(SupportedSetStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedSetStatement + + return p +} + +func (s *SupportedSetStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedSetStatementContext) CopyAll(ctx *SupportedSetStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedSetStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedSetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SetTransactionContext struct { + SupportedSetStatementContext +} + +func NewSetTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetTransactionContext { + var p = new(SetTransactionContext) + + InitEmptySupportedSetStatementContext(&p.SupportedSetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedSetStatementContext)) + + return p +} + +func (s *SetTransactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetTransactionContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *SetTransactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(DorisParserTRANSACTION, 0) +} + +func (s *SetTransactionContext) TransactionAccessMode() ITransactionAccessModeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionAccessModeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransactionAccessModeContext) +} + +func (s *SetTransactionContext) IsolationLevel() IIsolationLevelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIsolationLevelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIsolationLevelContext) +} + +func (s *SetTransactionContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *SetTransactionContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *SetTransactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetTransaction(s) + } +} + +func (s *SetTransactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetTransaction(s) + } +} + +func (s *SetTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetTransaction(s) + + default: + return t.VisitChildren(s) + } +} + +type SetUserPropertiesContext struct { + SupportedSetStatementContext + user IIdentifierOrTextContext +} + +func NewSetUserPropertiesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetUserPropertiesContext { + var p = new(SetUserPropertiesContext) + + InitEmptySupportedSetStatementContext(&p.SupportedSetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedSetStatementContext)) + + return p +} + +func (s *SetUserPropertiesContext) GetUser() IIdentifierOrTextContext { return s.user } + +func (s *SetUserPropertiesContext) SetUser(v IIdentifierOrTextContext) { s.user = v } + +func (s *SetUserPropertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetUserPropertiesContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *SetUserPropertiesContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTY, 0) +} + +func (s *SetUserPropertiesContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *SetUserPropertiesContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *SetUserPropertiesContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *SetUserPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetUserProperties(s) + } +} + +func (s *SetUserPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetUserProperties(s) + } +} + +func (s *SetUserPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetUserProperties(s) + + default: + return t.VisitChildren(s) + } +} + +type SetDefaultStorageVaultContext struct { + SupportedSetStatementContext +} + +func NewSetDefaultStorageVaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetDefaultStorageVaultContext { + var p = new(SetDefaultStorageVaultContext) + + InitEmptySupportedSetStatementContext(&p.SupportedSetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedSetStatementContext)) + + return p +} + +func (s *SetDefaultStorageVaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetDefaultStorageVaultContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *SetDefaultStorageVaultContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SetDefaultStorageVaultContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *SetDefaultStorageVaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *SetDefaultStorageVaultContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *SetDefaultStorageVaultContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *SetDefaultStorageVaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetDefaultStorageVault(s) + } +} + +func (s *SetDefaultStorageVaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetDefaultStorageVault(s) + } +} + +func (s *SetDefaultStorageVaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetDefaultStorageVault(s) + + default: + return t.VisitChildren(s) + } +} + +type SetOptionsContext struct { + SupportedSetStatementContext +} + +func NewSetOptionsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetOptionsContext { + var p = new(SetOptionsContext) + + InitEmptySupportedSetStatementContext(&p.SupportedSetStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedSetStatementContext)) + + return p +} + +func (s *SetOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetOptionsContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *SetOptionsContext) AllOptionWithType() []IOptionWithTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOptionWithTypeContext); ok { + len++ + } + } + + tst := make([]IOptionWithTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOptionWithTypeContext); ok { + tst[i] = t.(IOptionWithTypeContext) + i++ + } + } + + return tst +} + +func (s *SetOptionsContext) OptionWithType(i int) IOptionWithTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionWithTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOptionWithTypeContext) +} + +func (s *SetOptionsContext) AllOptionWithoutType() []IOptionWithoutTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOptionWithoutTypeContext); ok { + len++ + } + } + + tst := make([]IOptionWithoutTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOptionWithoutTypeContext); ok { + tst[i] = t.(IOptionWithoutTypeContext) + i++ + } + } + + return tst +} + +func (s *SetOptionsContext) OptionWithoutType(i int) IOptionWithoutTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionWithoutTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOptionWithoutTypeContext) +} + +func (s *SetOptionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *SetOptionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *SetOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetOptions(s) + } +} + +func (s *SetOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetOptions(s) + } +} + +func (s *SetOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedSetStatement() (localctx ISupportedSetStatementContext) { + localctx = NewSupportedSetStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, DorisParserRULE_supportedSetStatement) + var _la int + + p.SetState(4508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 623, p.GetParserRuleContext()) { + case 1: + localctx = NewSetOptionsContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4462) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 617, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4463) + p.OptionWithType() + } + + case 2: + { + p.SetState(4464) + p.OptionWithoutType() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(4467) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4468) + p.OptionWithType() + } + + case 2: + { + p.SetState(4469) + p.OptionWithoutType() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(4476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + localctx = NewSetDefaultStorageVaultContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4477) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4478) + p.Identifier() + } + { + p.SetState(4479) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4480) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4481) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4482) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewSetUserPropertiesContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4484) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4485) + p.Match(DorisParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(4486) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4487) + + var _x = p.IdentifierOrText() + + localctx.(*SetUserPropertiesContext).user = _x + } + + } + { + p.SetState(4490) + p.PropertyItemList() + } + + case 4: + localctx = NewSetTransactionContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4491) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(4492) + p.StatementScope() + } + + } + { + p.SetState(4495) + p.Match(DorisParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4496) + p.TransactionAccessMode() + } + + case 2: + { + p.SetState(4497) + p.IsolationLevel() + } + + case 3: + { + p.SetState(4498) + p.TransactionAccessMode() + } + { + p.SetState(4499) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4500) + p.IsolationLevel() + } + + case 4: + { + p.SetState(4502) + p.IsolationLevel() + } + { + p.SetState(4503) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4504) + p.TransactionAccessMode() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionWithTypeContext is an interface to support dynamic dispatch. +type IOptionWithTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsOptionWithTypeContext differentiates from other interfaces. + IsOptionWithTypeContext() +} + +type OptionWithTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptionWithTypeContext() *OptionWithTypeContext { + var p = new(OptionWithTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optionWithType + return p +} + +func InitEmptyOptionWithTypeContext(p *OptionWithTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optionWithType +} + +func (*OptionWithTypeContext) IsOptionWithTypeContext() {} + +func NewOptionWithTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionWithTypeContext { + var p = new(OptionWithTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_optionWithType + + return p +} + +func (s *OptionWithTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionWithTypeContext) CopyAll(ctx *OptionWithTypeContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *OptionWithTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionWithTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SetVariableWithTypeContext struct { + OptionWithTypeContext +} + +func NewSetVariableWithTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetVariableWithTypeContext { + var p = new(SetVariableWithTypeContext) + + InitEmptyOptionWithTypeContext(&p.OptionWithTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithTypeContext)) + + return p +} + +func (s *SetVariableWithTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetVariableWithTypeContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *SetVariableWithTypeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SetVariableWithTypeContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *SetVariableWithTypeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SetVariableWithTypeContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *SetVariableWithTypeContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *SetVariableWithTypeContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *SetVariableWithTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetVariableWithType(s) + } +} + +func (s *SetVariableWithTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetVariableWithType(s) + } +} + +func (s *SetVariableWithTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetVariableWithType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) OptionWithType() (localctx IOptionWithTypeContext) { + localctx = NewOptionWithTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, DorisParserRULE_optionWithType) + localctx = NewSetVariableWithTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4510) + p.StatementScope() + } + { + p.SetState(4511) + p.Identifier() + } + { + p.SetState(4512) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_PAREN, DorisParserLEFT_BRACKET, DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserADD, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBINARY, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCASE, DorisParserCAST, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATABASE, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXISTS, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserEXTRACT, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFALSE, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIF, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINTERVAL, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserKEY, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLEFT, DorisParserLESS, DorisParserLEVEL, DorisParserLIKE, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNOT, DorisParserNULL, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLACEHOLDER, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREGEXP, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRIGHT, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRIM, DorisParserTRUE, DorisParserTRUNCATE, DorisParserTRY_CAST, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserPLUS, DorisParserSUBTRACT, DorisParserASTERISK, DorisParserTILDE, DorisParserLOGICALNOT, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserATSIGN, DorisParserDOUBLEATSIGN, DorisParserSTRING_LITERAL, DorisParserVARBINARY_LITERAL, DorisParserINTEGER_VALUE, DorisParserEXPONENT_VALUE, DorisParserDECIMAL_VALUE, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4513) + p.Expression() + } + + case DorisParserDEFAULT: + { + p.SetState(4514) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserON: + { + p.SetState(4515) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserALL: + { + p.SetState(4516) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionWithoutTypeContext is an interface to support dynamic dispatch. +type IOptionWithoutTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsOptionWithoutTypeContext differentiates from other interfaces. + IsOptionWithoutTypeContext() +} + +type OptionWithoutTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptionWithoutTypeContext() *OptionWithoutTypeContext { + var p = new(OptionWithoutTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optionWithoutType + return p +} + +func InitEmptyOptionWithoutTypeContext(p *OptionWithoutTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optionWithoutType +} + +func (*OptionWithoutTypeContext) IsOptionWithoutTypeContext() {} + +func NewOptionWithoutTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionWithoutTypeContext { + var p = new(OptionWithoutTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_optionWithoutType + + return p +} + +func (s *OptionWithoutTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionWithoutTypeContext) CopyAll(ctx *OptionWithoutTypeContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *OptionWithoutTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionWithoutTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SetNamesContext struct { + OptionWithoutTypeContext +} + +func NewSetNamesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNamesContext { + var p = new(SetNamesContext) + + InitEmptyOptionWithoutTypeContext(&p.OptionWithoutTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithoutTypeContext)) + + return p +} + +func (s *SetNamesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetNamesContext) NAMES() antlr.TerminalNode { + return s.GetToken(DorisParserNAMES, 0) +} + +func (s *SetNamesContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *SetNamesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SetNamesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetNames(s) + } +} + +func (s *SetNamesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetNames(s) + } +} + +func (s *SetNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetNames(s) + + default: + return t.VisitChildren(s) + } +} + +type SetCharsetContext struct { + OptionWithoutTypeContext + charsetName IIdentifierOrTextContext +} + +func NewSetCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetCharsetContext { + var p = new(SetCharsetContext) + + InitEmptyOptionWithoutTypeContext(&p.OptionWithoutTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithoutTypeContext)) + + return p +} + +func (s *SetCharsetContext) GetCharsetName() IIdentifierOrTextContext { return s.charsetName } + +func (s *SetCharsetContext) SetCharsetName(v IIdentifierOrTextContext) { s.charsetName = v } + +func (s *SetCharsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetCharsetContext) CHAR() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR, 0) +} + +func (s *SetCharsetContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *SetCharsetContext) CHARSET() antlr.TerminalNode { + return s.GetToken(DorisParserCHARSET, 0) +} + +func (s *SetCharsetContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *SetCharsetContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *SetCharsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetCharset(s) + } +} + +func (s *SetCharsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetCharset(s) + } +} + +func (s *SetCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetCharset(s) + + default: + return t.VisitChildren(s) + } +} + +type SetCollateContext struct { + OptionWithoutTypeContext + charsetName IIdentifierOrTextContext + collateName IIdentifierOrTextContext +} + +func NewSetCollateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetCollateContext { + var p = new(SetCollateContext) + + InitEmptyOptionWithoutTypeContext(&p.OptionWithoutTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithoutTypeContext)) + + return p +} + +func (s *SetCollateContext) GetCharsetName() IIdentifierOrTextContext { return s.charsetName } + +func (s *SetCollateContext) GetCollateName() IIdentifierOrTextContext { return s.collateName } + +func (s *SetCollateContext) SetCharsetName(v IIdentifierOrTextContext) { s.charsetName = v } + +func (s *SetCollateContext) SetCollateName(v IIdentifierOrTextContext) { s.collateName = v } + +func (s *SetCollateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetCollateContext) NAMES() antlr.TerminalNode { + return s.GetToken(DorisParserNAMES, 0) +} + +func (s *SetCollateContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(DorisParserDEFAULT) +} + +func (s *SetCollateContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, i) +} + +func (s *SetCollateContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *SetCollateContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *SetCollateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(DorisParserCOLLATE, 0) +} + +func (s *SetCollateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetCollate(s) + } +} + +func (s *SetCollateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetCollate(s) + } +} + +func (s *SetCollateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetCollate(s) + + default: + return t.VisitChildren(s) + } +} + +type SetPasswordContext struct { + OptionWithoutTypeContext + pwd antlr.Token + isPlain antlr.Token +} + +func NewSetPasswordContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetPasswordContext { + var p = new(SetPasswordContext) + + InitEmptyOptionWithoutTypeContext(&p.OptionWithoutTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithoutTypeContext)) + + return p +} + +func (s *SetPasswordContext) GetPwd() antlr.Token { return s.pwd } + +func (s *SetPasswordContext) GetIsPlain() antlr.Token { return s.isPlain } + +func (s *SetPasswordContext) SetPwd(v antlr.Token) { s.pwd = v } + +func (s *SetPasswordContext) SetIsPlain(v antlr.Token) { s.isPlain = v } + +func (s *SetPasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetPasswordContext) AllPASSWORD() []antlr.TerminalNode { + return s.GetTokens(DorisParserPASSWORD) +} + +func (s *SetPasswordContext) PASSWORD(i int) antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD, i) +} + +func (s *SetPasswordContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *SetPasswordContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *SetPasswordContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *SetPasswordContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *SetPasswordContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SetPasswordContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SetPasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetPassword(s) + } +} + +func (s *SetPasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetPassword(s) + } +} + +func (s *SetPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetPassword(s) + + default: + return t.VisitChildren(s) + } +} + +type SetVariableWithoutTypeContext struct { + OptionWithoutTypeContext +} + +func NewSetVariableWithoutTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetVariableWithoutTypeContext { + var p = new(SetVariableWithoutTypeContext) + + InitEmptyOptionWithoutTypeContext(&p.OptionWithoutTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithoutTypeContext)) + + return p +} + +func (s *SetVariableWithoutTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetVariableWithoutTypeContext) Variable() IVariableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableContext) +} + +func (s *SetVariableWithoutTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetVariableWithoutType(s) + } +} + +func (s *SetVariableWithoutTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetVariableWithoutType(s) + } +} + +func (s *SetVariableWithoutTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetVariableWithoutType(s) + + default: + return t.VisitChildren(s) + } +} + +type SetLdapAdminPasswordContext struct { + OptionWithoutTypeContext + pwd antlr.Token +} + +func NewSetLdapAdminPasswordContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetLdapAdminPasswordContext { + var p = new(SetLdapAdminPasswordContext) + + InitEmptyOptionWithoutTypeContext(&p.OptionWithoutTypeContext) + p.parser = parser + p.CopyAll(ctx.(*OptionWithoutTypeContext)) + + return p +} + +func (s *SetLdapAdminPasswordContext) GetPwd() antlr.Token { return s.pwd } + +func (s *SetLdapAdminPasswordContext) SetPwd(v antlr.Token) { s.pwd = v } + +func (s *SetLdapAdminPasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetLdapAdminPasswordContext) LDAP_ADMIN_PASSWORD() antlr.TerminalNode { + return s.GetToken(DorisParserLDAP_ADMIN_PASSWORD, 0) +} + +func (s *SetLdapAdminPasswordContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *SetLdapAdminPasswordContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *SetLdapAdminPasswordContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD, 0) +} + +func (s *SetLdapAdminPasswordContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SetLdapAdminPasswordContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SetLdapAdminPasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetLdapAdminPassword(s) + } +} + +func (s *SetLdapAdminPasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetLdapAdminPassword(s) + } +} + +func (s *SetLdapAdminPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetLdapAdminPassword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) OptionWithoutType() (localctx IOptionWithoutTypeContext) { + localctx = NewOptionWithoutTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, DorisParserRULE_optionWithoutType) + var _la int + + p.SetState(4564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 632, p.GetParserRuleContext()) { + case 1: + localctx = NewSetNamesContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4519) + p.Match(DorisParserNAMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4520) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4521) + p.Expression() + } + + case 2: + localctx = NewSetCharsetContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(4525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserCHAR: + { + p.SetState(4522) + p.Match(DorisParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4523) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCHARSET: + { + p.SetState(4524) + p.Match(DorisParserCHARSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4527) + + var _x = p.IdentifierOrText() + + localctx.(*SetCharsetContext).charsetName = _x + } + + case DorisParserDEFAULT: + { + p.SetState(4528) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + localctx = NewSetCollateContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4531) + p.Match(DorisParserNAMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4532) + + var _x = p.IdentifierOrText() + + localctx.(*SetCollateContext).charsetName = _x + } + + case DorisParserDEFAULT: + { + p.SetState(4533) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case DorisParserCOLLATE: + { + p.SetState(4536) + p.Match(DorisParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4537) + + var _x = p.IdentifierOrText() + + localctx.(*SetCollateContext).collateName = _x + } + + case DorisParserDEFAULT: + { + p.SetState(4538) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserEOF, DorisParserSEMICOLON, DorisParserCOMMA: + + default: + } + + case 4: + localctx = NewSetPasswordContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4541) + p.Match(DorisParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(4542) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4543) + p.UserIdentify() + } + + } + { + p.SetState(4546) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSTRING_LITERAL: + { + p.SetState(4547) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*SetPasswordContext).pwd = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserPASSWORD: + { + p.SetState(4548) + + var _m = p.Match(DorisParserPASSWORD) + + localctx.(*SetPasswordContext).isPlain = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4549) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4550) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*SetPasswordContext).pwd = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4551) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 5: + localctx = NewSetLdapAdminPasswordContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4554) + p.Match(DorisParserLDAP_ADMIN_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4555) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSTRING_LITERAL: + { + p.SetState(4556) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*SetLdapAdminPasswordContext).pwd = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserPASSWORD: + { + p.SetState(4557) + p.Match(DorisParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4558) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4559) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*SetLdapAdminPasswordContext).pwd = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4560) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + localctx = NewSetVariableWithoutTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4563) + p.Variable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariableContext is an interface to support dynamic dispatch. +type IVariableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsVariableContext differentiates from other interfaces. + IsVariableContext() +} + +type VariableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariableContext() *VariableContext { + var p = new(VariableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variable + return p +} + +func InitEmptyVariableContext(p *VariableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variable +} + +func (*VariableContext) IsVariableContext() {} + +func NewVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableContext { + var p = new(VariableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_variable + + return p +} + +func (s *VariableContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariableContext) CopyAll(ctx *VariableContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *VariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SetUserVariableContext struct { + VariableContext +} + +func NewSetUserVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetUserVariableContext { + var p = new(SetUserVariableContext) + + InitEmptyVariableContext(&p.VariableContext) + p.parser = parser + p.CopyAll(ctx.(*VariableContext)) + + return p +} + +func (s *SetUserVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetUserVariableContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *SetUserVariableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SetUserVariableContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *SetUserVariableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SetUserVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetUserVariable(s) + } +} + +func (s *SetUserVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetUserVariable(s) + } +} + +func (s *SetUserVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetUserVariable(s) + + default: + return t.VisitChildren(s) + } +} + +type SetSystemVariableContext struct { + VariableContext +} + +func NewSetSystemVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetSystemVariableContext { + var p = new(SetSystemVariableContext) + + InitEmptyVariableContext(&p.VariableContext) + p.parser = parser + p.CopyAll(ctx.(*VariableContext)) + + return p +} + +func (s *SetSystemVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetSystemVariableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SetSystemVariableContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *SetSystemVariableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SetSystemVariableContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *SetSystemVariableContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *SetSystemVariableContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *SetSystemVariableContext) DOUBLEATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserDOUBLEATSIGN, 0) +} + +func (s *SetSystemVariableContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *SetSystemVariableContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *SetSystemVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetSystemVariable(s) + } +} + +func (s *SetSystemVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetSystemVariable(s) + } +} + +func (s *SetSystemVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetSystemVariable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Variable() (localctx IVariableContext) { + localctx = NewVariableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, DorisParserRULE_variable) + var _la int + + p.SetState(4587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserDOUBLEATSIGN, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + localctx = NewSetSystemVariableContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(4572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDOUBLEATSIGN { + { + p.SetState(4566) + p.Match(DorisParserDOUBLEATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4570) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 633, p.GetParserRuleContext()) == 1 { + { + p.SetState(4567) + p.StatementScope() + } + { + p.SetState(4568) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + { + p.SetState(4574) + p.Identifier() + } + { + p.SetState(4575) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_PAREN, DorisParserLEFT_BRACKET, DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserADD, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBINARY, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCASE, DorisParserCAST, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATABASE, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXISTS, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserEXTRACT, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFALSE, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIF, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINTERVAL, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserKEY, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLEFT, DorisParserLESS, DorisParserLEVEL, DorisParserLIKE, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNOT, DorisParserNULL, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLACEHOLDER, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREGEXP, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRIGHT, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRIM, DorisParserTRUE, DorisParserTRUNCATE, DorisParserTRY_CAST, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserPLUS, DorisParserSUBTRACT, DorisParserASTERISK, DorisParserTILDE, DorisParserLOGICALNOT, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserATSIGN, DorisParserDOUBLEATSIGN, DorisParserSTRING_LITERAL, DorisParserVARBINARY_LITERAL, DorisParserINTEGER_VALUE, DorisParserEXPONENT_VALUE, DorisParserDECIMAL_VALUE, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4576) + p.Expression() + } + + case DorisParserDEFAULT: + { + p.SetState(4577) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserON: + { + p.SetState(4578) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserALL: + { + p.SetState(4579) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case DorisParserATSIGN: + localctx = NewSetUserVariableContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4582) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4583) + p.Identifier() + } + { + p.SetState(4584) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4585) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionAccessModeContext is an interface to support dynamic dispatch. +type ITransactionAccessModeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + + // IsTransactionAccessModeContext differentiates from other interfaces. + IsTransactionAccessModeContext() +} + +type TransactionAccessModeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionAccessModeContext() *TransactionAccessModeContext { + var p = new(TransactionAccessModeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_transactionAccessMode + return p +} + +func InitEmptyTransactionAccessModeContext(p *TransactionAccessModeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_transactionAccessMode +} + +func (*TransactionAccessModeContext) IsTransactionAccessModeContext() {} + +func NewTransactionAccessModeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionAccessModeContext { + var p = new(TransactionAccessModeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_transactionAccessMode + + return p +} + +func (s *TransactionAccessModeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionAccessModeContext) READ() antlr.TerminalNode { + return s.GetToken(DorisParserREAD, 0) +} + +func (s *TransactionAccessModeContext) ONLY() antlr.TerminalNode { + return s.GetToken(DorisParserONLY, 0) +} + +func (s *TransactionAccessModeContext) WRITE() antlr.TerminalNode { + return s.GetToken(DorisParserWRITE, 0) +} + +func (s *TransactionAccessModeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionAccessModeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionAccessModeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTransactionAccessMode(s) + } +} + +func (s *TransactionAccessModeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTransactionAccessMode(s) + } +} + +func (s *TransactionAccessModeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTransactionAccessMode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TransactionAccessMode() (localctx ITransactionAccessModeContext) { + localctx = NewTransactionAccessModeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, DorisParserRULE_transactionAccessMode) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4589) + p.Match(DorisParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4590) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserONLY || _la == DorisParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIsolationLevelContext is an interface to support dynamic dispatch. +type IIsolationLevelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + READ() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + + // IsIsolationLevelContext differentiates from other interfaces. + IsIsolationLevelContext() +} + +type IsolationLevelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIsolationLevelContext() *IsolationLevelContext { + var p = new(IsolationLevelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_isolationLevel + return p +} + +func InitEmptyIsolationLevelContext(p *IsolationLevelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_isolationLevel +} + +func (*IsolationLevelContext) IsIsolationLevelContext() {} + +func NewIsolationLevelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IsolationLevelContext { + var p = new(IsolationLevelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_isolationLevel + + return p +} + +func (s *IsolationLevelContext) GetParser() antlr.Parser { return s.parser } + +func (s *IsolationLevelContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(DorisParserISOLATION, 0) +} + +func (s *IsolationLevelContext) LEVEL() antlr.TerminalNode { + return s.GetToken(DorisParserLEVEL, 0) +} + +func (s *IsolationLevelContext) READ() antlr.TerminalNode { + return s.GetToken(DorisParserREAD, 0) +} + +func (s *IsolationLevelContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(DorisParserUNCOMMITTED, 0) +} + +func (s *IsolationLevelContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMITTED, 0) +} + +func (s *IsolationLevelContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(DorisParserREPEATABLE, 0) +} + +func (s *IsolationLevelContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(DorisParserSERIALIZABLE, 0) +} + +func (s *IsolationLevelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IsolationLevelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IsolationLevelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIsolationLevel(s) + } +} + +func (s *IsolationLevelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIsolationLevel(s) + } +} + +func (s *IsolationLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIsolationLevel(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IsolationLevel() (localctx IIsolationLevelContext) { + localctx = NewIsolationLevelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, DorisParserRULE_isolationLevel) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4592) + p.Match(DorisParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4593) + p.Match(DorisParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 637, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4594) + p.Match(DorisParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4595) + p.Match(DorisParserUNCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(4596) + p.Match(DorisParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4597) + p.Match(DorisParserCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(4598) + p.Match(DorisParserREPEATABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4599) + p.Match(DorisParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(4600) + p.Match(DorisParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedUnsetStatementContext is an interface to support dynamic dispatch. +type ISupportedUnsetStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSET() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + ALL() antlr.TerminalNode + Identifier() IIdentifierContext + StatementScope() IStatementScopeContext + DEFAULT() antlr.TerminalNode + STORAGE() antlr.TerminalNode + VAULT() antlr.TerminalNode + + // IsSupportedUnsetStatementContext differentiates from other interfaces. + IsSupportedUnsetStatementContext() +} + +type SupportedUnsetStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedUnsetStatementContext() *SupportedUnsetStatementContext { + var p = new(SupportedUnsetStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedUnsetStatement + return p +} + +func InitEmptySupportedUnsetStatementContext(p *SupportedUnsetStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedUnsetStatement +} + +func (*SupportedUnsetStatementContext) IsSupportedUnsetStatementContext() {} + +func NewSupportedUnsetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedUnsetStatementContext { + var p = new(SupportedUnsetStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedUnsetStatement + + return p +} + +func (s *SupportedUnsetStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedUnsetStatementContext) UNSET() antlr.TerminalNode { + return s.GetToken(DorisParserUNSET, 0) +} + +func (s *SupportedUnsetStatementContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(DorisParserVARIABLE, 0) +} + +func (s *SupportedUnsetStatementContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *SupportedUnsetStatementContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SupportedUnsetStatementContext) StatementScope() IStatementScopeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementScopeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementScopeContext) +} + +func (s *SupportedUnsetStatementContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *SupportedUnsetStatementContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *SupportedUnsetStatementContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *SupportedUnsetStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedUnsetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SupportedUnsetStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSupportedUnsetStatement(s) + } +} + +func (s *SupportedUnsetStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSupportedUnsetStatement(s) + } +} + +func (s *SupportedUnsetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSupportedUnsetStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedUnsetStatement() (localctx ISupportedUnsetStatementContext) { + localctx = NewSupportedUnsetStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, DorisParserRULE_supportedUnsetStatement) + var _la int + + p.SetState(4616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4603) + p.Match(DorisParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION { + { + p.SetState(4604) + p.StatementScope() + } + + } + { + p.SetState(4607) + p.Match(DorisParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserALL: + { + p.SetState(4608) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4609) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4612) + p.Match(DorisParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4613) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4614) + p.Match(DorisParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4615) + p.Match(DorisParserVAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedUseStatementContext is an interface to support dynamic dispatch. +type ISupportedUseStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedUseStatementContext differentiates from other interfaces. + IsSupportedUseStatementContext() +} + +type SupportedUseStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedUseStatementContext() *SupportedUseStatementContext { + var p = new(SupportedUseStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedUseStatement + return p +} + +func InitEmptySupportedUseStatementContext(p *SupportedUseStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedUseStatement +} + +func (*SupportedUseStatementContext) IsSupportedUseStatementContext() {} + +func NewSupportedUseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedUseStatementContext { + var p = new(SupportedUseStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedUseStatement + + return p +} + +func (s *SupportedUseStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedUseStatementContext) CopyAll(ctx *SupportedUseStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedUseStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedUseStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type UseCloudClusterContext struct { + SupportedUseStatementContext + catalog IIdentifierContext + database IIdentifierContext + cluster IIdentifierContext +} + +func NewUseCloudClusterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UseCloudClusterContext { + var p = new(UseCloudClusterContext) + + InitEmptySupportedUseStatementContext(&p.SupportedUseStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedUseStatementContext)) + + return p +} + +func (s *UseCloudClusterContext) GetCatalog() IIdentifierContext { return s.catalog } + +func (s *UseCloudClusterContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *UseCloudClusterContext) GetCluster() IIdentifierContext { return s.cluster } + +func (s *UseCloudClusterContext) SetCatalog(v IIdentifierContext) { s.catalog = v } + +func (s *UseCloudClusterContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *UseCloudClusterContext) SetCluster(v IIdentifierContext) { s.cluster = v } + +func (s *UseCloudClusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UseCloudClusterContext) USE() antlr.TerminalNode { + return s.GetToken(DorisParserUSE, 0) +} + +func (s *UseCloudClusterContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *UseCloudClusterContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *UseCloudClusterContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *UseCloudClusterContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *UseCloudClusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUseCloudCluster(s) + } +} + +func (s *UseCloudClusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUseCloudCluster(s) + } +} + +func (s *UseCloudClusterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUseCloudCluster(s) + + default: + return t.VisitChildren(s) + } +} + +type UseDatabaseContext struct { + SupportedUseStatementContext + catalog IIdentifierContext + database IIdentifierContext +} + +func NewUseDatabaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UseDatabaseContext { + var p = new(UseDatabaseContext) + + InitEmptySupportedUseStatementContext(&p.SupportedUseStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedUseStatementContext)) + + return p +} + +func (s *UseDatabaseContext) GetCatalog() IIdentifierContext { return s.catalog } + +func (s *UseDatabaseContext) GetDatabase() IIdentifierContext { return s.database } + +func (s *UseDatabaseContext) SetCatalog(v IIdentifierContext) { s.catalog = v } + +func (s *UseDatabaseContext) SetDatabase(v IIdentifierContext) { s.database = v } + +func (s *UseDatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UseDatabaseContext) USE() antlr.TerminalNode { + return s.GetToken(DorisParserUSE, 0) +} + +func (s *UseDatabaseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *UseDatabaseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *UseDatabaseContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *UseDatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUseDatabase(s) + } +} + +func (s *UseDatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUseDatabase(s) + } +} + +func (s *UseDatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUseDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +type SwitchCatalogContext struct { + SupportedUseStatementContext + catalog IIdentifierContext +} + +func NewSwitchCatalogContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SwitchCatalogContext { + var p = new(SwitchCatalogContext) + + InitEmptySupportedUseStatementContext(&p.SupportedUseStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedUseStatementContext)) + + return p +} + +func (s *SwitchCatalogContext) GetCatalog() IIdentifierContext { return s.catalog } + +func (s *SwitchCatalogContext) SetCatalog(v IIdentifierContext) { s.catalog = v } + +func (s *SwitchCatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SwitchCatalogContext) SWITCH() antlr.TerminalNode { + return s.GetToken(DorisParserSWITCH, 0) +} + +func (s *SwitchCatalogContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SwitchCatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSwitchCatalog(s) + } +} + +func (s *SwitchCatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSwitchCatalog(s) + } +} + +func (s *SwitchCatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSwitchCatalog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedUseStatement() (localctx ISupportedUseStatementContext) { + localctx = NewSupportedUseStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, DorisParserRULE_supportedUseStatement) + var _la int + + p.SetState(4638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 644, p.GetParserRuleContext()) { + case 1: + localctx = NewSwitchCatalogContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4618) + p.Match(DorisParserSWITCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4619) + + var _x = p.Identifier() + + localctx.(*SwitchCatalogContext).catalog = _x + } + + case 2: + localctx = NewUseDatabaseContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4620) + p.Match(DorisParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4624) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) == 1 { + { + p.SetState(4621) + + var _x = p.Identifier() + + localctx.(*UseDatabaseContext).catalog = _x + } + { + p.SetState(4622) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4626) + + var _x = p.Identifier() + + localctx.(*UseDatabaseContext).database = _x + } + + case 3: + localctx = NewUseCloudClusterContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4627) + p.Match(DorisParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1179945026516488447) != 0) { + p.SetState(4631) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) == 1 { + { + p.SetState(4628) + + var _x = p.Identifier() + + localctx.(*UseCloudClusterContext).catalog = _x + } + { + p.SetState(4629) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4633) + + var _x = p.Identifier() + + localctx.(*UseCloudClusterContext).database = _x + } + + } + { + p.SetState(4636) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4637) + + var _x = p.Identifier() + + localctx.(*UseCloudClusterContext).cluster = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStageAndPatternContext is an interface to support dynamic dispatch. +type IStageAndPatternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPattern returns the pattern token. + GetPattern() antlr.Token + + // SetPattern sets the pattern token. + SetPattern(antlr.Token) + + // GetStage returns the stage rule contexts. + GetStage() IIdentifierContext + + // SetStage sets the stage rule contexts. + SetStage(IIdentifierContext) + + // Getter signatures + ATSIGN() antlr.TerminalNode + TILDE() antlr.TerminalNode + Identifier() IIdentifierContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsStageAndPatternContext differentiates from other interfaces. + IsStageAndPatternContext() +} + +type StageAndPatternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + stage IIdentifierContext + pattern antlr.Token +} + +func NewEmptyStageAndPatternContext() *StageAndPatternContext { + var p = new(StageAndPatternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_stageAndPattern + return p +} + +func InitEmptyStageAndPatternContext(p *StageAndPatternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_stageAndPattern +} + +func (*StageAndPatternContext) IsStageAndPatternContext() {} + +func NewStageAndPatternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StageAndPatternContext { + var p = new(StageAndPatternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_stageAndPattern + + return p +} + +func (s *StageAndPatternContext) GetParser() antlr.Parser { return s.parser } + +func (s *StageAndPatternContext) GetPattern() antlr.Token { return s.pattern } + +func (s *StageAndPatternContext) SetPattern(v antlr.Token) { s.pattern = v } + +func (s *StageAndPatternContext) GetStage() IIdentifierContext { return s.stage } + +func (s *StageAndPatternContext) SetStage(v IIdentifierContext) { s.stage = v } + +func (s *StageAndPatternContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *StageAndPatternContext) TILDE() antlr.TerminalNode { + return s.GetToken(DorisParserTILDE, 0) +} + +func (s *StageAndPatternContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *StageAndPatternContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *StageAndPatternContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *StageAndPatternContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *StageAndPatternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StageAndPatternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StageAndPatternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStageAndPattern(s) + } +} + +func (s *StageAndPatternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStageAndPattern(s) + } +} + +func (s *StageAndPatternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStageAndPattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) StageAndPattern() (localctx IStageAndPatternContext) { + localctx = NewStageAndPatternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, DorisParserRULE_stageAndPattern) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4640) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4641) + + var _x = p.Identifier() + + localctx.(*StageAndPatternContext).stage = _x + } + + case DorisParserTILDE: + { + p.SetState(4642) + p.Match(DorisParserTILDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4645) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4646) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*StageAndPatternContext).pattern = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4647) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupportedDescribeStatementContext is an interface to support dynamic dispatch. +type ISupportedDescribeStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSupportedDescribeStatementContext differentiates from other interfaces. + IsSupportedDescribeStatementContext() +} + +type SupportedDescribeStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupportedDescribeStatementContext() *SupportedDescribeStatementContext { + var p = new(SupportedDescribeStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedDescribeStatement + return p +} + +func InitEmptySupportedDescribeStatementContext(p *SupportedDescribeStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_supportedDescribeStatement +} + +func (*SupportedDescribeStatementContext) IsSupportedDescribeStatementContext() {} + +func NewSupportedDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SupportedDescribeStatementContext { + var p = new(SupportedDescribeStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_supportedDescribeStatement + + return p +} + +func (s *SupportedDescribeStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SupportedDescribeStatementContext) CopyAll(ctx *SupportedDescribeStatementContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SupportedDescribeStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SupportedDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DescribeTableValuedFunctionContext struct { + SupportedDescribeStatementContext + tvfName IIdentifierContext + properties IPropertyItemListContext +} + +func NewDescribeTableValuedFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeTableValuedFunctionContext { + var p = new(DescribeTableValuedFunctionContext) + + InitEmptySupportedDescribeStatementContext(&p.SupportedDescribeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDescribeStatementContext)) + + return p +} + +func (s *DescribeTableValuedFunctionContext) GetTvfName() IIdentifierContext { return s.tvfName } + +func (s *DescribeTableValuedFunctionContext) GetProperties() IPropertyItemListContext { + return s.properties +} + +func (s *DescribeTableValuedFunctionContext) SetTvfName(v IIdentifierContext) { s.tvfName = v } + +func (s *DescribeTableValuedFunctionContext) SetProperties(v IPropertyItemListContext) { + s.properties = v +} + +func (s *DescribeTableValuedFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeTableValuedFunctionContext) ExplainCommand() IExplainCommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainCommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainCommandContext) +} + +func (s *DescribeTableValuedFunctionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *DescribeTableValuedFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *DescribeTableValuedFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *DescribeTableValuedFunctionContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *DescribeTableValuedFunctionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DescribeTableValuedFunctionContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *DescribeTableValuedFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDescribeTableValuedFunction(s) + } +} + +func (s *DescribeTableValuedFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDescribeTableValuedFunction(s) + } +} + +func (s *DescribeTableValuedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDescribeTableValuedFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type DescribeTableContext struct { + SupportedDescribeStatementContext +} + +func NewDescribeTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeTableContext { + var p = new(DescribeTableContext) + + InitEmptySupportedDescribeStatementContext(&p.SupportedDescribeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDescribeStatementContext)) + + return p +} + +func (s *DescribeTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeTableContext) ExplainCommand() IExplainCommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainCommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainCommandContext) +} + +func (s *DescribeTableContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DescribeTableContext) SpecifiedPartition() ISpecifiedPartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecifiedPartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpecifiedPartitionContext) +} + +func (s *DescribeTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDescribeTable(s) + } +} + +func (s *DescribeTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDescribeTable(s) + } +} + +func (s *DescribeTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDescribeTable(s) + + default: + return t.VisitChildren(s) + } +} + +type DescribeTableAllContext struct { + SupportedDescribeStatementContext +} + +func NewDescribeTableAllContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeTableAllContext { + var p = new(DescribeTableAllContext) + + InitEmptySupportedDescribeStatementContext(&p.SupportedDescribeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDescribeStatementContext)) + + return p +} + +func (s *DescribeTableAllContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeTableAllContext) ExplainCommand() IExplainCommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainCommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainCommandContext) +} + +func (s *DescribeTableAllContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DescribeTableAllContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *DescribeTableAllContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDescribeTableAll(s) + } +} + +func (s *DescribeTableAllContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDescribeTableAll(s) + } +} + +func (s *DescribeTableAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDescribeTableAll(s) + + default: + return t.VisitChildren(s) + } +} + +type DescribeDictionaryContext struct { + SupportedDescribeStatementContext +} + +func NewDescribeDictionaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeDictionaryContext { + var p = new(DescribeDictionaryContext) + + InitEmptySupportedDescribeStatementContext(&p.SupportedDescribeStatementContext) + p.parser = parser + p.CopyAll(ctx.(*SupportedDescribeStatementContext)) + + return p +} + +func (s *DescribeDictionaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeDictionaryContext) ExplainCommand() IExplainCommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainCommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainCommandContext) +} + +func (s *DescribeDictionaryContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARY, 0) +} + +func (s *DescribeDictionaryContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *DescribeDictionaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDescribeDictionary(s) + } +} + +func (s *DescribeDictionaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDescribeDictionary(s) + } +} + +func (s *DescribeDictionaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDescribeDictionary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SupportedDescribeStatement() (localctx ISupportedDescribeStatementContext) { + localctx = NewSupportedDescribeStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, DorisParserRULE_supportedDescribeStatement) + var _la int + + p.SetState(4673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 649, p.GetParserRuleContext()) { + case 1: + localctx = NewDescribeTableValuedFunctionContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4650) + p.ExplainCommand() + } + { + p.SetState(4651) + p.Match(DorisParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4652) + + var _x = p.Identifier() + + localctx.(*DescribeTableValuedFunctionContext).tvfName = _x + } + { + p.SetState(4653) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-7)) & ^0x3f) == 0 && ((int64(1)<<(_la-7))&-4071395127667384755) != 0) || ((int64((_la-71)) & ^0x3f) == 0 && ((int64(1)<<(_la-71))&-6386157293049745705) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485008317210093361) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-2666703833553702093) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439307733023) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605691481683905) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1183912064503058687) != 0) { + { + p.SetState(4654) + + var _x = p.PropertyItemList() + + localctx.(*DescribeTableValuedFunctionContext).properties = _x + } + + } + { + p.SetState(4657) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4658) + p.TableAlias() + } + + case 2: + localctx = NewDescribeTableAllContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4660) + p.ExplainCommand() + } + { + p.SetState(4661) + p.MultipartIdentifier() + } + { + p.SetState(4662) + p.Match(DorisParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewDescribeTableContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4664) + p.ExplainCommand() + } + { + p.SetState(4665) + p.MultipartIdentifier() + } + p.SetState(4667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4666) + p.SpecifiedPartition() + } + + } + + case 4: + localctx = NewDescribeDictionaryContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4669) + p.ExplainCommand() + } + { + p.SetState(4670) + p.Match(DorisParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4671) + p.MultipartIdentifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintContext is an interface to support dynamic dispatch. +type IConstraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSlots returns the slots rule contexts. + GetSlots() IIdentifierListContext + + // GetReferenceTable returns the referenceTable rule contexts. + GetReferenceTable() IMultipartIdentifierContext + + // GetReferencedSlots returns the referencedSlots rule contexts. + GetReferencedSlots() IIdentifierListContext + + // SetSlots sets the slots rule contexts. + SetSlots(IIdentifierListContext) + + // SetReferenceTable sets the referenceTable rule contexts. + SetReferenceTable(IMultipartIdentifierContext) + + // SetReferencedSlots sets the referencedSlots rule contexts. + SetReferencedSlots(IIdentifierListContext) + + // Getter signatures + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + AllIdentifierList() []IIdentifierListContext + IdentifierList(i int) IIdentifierListContext + UNIQUE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + MultipartIdentifier() IMultipartIdentifierContext + + // IsConstraintContext differentiates from other interfaces. + IsConstraintContext() +} + +type ConstraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + slots IIdentifierListContext + referenceTable IMultipartIdentifierContext + referencedSlots IIdentifierListContext +} + +func NewEmptyConstraintContext() *ConstraintContext { + var p = new(ConstraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constraint + return p +} + +func InitEmptyConstraintContext(p *ConstraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constraint +} + +func (*ConstraintContext) IsConstraintContext() {} + +func NewConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintContext { + var p = new(ConstraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_constraint + + return p +} + +func (s *ConstraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintContext) GetSlots() IIdentifierListContext { return s.slots } + +func (s *ConstraintContext) GetReferenceTable() IMultipartIdentifierContext { return s.referenceTable } + +func (s *ConstraintContext) GetReferencedSlots() IIdentifierListContext { return s.referencedSlots } + +func (s *ConstraintContext) SetSlots(v IIdentifierListContext) { s.slots = v } + +func (s *ConstraintContext) SetReferenceTable(v IMultipartIdentifierContext) { s.referenceTable = v } + +func (s *ConstraintContext) SetReferencedSlots(v IIdentifierListContext) { s.referencedSlots = v } + +func (s *ConstraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(DorisParserPRIMARY, 0) +} + +func (s *ConstraintContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *ConstraintContext) AllIdentifierList() []IIdentifierListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierListContext); ok { + len++ + } + } + + tst := make([]IIdentifierListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierListContext); ok { + tst[i] = t.(IIdentifierListContext) + i++ + } + } + + return tst +} + +func (s *ConstraintContext) IdentifierList(i int) IIdentifierListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ConstraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(DorisParserUNIQUE, 0) +} + +func (s *ConstraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(DorisParserFOREIGN, 0) +} + +func (s *ConstraintContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(DorisParserREFERENCES, 0) +} + +func (s *ConstraintContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *ConstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterConstraint(s) + } +} + +func (s *ConstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitConstraint(s) + } +} + +func (s *ConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitConstraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Constraint() (localctx IConstraintContext) { + localctx = NewConstraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, DorisParserRULE_constraint) + p.SetState(4687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserPRIMARY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4675) + p.Match(DorisParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4676) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4677) + + var _x = p.IdentifierList() + + localctx.(*ConstraintContext).slots = _x + } + + case DorisParserUNIQUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4678) + p.Match(DorisParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4679) + + var _x = p.IdentifierList() + + localctx.(*ConstraintContext).slots = _x + } + + case DorisParserFOREIGN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4680) + p.Match(DorisParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4681) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4682) + + var _x = p.IdentifierList() + + localctx.(*ConstraintContext).slots = _x + } + { + p.SetState(4683) + p.Match(DorisParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4684) + + var _x = p.MultipartIdentifier() + + localctx.(*ConstraintContext).referenceTable = _x + } + { + p.SetState(4685) + + var _x = p.IdentifierList() + + localctx.(*ConstraintContext).referencedSlots = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionSpecContext is an interface to support dynamic dispatch. +type IPartitionSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartitions returns the partitions rule contexts. + GetPartitions() IIdentifierListContext + + // GetPartition returns the partition rule contexts. + GetPartition() IErrorCapturingIdentifierContext + + // SetPartitions sets the partitions rule contexts. + SetPartitions(IIdentifierListContext) + + // SetPartition sets the partition rule contexts. + SetPartition(IErrorCapturingIdentifierContext) + + // Getter signatures + PARTITION() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + IdentifierList() IIdentifierListContext + TEMPORARY() antlr.TerminalNode + ErrorCapturingIdentifier() IErrorCapturingIdentifierContext + LEFT_PAREN() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsPartitionSpecContext differentiates from other interfaces. + IsPartitionSpecContext() +} + +type PartitionSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitions IIdentifierListContext + partition IErrorCapturingIdentifierContext +} + +func NewEmptyPartitionSpecContext() *PartitionSpecContext { + var p = new(PartitionSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionSpec + return p +} + +func InitEmptyPartitionSpecContext(p *PartitionSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionSpec +} + +func (*PartitionSpecContext) IsPartitionSpecContext() {} + +func NewPartitionSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionSpecContext { + var p = new(PartitionSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionSpec + + return p +} + +func (s *PartitionSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionSpecContext) GetPartitions() IIdentifierListContext { return s.partitions } + +func (s *PartitionSpecContext) GetPartition() IErrorCapturingIdentifierContext { return s.partition } + +func (s *PartitionSpecContext) SetPartitions(v IIdentifierListContext) { s.partitions = v } + +func (s *PartitionSpecContext) SetPartition(v IErrorCapturingIdentifierContext) { s.partition = v } + +func (s *PartitionSpecContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *PartitionSpecContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITIONS, 0) +} + +func (s *PartitionSpecContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *PartitionSpecContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *PartitionSpecContext) ErrorCapturingIdentifier() IErrorCapturingIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierContext) +} + +func (s *PartitionSpecContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PartitionSpecContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *PartitionSpecContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PartitionSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionSpec(s) + } +} + +func (s *PartitionSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionSpec(s) + } +} + +func (s *PartitionSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionSpec() (localctx IPartitionSpecContext) { + localctx = NewPartitionSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, DorisParserRULE_partitionSpec) + var _la int + + p.SetState(4703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 653, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(4690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(4689) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4692) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserPARTITION || _la == DorisParserPARTITIONS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4693) + + var _x = p.IdentifierList() + + localctx.(*PartitionSpecContext).partitions = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(4695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(4694) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4697) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4698) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*PartitionSpecContext).partition = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4699) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserPARTITION || _la == DorisParserPARTITIONS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4700) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4701) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4702) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionTableContext is an interface to support dynamic dispatch. +type IPartitionTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAutoPartition returns the autoPartition token. + GetAutoPartition() antlr.Token + + // SetAutoPartition sets the autoPartition token. + SetAutoPartition(antlr.Token) + + // GetPartitionList returns the partitionList rule contexts. + GetPartitionList() IIdentityOrFunctionListContext + + // GetPartitions returns the partitions rule contexts. + GetPartitions() IPartitionsDefContext + + // SetPartitionList sets the partitionList rule contexts. + SetPartitionList(IIdentityOrFunctionListContext) + + // SetPartitions sets the partitions rule contexts. + SetPartitions(IPartitionsDefContext) + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + IdentityOrFunctionList() IIdentityOrFunctionListContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AUTO() antlr.TerminalNode + RANGE() antlr.TerminalNode + LIST() antlr.TerminalNode + PartitionsDef() IPartitionsDefContext + + // IsPartitionTableContext differentiates from other interfaces. + IsPartitionTableContext() +} + +type PartitionTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + autoPartition antlr.Token + partitionList IIdentityOrFunctionListContext + partitions IPartitionsDefContext +} + +func NewEmptyPartitionTableContext() *PartitionTableContext { + var p = new(PartitionTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionTable + return p +} + +func InitEmptyPartitionTableContext(p *PartitionTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionTable +} + +func (*PartitionTableContext) IsPartitionTableContext() {} + +func NewPartitionTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionTableContext { + var p = new(PartitionTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionTable + + return p +} + +func (s *PartitionTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionTableContext) GetAutoPartition() antlr.Token { return s.autoPartition } + +func (s *PartitionTableContext) SetAutoPartition(v antlr.Token) { s.autoPartition = v } + +func (s *PartitionTableContext) GetPartitionList() IIdentityOrFunctionListContext { + return s.partitionList +} + +func (s *PartitionTableContext) GetPartitions() IPartitionsDefContext { return s.partitions } + +func (s *PartitionTableContext) SetPartitionList(v IIdentityOrFunctionListContext) { + s.partitionList = v +} + +func (s *PartitionTableContext) SetPartitions(v IPartitionsDefContext) { s.partitions = v } + +func (s *PartitionTableContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *PartitionTableContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *PartitionTableContext) IdentityOrFunctionList() IIdentityOrFunctionListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentityOrFunctionListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentityOrFunctionListContext) +} + +func (s *PartitionTableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PartitionTableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PartitionTableContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *PartitionTableContext) RANGE() antlr.TerminalNode { + return s.GetToken(DorisParserRANGE, 0) +} + +func (s *PartitionTableContext) LIST() antlr.TerminalNode { + return s.GetToken(DorisParserLIST, 0) +} + +func (s *PartitionTableContext) PartitionsDef() IPartitionsDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionsDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionsDefContext) +} + +func (s *PartitionTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionTable(s) + } +} + +func (s *PartitionTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionTable(s) + } +} + +func (s *PartitionTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionTable() (localctx IPartitionTableContext) { + localctx = NewPartitionTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, DorisParserRULE_partitionTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAUTO { + { + p.SetState(4705) + + var _m = p.Match(DorisParserAUTO) + + localctx.(*PartitionTableContext).autoPartition = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4708) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4709) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLIST || _la == DorisParserRANGE { + { + p.SetState(4710) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserLIST || _la == DorisParserRANGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(4713) + + var _x = p.IdentityOrFunctionList() + + localctx.(*PartitionTableContext).partitionList = _x + } + + { + p.SetState(4714) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFROM || _la == DorisParserPARTITION { + { + p.SetState(4715) + + var _x = p.PartitionsDef() + + localctx.(*PartitionTableContext).partitions = _x + } + + } + { + p.SetState(4718) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentityOrFunctionListContext is an interface to support dynamic dispatch. +type IIdentityOrFunctionListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_identityOrFunction returns the _identityOrFunction rule contexts. + Get_identityOrFunction() IIdentityOrFunctionContext + + // Set_identityOrFunction sets the _identityOrFunction rule contexts. + Set_identityOrFunction(IIdentityOrFunctionContext) + + // GetPartitions returns the partitions rule context list. + GetPartitions() []IIdentityOrFunctionContext + + // SetPartitions sets the partitions rule context list. + SetPartitions([]IIdentityOrFunctionContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllIdentityOrFunction() []IIdentityOrFunctionContext + IdentityOrFunction(i int) IIdentityOrFunctionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIdentityOrFunctionListContext differentiates from other interfaces. + IsIdentityOrFunctionListContext() +} + +type IdentityOrFunctionListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _identityOrFunction IIdentityOrFunctionContext + partitions []IIdentityOrFunctionContext +} + +func NewEmptyIdentityOrFunctionListContext() *IdentityOrFunctionListContext { + var p = new(IdentityOrFunctionListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identityOrFunctionList + return p +} + +func InitEmptyIdentityOrFunctionListContext(p *IdentityOrFunctionListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identityOrFunctionList +} + +func (*IdentityOrFunctionListContext) IsIdentityOrFunctionListContext() {} + +func NewIdentityOrFunctionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentityOrFunctionListContext { + var p = new(IdentityOrFunctionListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identityOrFunctionList + + return p +} + +func (s *IdentityOrFunctionListContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentityOrFunctionListContext) Get_identityOrFunction() IIdentityOrFunctionContext { + return s._identityOrFunction +} + +func (s *IdentityOrFunctionListContext) Set_identityOrFunction(v IIdentityOrFunctionContext) { + s._identityOrFunction = v +} + +func (s *IdentityOrFunctionListContext) GetPartitions() []IIdentityOrFunctionContext { + return s.partitions +} + +func (s *IdentityOrFunctionListContext) SetPartitions(v []IIdentityOrFunctionContext) { + s.partitions = v +} + +func (s *IdentityOrFunctionListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *IdentityOrFunctionListContext) AllIdentityOrFunction() []IIdentityOrFunctionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentityOrFunctionContext); ok { + len++ + } + } + + tst := make([]IIdentityOrFunctionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentityOrFunctionContext); ok { + tst[i] = t.(IIdentityOrFunctionContext) + i++ + } + } + + return tst +} + +func (s *IdentityOrFunctionListContext) IdentityOrFunction(i int) IIdentityOrFunctionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentityOrFunctionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentityOrFunctionContext) +} + +func (s *IdentityOrFunctionListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *IdentityOrFunctionListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *IdentityOrFunctionListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *IdentityOrFunctionListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentityOrFunctionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentityOrFunctionListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentityOrFunctionList(s) + } +} + +func (s *IdentityOrFunctionListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentityOrFunctionList(s) + } +} + +func (s *IdentityOrFunctionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentityOrFunctionList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentityOrFunctionList() (localctx IIdentityOrFunctionListContext) { + localctx = NewIdentityOrFunctionListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, DorisParserRULE_identityOrFunctionList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4720) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4721) + p.IdentityOrFunction() + } + p.SetState(4726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(4722) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4723) + + var _x = p.IdentityOrFunction() + + localctx.(*IdentityOrFunctionListContext)._identityOrFunction = _x + } + localctx.(*IdentityOrFunctionListContext).partitions = append(localctx.(*IdentityOrFunctionListContext).partitions, localctx.(*IdentityOrFunctionListContext)._identityOrFunction) + + p.SetState(4728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4729) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentityOrFunctionContext is an interface to support dynamic dispatch. +type IIdentityOrFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + FunctionCallExpression() IFunctionCallExpressionContext + + // IsIdentityOrFunctionContext differentiates from other interfaces. + IsIdentityOrFunctionContext() +} + +type IdentityOrFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentityOrFunctionContext() *IdentityOrFunctionContext { + var p = new(IdentityOrFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identityOrFunction + return p +} + +func InitEmptyIdentityOrFunctionContext(p *IdentityOrFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identityOrFunction +} + +func (*IdentityOrFunctionContext) IsIdentityOrFunctionContext() {} + +func NewIdentityOrFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentityOrFunctionContext { + var p = new(IdentityOrFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identityOrFunction + + return p +} + +func (s *IdentityOrFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentityOrFunctionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *IdentityOrFunctionContext) FunctionCallExpression() IFunctionCallExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallExpressionContext) +} + +func (s *IdentityOrFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentityOrFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentityOrFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentityOrFunction(s) + } +} + +func (s *IdentityOrFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentityOrFunction(s) + } +} + +func (s *IdentityOrFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentityOrFunction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentityOrFunction() (localctx IIdentityOrFunctionContext) { + localctx = NewIdentityOrFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, DorisParserRULE_identityOrFunction) + p.EnterOuterAlt(localctx, 1) + p.SetState(4733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 658, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4731) + p.Identifier() + } + + case 2: + { + p.SetState(4732) + p.FunctionCallExpression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataDescContext is an interface to support dynamic dispatch. +type IDataDescContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_STRING_LITERAL returns the _STRING_LITERAL token. + Get_STRING_LITERAL() antlr.Token + + // GetNegative returns the negative token. + GetNegative() antlr.Token + + // GetComma returns the comma token. + GetComma() antlr.Token + + // GetSeparator returns the separator token. + GetSeparator() antlr.Token + + // Set_STRING_LITERAL sets the _STRING_LITERAL token. + Set_STRING_LITERAL(antlr.Token) + + // SetNegative sets the negative token. + SetNegative(antlr.Token) + + // SetComma sets the comma token. + SetComma(antlr.Token) + + // SetSeparator sets the separator token. + SetSeparator(antlr.Token) + + // GetFilePaths returns the filePaths token list. + GetFilePaths() []antlr.Token + + // GetFilePath returns the filePath token list. + GetFilePath() []antlr.Token + + // SetFilePaths sets the filePaths token list. + SetFilePaths([]antlr.Token) + + // SetFilePath sets the filePath token list. + SetFilePath([]antlr.Token) + + // GetTargetTableName returns the targetTableName rule contexts. + GetTargetTableName() IIdentifierContext + + // GetFormat returns the format rule contexts. + GetFormat() IIdentifierOrTextContext + + // GetCompressType returns the compressType rule contexts. + GetCompressType() IIdentifierOrTextContext + + // GetColumns returns the columns rule contexts. + GetColumns() IIdentifierListContext + + // GetColumnsFromPath returns the columnsFromPath rule contexts. + GetColumnsFromPath() IColFromPathContext + + // GetColumnMapping returns the columnMapping rule contexts. + GetColumnMapping() IColMappingListContext + + // GetPreFilter returns the preFilter rule contexts. + GetPreFilter() IPreFilterClauseContext + + // GetWhere returns the where rule contexts. + GetWhere() IWhereClauseContext + + // GetDeleteOn returns the deleteOn rule contexts. + GetDeleteOn() IDeleteOnClauseContext + + // GetSequenceColumn returns the sequenceColumn rule contexts. + GetSequenceColumn() ISequenceColClauseContext + + // GetSourceTableName returns the sourceTableName rule contexts. + GetSourceTableName() IIdentifierContext + + // GetPartition returns the partition rule contexts. + GetPartition() IIdentifierListContext + + // SetTargetTableName sets the targetTableName rule contexts. + SetTargetTableName(IIdentifierContext) + + // SetFormat sets the format rule contexts. + SetFormat(IIdentifierOrTextContext) + + // SetCompressType sets the compressType rule contexts. + SetCompressType(IIdentifierOrTextContext) + + // SetColumns sets the columns rule contexts. + SetColumns(IIdentifierListContext) + + // SetColumnsFromPath sets the columnsFromPath rule contexts. + SetColumnsFromPath(IColFromPathContext) + + // SetColumnMapping sets the columnMapping rule contexts. + SetColumnMapping(IColMappingListContext) + + // SetPreFilter sets the preFilter rule contexts. + SetPreFilter(IPreFilterClauseContext) + + // SetWhere sets the where rule contexts. + SetWhere(IWhereClauseContext) + + // SetDeleteOn sets the deleteOn rule contexts. + SetDeleteOn(IDeleteOnClauseContext) + + // SetSequenceColumn sets the sequenceColumn rule contexts. + SetSequenceColumn(ISequenceColClauseContext) + + // SetSourceTableName sets the sourceTableName rule contexts. + SetSourceTableName(IIdentifierContext) + + // SetPartition sets the partition rule contexts. + SetPartition(IIdentifierListContext) + + // Getter signatures + DATA() antlr.TerminalNode + INFILE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + INTO() antlr.TerminalNode + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + MergeType() IMergeTypeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PartitionSpec() IPartitionSpecContext + COLUMNS() antlr.TerminalNode + AllTERMINATED() []antlr.TerminalNode + TERMINATED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + LINES() antlr.TerminalNode + FORMAT() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + COMPRESS_TYPE() antlr.TerminalNode + PropertyClause() IPropertyClauseContext + NEGATIVE() antlr.TerminalNode + AllIdentifierOrText() []IIdentifierOrTextContext + IdentifierOrText(i int) IIdentifierOrTextContext + IdentifierList() IIdentifierListContext + ColFromPath() IColFromPathContext + ColMappingList() IColMappingListContext + PreFilterClause() IPreFilterClauseContext + WhereClause() IWhereClauseContext + DeleteOnClause() IDeleteOnClauseContext + SequenceColClause() ISequenceColClauseContext + WITH() antlr.TerminalNode + FROM() antlr.TerminalNode + PARTITION() antlr.TerminalNode + + // IsDataDescContext differentiates from other interfaces. + IsDataDescContext() +} + +type DataDescContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _STRING_LITERAL antlr.Token + filePaths []antlr.Token + filePath []antlr.Token + negative antlr.Token + targetTableName IIdentifierContext + comma antlr.Token + separator antlr.Token + format IIdentifierOrTextContext + compressType IIdentifierOrTextContext + columns IIdentifierListContext + columnsFromPath IColFromPathContext + columnMapping IColMappingListContext + preFilter IPreFilterClauseContext + where IWhereClauseContext + deleteOn IDeleteOnClauseContext + sequenceColumn ISequenceColClauseContext + sourceTableName IIdentifierContext + partition IIdentifierListContext +} + +func NewEmptyDataDescContext() *DataDescContext { + var p = new(DataDescContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataDesc + return p +} + +func InitEmptyDataDescContext(p *DataDescContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataDesc +} + +func (*DataDescContext) IsDataDescContext() {} + +func NewDataDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataDescContext { + var p = new(DataDescContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dataDesc + + return p +} + +func (s *DataDescContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataDescContext) Get_STRING_LITERAL() antlr.Token { return s._STRING_LITERAL } + +func (s *DataDescContext) GetNegative() antlr.Token { return s.negative } + +func (s *DataDescContext) GetComma() antlr.Token { return s.comma } + +func (s *DataDescContext) GetSeparator() antlr.Token { return s.separator } + +func (s *DataDescContext) Set_STRING_LITERAL(v antlr.Token) { s._STRING_LITERAL = v } + +func (s *DataDescContext) SetNegative(v antlr.Token) { s.negative = v } + +func (s *DataDescContext) SetComma(v antlr.Token) { s.comma = v } + +func (s *DataDescContext) SetSeparator(v antlr.Token) { s.separator = v } + +func (s *DataDescContext) GetFilePaths() []antlr.Token { return s.filePaths } + +func (s *DataDescContext) GetFilePath() []antlr.Token { return s.filePath } + +func (s *DataDescContext) SetFilePaths(v []antlr.Token) { s.filePaths = v } + +func (s *DataDescContext) SetFilePath(v []antlr.Token) { s.filePath = v } + +func (s *DataDescContext) GetTargetTableName() IIdentifierContext { return s.targetTableName } + +func (s *DataDescContext) GetFormat() IIdentifierOrTextContext { return s.format } + +func (s *DataDescContext) GetCompressType() IIdentifierOrTextContext { return s.compressType } + +func (s *DataDescContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *DataDescContext) GetColumnsFromPath() IColFromPathContext { return s.columnsFromPath } + +func (s *DataDescContext) GetColumnMapping() IColMappingListContext { return s.columnMapping } + +func (s *DataDescContext) GetPreFilter() IPreFilterClauseContext { return s.preFilter } + +func (s *DataDescContext) GetWhere() IWhereClauseContext { return s.where } + +func (s *DataDescContext) GetDeleteOn() IDeleteOnClauseContext { return s.deleteOn } + +func (s *DataDescContext) GetSequenceColumn() ISequenceColClauseContext { return s.sequenceColumn } + +func (s *DataDescContext) GetSourceTableName() IIdentifierContext { return s.sourceTableName } + +func (s *DataDescContext) GetPartition() IIdentifierListContext { return s.partition } + +func (s *DataDescContext) SetTargetTableName(v IIdentifierContext) { s.targetTableName = v } + +func (s *DataDescContext) SetFormat(v IIdentifierOrTextContext) { s.format = v } + +func (s *DataDescContext) SetCompressType(v IIdentifierOrTextContext) { s.compressType = v } + +func (s *DataDescContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *DataDescContext) SetColumnsFromPath(v IColFromPathContext) { s.columnsFromPath = v } + +func (s *DataDescContext) SetColumnMapping(v IColMappingListContext) { s.columnMapping = v } + +func (s *DataDescContext) SetPreFilter(v IPreFilterClauseContext) { s.preFilter = v } + +func (s *DataDescContext) SetWhere(v IWhereClauseContext) { s.where = v } + +func (s *DataDescContext) SetDeleteOn(v IDeleteOnClauseContext) { s.deleteOn = v } + +func (s *DataDescContext) SetSequenceColumn(v ISequenceColClauseContext) { s.sequenceColumn = v } + +func (s *DataDescContext) SetSourceTableName(v IIdentifierContext) { s.sourceTableName = v } + +func (s *DataDescContext) SetPartition(v IIdentifierListContext) { s.partition = v } + +func (s *DataDescContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *DataDescContext) INFILE() antlr.TerminalNode { + return s.GetToken(DorisParserINFILE, 0) +} + +func (s *DataDescContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *DataDescContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *DataDescContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *DataDescContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(DorisParserTABLE) +} + +func (s *DataDescContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, i) +} + +func (s *DataDescContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *DataDescContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *DataDescContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *DataDescContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DataDescContext) MergeType() IMergeTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMergeTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMergeTypeContext) +} + +func (s *DataDescContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *DataDescContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *DataDescContext) PartitionSpec() IPartitionSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionSpecContext) +} + +func (s *DataDescContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *DataDescContext) AllTERMINATED() []antlr.TerminalNode { + return s.GetTokens(DorisParserTERMINATED) +} + +func (s *DataDescContext) TERMINATED(i int) antlr.TerminalNode { + return s.GetToken(DorisParserTERMINATED, i) +} + +func (s *DataDescContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(DorisParserBY) +} + +func (s *DataDescContext) BY(i int) antlr.TerminalNode { + return s.GetToken(DorisParserBY, i) +} + +func (s *DataDescContext) LINES() antlr.TerminalNode { + return s.GetToken(DorisParserLINES, 0) +} + +func (s *DataDescContext) FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserFORMAT, 0) +} + +func (s *DataDescContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(DorisParserAS) +} + +func (s *DataDescContext) AS(i int) antlr.TerminalNode { + return s.GetToken(DorisParserAS, i) +} + +func (s *DataDescContext) COMPRESS_TYPE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPRESS_TYPE, 0) +} + +func (s *DataDescContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *DataDescContext) NEGATIVE() antlr.TerminalNode { + return s.GetToken(DorisParserNEGATIVE, 0) +} + +func (s *DataDescContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *DataDescContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *DataDescContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *DataDescContext) ColFromPath() IColFromPathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColFromPathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColFromPathContext) +} + +func (s *DataDescContext) ColMappingList() IColMappingListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColMappingListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColMappingListContext) +} + +func (s *DataDescContext) PreFilterClause() IPreFilterClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreFilterClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreFilterClauseContext) +} + +func (s *DataDescContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *DataDescContext) DeleteOnClause() IDeleteOnClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeleteOnClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeleteOnClauseContext) +} + +func (s *DataDescContext) SequenceColClause() ISequenceColClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequenceColClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequenceColClauseContext) +} + +func (s *DataDescContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *DataDescContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *DataDescContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *DataDescContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataDescContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDataDesc(s) + } +} + +func (s *DataDescContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDataDesc(s) + } +} + +func (s *DataDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDataDesc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DataDesc() (localctx IDataDescContext) { + localctx = NewDataDescContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, DorisParserRULE_dataDesc) + var _la int + + p.SetState(4840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 684, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(4739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAPPEND || _la == DorisParserDELETE || _la == DorisParserMERGE || _la == DorisParserWITH { + p.SetState(4736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(4735) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4738) + p.MergeType() + } + + } + { + p.SetState(4741) + p.Match(DorisParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4742) + p.Match(DorisParserINFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4743) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4744) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DataDescContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DataDescContext).filePaths = append(localctx.(*DataDescContext).filePaths, localctx.(*DataDescContext)._STRING_LITERAL) + p.SetState(4749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(4745) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4746) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DataDescContext)._STRING_LITERAL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*DataDescContext).filePath = append(localctx.(*DataDescContext).filePath, localctx.(*DataDescContext)._STRING_LITERAL) + + p.SetState(4751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4752) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNEGATIVE { + { + p.SetState(4753) + + var _m = p.Match(DorisParserNEGATIVE) + + localctx.(*DataDescContext).negative = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4756) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4757) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4758) + + var _x = p.Identifier() + + localctx.(*DataDescContext).targetTableName = _x + } + p.SetState(4760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION || _la == DorisParserPARTITIONS || _la == DorisParserTEMPORARY { + { + p.SetState(4759) + p.PartitionSpec() + } + + } + p.SetState(4766) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) == 1 { + { + p.SetState(4762) + p.Match(DorisParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4763) + p.Match(DorisParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4764) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4765) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DataDescContext).comma = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLINES { + { + p.SetState(4768) + p.Match(DorisParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4769) + p.Match(DorisParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4770) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4771) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*DataDescContext).separator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORMAT { + { + p.SetState(4774) + p.Match(DorisParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4775) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4776) + + var _x = p.IdentifierOrText() + + localctx.(*DataDescContext).format = _x + } + + } + p.SetState(4782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMPRESS_TYPE { + { + p.SetState(4779) + p.Match(DorisParserCOMPRESS_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4780) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4781) + + var _x = p.IdentifierOrText() + + localctx.(*DataDescContext).compressType = _x + } + + } + p.SetState(4785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4784) + + var _x = p.IdentifierList() + + localctx.(*DataDescContext).columns = _x + } + + } + p.SetState(4788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOLUMNS { + { + p.SetState(4787) + + var _x = p.ColFromPath() + + localctx.(*DataDescContext).columnsFromPath = _x + } + + } + p.SetState(4791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSET { + { + p.SetState(4790) + + var _x = p.ColMappingList() + + localctx.(*DataDescContext).columnMapping = _x + } + + } + p.SetState(4794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPRECEDING { + { + p.SetState(4793) + + var _x = p.PreFilterClause() + + localctx.(*DataDescContext).preFilter = _x + } + + } + p.SetState(4797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(4796) + + var _x = p.WhereClause() + + localctx.(*DataDescContext).where = _x + } + + } + p.SetState(4800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDELETE { + { + p.SetState(4799) + + var _x = p.DeleteOnClause() + + localctx.(*DataDescContext).deleteOn = _x + } + + } + p.SetState(4803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(4802) + + var _x = p.SequenceColClause() + + localctx.(*DataDescContext).sequenceColumn = _x + } + + } + p.SetState(4806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4805) + p.PropertyClause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(4812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAPPEND || _la == DorisParserDELETE || _la == DorisParserMERGE || _la == DorisParserWITH { + p.SetState(4809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(4808) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4811) + p.MergeType() + } + + } + { + p.SetState(4814) + p.Match(DorisParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4815) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4816) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4817) + + var _x = p.Identifier() + + localctx.(*DataDescContext).sourceTableName = _x + } + p.SetState(4819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNEGATIVE { + { + p.SetState(4818) + + var _m = p.Match(DorisParserNEGATIVE) + + localctx.(*DataDescContext).negative = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4821) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4822) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4823) + + var _x = p.Identifier() + + localctx.(*DataDescContext).targetTableName = _x + } + p.SetState(4826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION { + { + p.SetState(4824) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4825) + + var _x = p.IdentifierList() + + localctx.(*DataDescContext).partition = _x + } + + } + p.SetState(4829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSET { + { + p.SetState(4828) + + var _x = p.ColMappingList() + + localctx.(*DataDescContext).columnMapping = _x + } + + } + p.SetState(4832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWHERE { + { + p.SetState(4831) + + var _x = p.WhereClause() + + localctx.(*DataDescContext).where = _x + } + + } + p.SetState(4835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDELETE { + { + p.SetState(4834) + + var _x = p.DeleteOnClause() + + localctx.(*DataDescContext).deleteOn = _x + } + + } + p.SetState(4838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(4837) + p.PropertyClause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatementScopeContext is an interface to support dynamic dispatch. +type IStatementScopeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GLOBAL() antlr.TerminalNode + SESSION() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsStatementScopeContext differentiates from other interfaces. + IsStatementScopeContext() +} + +type StatementScopeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementScopeContext() *StatementScopeContext { + var p = new(StatementScopeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_statementScope + return p +} + +func InitEmptyStatementScopeContext(p *StatementScopeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_statementScope +} + +func (*StatementScopeContext) IsStatementScopeContext() {} + +func NewStatementScopeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementScopeContext { + var p = new(StatementScopeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_statementScope + + return p +} + +func (s *StatementScopeContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementScopeContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(DorisParserGLOBAL, 0) +} + +func (s *StatementScopeContext) SESSION() antlr.TerminalNode { + return s.GetToken(DorisParserSESSION, 0) +} + +func (s *StatementScopeContext) LOCAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOCAL, 0) +} + +func (s *StatementScopeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementScopeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StatementScopeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStatementScope(s) + } +} + +func (s *StatementScopeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStatementScope(s) + } +} + +func (s *StatementScopeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStatementScope(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) StatementScope() (localctx IStatementScopeContext) { + localctx = NewStatementScopeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, DorisParserRULE_statementScope) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4842) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserGLOBAL || _la == DorisParserLOCAL || _la == DorisParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBuildModeContext is an interface to support dynamic dispatch. +type IBuildModeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BUILD() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + + // IsBuildModeContext differentiates from other interfaces. + IsBuildModeContext() +} + +type BuildModeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBuildModeContext() *BuildModeContext { + var p = new(BuildModeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_buildMode + return p +} + +func InitEmptyBuildModeContext(p *BuildModeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_buildMode +} + +func (*BuildModeContext) IsBuildModeContext() {} + +func NewBuildModeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BuildModeContext { + var p = new(BuildModeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_buildMode + + return p +} + +func (s *BuildModeContext) GetParser() antlr.Parser { return s.parser } + +func (s *BuildModeContext) BUILD() antlr.TerminalNode { + return s.GetToken(DorisParserBUILD, 0) +} + +func (s *BuildModeContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(DorisParserIMMEDIATE, 0) +} + +func (s *BuildModeContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(DorisParserDEFERRED, 0) +} + +func (s *BuildModeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BuildModeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BuildModeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBuildMode(s) + } +} + +func (s *BuildModeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBuildMode(s) + } +} + +func (s *BuildModeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBuildMode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) BuildMode() (localctx IBuildModeContext) { + localctx = NewBuildModeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, DorisParserRULE_buildMode) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4844) + p.Match(DorisParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4845) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDEFERRED || _la == DorisParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRefreshTriggerContext is an interface to support dynamic dispatch. +type IRefreshTriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + MANUAL() antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + RefreshSchedule() IRefreshScheduleContext + COMMIT() antlr.TerminalNode + + // IsRefreshTriggerContext differentiates from other interfaces. + IsRefreshTriggerContext() +} + +type RefreshTriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRefreshTriggerContext() *RefreshTriggerContext { + var p = new(RefreshTriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_refreshTrigger + return p +} + +func InitEmptyRefreshTriggerContext(p *RefreshTriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_refreshTrigger +} + +func (*RefreshTriggerContext) IsRefreshTriggerContext() {} + +func NewRefreshTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RefreshTriggerContext { + var p = new(RefreshTriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_refreshTrigger + + return p +} + +func (s *RefreshTriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *RefreshTriggerContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *RefreshTriggerContext) MANUAL() antlr.TerminalNode { + return s.GetToken(DorisParserMANUAL, 0) +} + +func (s *RefreshTriggerContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEDULE, 0) +} + +func (s *RefreshTriggerContext) RefreshSchedule() IRefreshScheduleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshScheduleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshScheduleContext) +} + +func (s *RefreshTriggerContext) COMMIT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMIT, 0) +} + +func (s *RefreshTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RefreshTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshTrigger(s) + } +} + +func (s *RefreshTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshTrigger(s) + } +} + +func (s *RefreshTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshTrigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RefreshTrigger() (localctx IRefreshTriggerContext) { + localctx = NewRefreshTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, DorisParserRULE_refreshTrigger) + p.SetState(4854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 685, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4847) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4848) + p.Match(DorisParserMANUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4849) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4850) + p.Match(DorisParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4851) + p.RefreshSchedule() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4852) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4853) + p.Match(DorisParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRefreshScheduleContext is an interface to support dynamic dispatch. +type IRefreshScheduleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRefreshUnit returns the refreshUnit rule contexts. + GetRefreshUnit() IIdentifierContext + + // SetRefreshUnit sets the refreshUnit rule contexts. + SetRefreshUnit(IIdentifierContext) + + // Getter signatures + EVERY() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + Identifier() IIdentifierContext + STARTS() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsRefreshScheduleContext differentiates from other interfaces. + IsRefreshScheduleContext() +} + +type RefreshScheduleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + refreshUnit IIdentifierContext +} + +func NewEmptyRefreshScheduleContext() *RefreshScheduleContext { + var p = new(RefreshScheduleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_refreshSchedule + return p +} + +func InitEmptyRefreshScheduleContext(p *RefreshScheduleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_refreshSchedule +} + +func (*RefreshScheduleContext) IsRefreshScheduleContext() {} + +func NewRefreshScheduleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RefreshScheduleContext { + var p = new(RefreshScheduleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_refreshSchedule + + return p +} + +func (s *RefreshScheduleContext) GetParser() antlr.Parser { return s.parser } + +func (s *RefreshScheduleContext) GetRefreshUnit() IIdentifierContext { return s.refreshUnit } + +func (s *RefreshScheduleContext) SetRefreshUnit(v IIdentifierContext) { s.refreshUnit = v } + +func (s *RefreshScheduleContext) EVERY() antlr.TerminalNode { + return s.GetToken(DorisParserEVERY, 0) +} + +func (s *RefreshScheduleContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *RefreshScheduleContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RefreshScheduleContext) STARTS() antlr.TerminalNode { + return s.GetToken(DorisParserSTARTS, 0) +} + +func (s *RefreshScheduleContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *RefreshScheduleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshScheduleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RefreshScheduleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshSchedule(s) + } +} + +func (s *RefreshScheduleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshSchedule(s) + } +} + +func (s *RefreshScheduleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshSchedule(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RefreshSchedule() (localctx IRefreshScheduleContext) { + localctx = NewRefreshScheduleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, DorisParserRULE_refreshSchedule) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4856) + p.Match(DorisParserEVERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4857) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4858) + + var _x = p.Identifier() + + localctx.(*RefreshScheduleContext).refreshUnit = _x + } + p.SetState(4861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSTARTS { + { + p.SetState(4859) + p.Match(DorisParserSTARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4860) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRefreshMethodContext is an interface to support dynamic dispatch. +type IRefreshMethodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPLETE() antlr.TerminalNode + AUTO() antlr.TerminalNode + + // IsRefreshMethodContext differentiates from other interfaces. + IsRefreshMethodContext() +} + +type RefreshMethodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRefreshMethodContext() *RefreshMethodContext { + var p = new(RefreshMethodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_refreshMethod + return p +} + +func InitEmptyRefreshMethodContext(p *RefreshMethodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_refreshMethod +} + +func (*RefreshMethodContext) IsRefreshMethodContext() {} + +func NewRefreshMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RefreshMethodContext { + var p = new(RefreshMethodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_refreshMethod + + return p +} + +func (s *RefreshMethodContext) GetParser() antlr.Parser { return s.parser } + +func (s *RefreshMethodContext) COMPLETE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPLETE, 0) +} + +func (s *RefreshMethodContext) AUTO() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO, 0) +} + +func (s *RefreshMethodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshMethodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RefreshMethodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRefreshMethod(s) + } +} + +func (s *RefreshMethodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRefreshMethod(s) + } +} + +func (s *RefreshMethodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRefreshMethod(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RefreshMethod() (localctx IRefreshMethodContext) { + localctx = NewRefreshMethodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, DorisParserRULE_refreshMethod) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4863) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAUTO || _la == DorisParserCOMPLETE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMvPartitionContext is an interface to support dynamic dispatch. +type IMvPartitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartitionKey returns the partitionKey rule contexts. + GetPartitionKey() IIdentifierContext + + // GetPartitionExpr returns the partitionExpr rule contexts. + GetPartitionExpr() IFunctionCallExpressionContext + + // SetPartitionKey sets the partitionKey rule contexts. + SetPartitionKey(IIdentifierContext) + + // SetPartitionExpr sets the partitionExpr rule contexts. + SetPartitionExpr(IFunctionCallExpressionContext) + + // Getter signatures + Identifier() IIdentifierContext + FunctionCallExpression() IFunctionCallExpressionContext + + // IsMvPartitionContext differentiates from other interfaces. + IsMvPartitionContext() +} + +type MvPartitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitionKey IIdentifierContext + partitionExpr IFunctionCallExpressionContext +} + +func NewEmptyMvPartitionContext() *MvPartitionContext { + var p = new(MvPartitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mvPartition + return p +} + +func InitEmptyMvPartitionContext(p *MvPartitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mvPartition +} + +func (*MvPartitionContext) IsMvPartitionContext() {} + +func NewMvPartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MvPartitionContext { + var p = new(MvPartitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_mvPartition + + return p +} + +func (s *MvPartitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *MvPartitionContext) GetPartitionKey() IIdentifierContext { return s.partitionKey } + +func (s *MvPartitionContext) GetPartitionExpr() IFunctionCallExpressionContext { + return s.partitionExpr +} + +func (s *MvPartitionContext) SetPartitionKey(v IIdentifierContext) { s.partitionKey = v } + +func (s *MvPartitionContext) SetPartitionExpr(v IFunctionCallExpressionContext) { s.partitionExpr = v } + +func (s *MvPartitionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *MvPartitionContext) FunctionCallExpression() IFunctionCallExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallExpressionContext) +} + +func (s *MvPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MvPartitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MvPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMvPartition(s) + } +} + +func (s *MvPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMvPartition(s) + } +} + +func (s *MvPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMvPartition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MvPartition() (localctx IMvPartitionContext) { + localctx = NewMvPartitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, DorisParserRULE_mvPartition) + p.SetState(4867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 687, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4865) + + var _x = p.Identifier() + + localctx.(*MvPartitionContext).partitionKey = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4866) + + var _x = p.FunctionCallExpression() + + localctx.(*MvPartitionContext).partitionExpr = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierOrTextContext is an interface to support dynamic dispatch. +type IIdentifierOrTextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + STRING_LITERAL() antlr.TerminalNode + + // IsIdentifierOrTextContext differentiates from other interfaces. + IsIdentifierOrTextContext() +} + +type IdentifierOrTextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierOrTextContext() *IdentifierOrTextContext { + var p = new(IdentifierOrTextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierOrText + return p +} + +func InitEmptyIdentifierOrTextContext(p *IdentifierOrTextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierOrText +} + +func (*IdentifierOrTextContext) IsIdentifierOrTextContext() {} + +func NewIdentifierOrTextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierOrTextContext { + var p = new(IdentifierOrTextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identifierOrText + + return p +} + +func (s *IdentifierOrTextContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierOrTextContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *IdentifierOrTextContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *IdentifierOrTextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierOrTextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierOrTextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentifierOrText(s) + } +} + +func (s *IdentifierOrTextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentifierOrText(s) + } +} + +func (s *IdentifierOrTextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentifierOrText(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentifierOrText() (localctx IIdentifierOrTextContext) { + localctx = NewIdentifierOrTextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, DorisParserRULE_identifierOrText) + p.SetState(4871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4869) + p.Identifier() + } + + case DorisParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4870) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierOrTextOrAsteriskContext is an interface to support dynamic dispatch. +type IIdentifierOrTextOrAsteriskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + STRING_LITERAL() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + + // IsIdentifierOrTextOrAsteriskContext differentiates from other interfaces. + IsIdentifierOrTextOrAsteriskContext() +} + +type IdentifierOrTextOrAsteriskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierOrTextOrAsteriskContext() *IdentifierOrTextOrAsteriskContext { + var p = new(IdentifierOrTextOrAsteriskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierOrTextOrAsterisk + return p +} + +func InitEmptyIdentifierOrTextOrAsteriskContext(p *IdentifierOrTextOrAsteriskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierOrTextOrAsterisk +} + +func (*IdentifierOrTextOrAsteriskContext) IsIdentifierOrTextOrAsteriskContext() {} + +func NewIdentifierOrTextOrAsteriskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierOrTextOrAsteriskContext { + var p = new(IdentifierOrTextOrAsteriskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identifierOrTextOrAsterisk + + return p +} + +func (s *IdentifierOrTextOrAsteriskContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierOrTextOrAsteriskContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *IdentifierOrTextOrAsteriskContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *IdentifierOrTextOrAsteriskContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *IdentifierOrTextOrAsteriskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierOrTextOrAsteriskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierOrTextOrAsteriskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentifierOrTextOrAsterisk(s) + } +} + +func (s *IdentifierOrTextOrAsteriskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentifierOrTextOrAsterisk(s) + } +} + +func (s *IdentifierOrTextOrAsteriskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentifierOrTextOrAsterisk(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentifierOrTextOrAsterisk() (localctx IIdentifierOrTextOrAsteriskContext) { + localctx = NewIdentifierOrTextOrAsteriskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, DorisParserRULE_identifierOrTextOrAsterisk) + p.SetState(4876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4873) + p.Identifier() + } + + case DorisParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4874) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserASTERISK: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4875) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultipartIdentifierOrAsteriskContext is an interface to support dynamic dispatch. +type IMultipartIdentifierOrAsteriskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_identifierOrAsterisk returns the _identifierOrAsterisk rule contexts. + Get_identifierOrAsterisk() IIdentifierOrAsteriskContext + + // Set_identifierOrAsterisk sets the _identifierOrAsterisk rule contexts. + Set_identifierOrAsterisk(IIdentifierOrAsteriskContext) + + // GetParts returns the parts rule context list. + GetParts() []IIdentifierOrAsteriskContext + + // SetParts sets the parts rule context list. + SetParts([]IIdentifierOrAsteriskContext) + + // Getter signatures + AllIdentifierOrAsterisk() []IIdentifierOrAsteriskContext + IdentifierOrAsterisk(i int) IIdentifierOrAsteriskContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsMultipartIdentifierOrAsteriskContext differentiates from other interfaces. + IsMultipartIdentifierOrAsteriskContext() +} + +type MultipartIdentifierOrAsteriskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _identifierOrAsterisk IIdentifierOrAsteriskContext + parts []IIdentifierOrAsteriskContext +} + +func NewEmptyMultipartIdentifierOrAsteriskContext() *MultipartIdentifierOrAsteriskContext { + var p = new(MultipartIdentifierOrAsteriskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_multipartIdentifierOrAsterisk + return p +} + +func InitEmptyMultipartIdentifierOrAsteriskContext(p *MultipartIdentifierOrAsteriskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_multipartIdentifierOrAsterisk +} + +func (*MultipartIdentifierOrAsteriskContext) IsMultipartIdentifierOrAsteriskContext() {} + +func NewMultipartIdentifierOrAsteriskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultipartIdentifierOrAsteriskContext { + var p = new(MultipartIdentifierOrAsteriskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_multipartIdentifierOrAsterisk + + return p +} + +func (s *MultipartIdentifierOrAsteriskContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultipartIdentifierOrAsteriskContext) Get_identifierOrAsterisk() IIdentifierOrAsteriskContext { + return s._identifierOrAsterisk +} + +func (s *MultipartIdentifierOrAsteriskContext) Set_identifierOrAsterisk(v IIdentifierOrAsteriskContext) { + s._identifierOrAsterisk = v +} + +func (s *MultipartIdentifierOrAsteriskContext) GetParts() []IIdentifierOrAsteriskContext { + return s.parts +} + +func (s *MultipartIdentifierOrAsteriskContext) SetParts(v []IIdentifierOrAsteriskContext) { + s.parts = v +} + +func (s *MultipartIdentifierOrAsteriskContext) AllIdentifierOrAsterisk() []IIdentifierOrAsteriskContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrAsteriskContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrAsteriskContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrAsteriskContext); ok { + tst[i] = t.(IIdentifierOrAsteriskContext) + i++ + } + } + + return tst +} + +func (s *MultipartIdentifierOrAsteriskContext) IdentifierOrAsterisk(i int) IIdentifierOrAsteriskContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrAsteriskContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrAsteriskContext) +} + +func (s *MultipartIdentifierOrAsteriskContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(DorisParserDOT) +} + +func (s *MultipartIdentifierOrAsteriskContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(DorisParserDOT, i) +} + +func (s *MultipartIdentifierOrAsteriskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultipartIdentifierOrAsteriskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultipartIdentifierOrAsteriskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMultipartIdentifierOrAsterisk(s) + } +} + +func (s *MultipartIdentifierOrAsteriskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMultipartIdentifierOrAsterisk(s) + } +} + +func (s *MultipartIdentifierOrAsteriskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMultipartIdentifierOrAsterisk(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MultipartIdentifierOrAsterisk() (localctx IMultipartIdentifierOrAsteriskContext) { + localctx = NewMultipartIdentifierOrAsteriskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, DorisParserRULE_multipartIdentifierOrAsterisk) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4878) + + var _x = p.IdentifierOrAsterisk() + + localctx.(*MultipartIdentifierOrAsteriskContext)._identifierOrAsterisk = _x + } + localctx.(*MultipartIdentifierOrAsteriskContext).parts = append(localctx.(*MultipartIdentifierOrAsteriskContext).parts, localctx.(*MultipartIdentifierOrAsteriskContext)._identifierOrAsterisk) + p.SetState(4883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserDOT { + { + p.SetState(4879) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4880) + + var _x = p.IdentifierOrAsterisk() + + localctx.(*MultipartIdentifierOrAsteriskContext)._identifierOrAsterisk = _x + } + localctx.(*MultipartIdentifierOrAsteriskContext).parts = append(localctx.(*MultipartIdentifierOrAsteriskContext).parts, localctx.(*MultipartIdentifierOrAsteriskContext)._identifierOrAsterisk) + + p.SetState(4885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierOrAsteriskContext is an interface to support dynamic dispatch. +type IIdentifierOrAsteriskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IdentifierOrText() IIdentifierOrTextContext + ASTERISK() antlr.TerminalNode + + // IsIdentifierOrAsteriskContext differentiates from other interfaces. + IsIdentifierOrAsteriskContext() +} + +type IdentifierOrAsteriskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierOrAsteriskContext() *IdentifierOrAsteriskContext { + var p = new(IdentifierOrAsteriskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierOrAsterisk + return p +} + +func InitEmptyIdentifierOrAsteriskContext(p *IdentifierOrAsteriskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierOrAsterisk +} + +func (*IdentifierOrAsteriskContext) IsIdentifierOrAsteriskContext() {} + +func NewIdentifierOrAsteriskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierOrAsteriskContext { + var p = new(IdentifierOrAsteriskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identifierOrAsterisk + + return p +} + +func (s *IdentifierOrAsteriskContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierOrAsteriskContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *IdentifierOrAsteriskContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *IdentifierOrAsteriskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierOrAsteriskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierOrAsteriskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentifierOrAsterisk(s) + } +} + +func (s *IdentifierOrAsteriskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentifierOrAsterisk(s) + } +} + +func (s *IdentifierOrAsteriskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentifierOrAsterisk(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentifierOrAsterisk() (localctx IIdentifierOrAsteriskContext) { + localctx = NewIdentifierOrAsteriskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, DorisParserRULE_identifierOrAsterisk) + p.SetState(4888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4886) + p.IdentifierOrText() + } + + case DorisParserASTERISK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4887) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserIdentifyContext is an interface to support dynamic dispatch. +type IUserIdentifyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUser returns the user rule contexts. + GetUser() IIdentifierOrTextContext + + // GetHost returns the host rule contexts. + GetHost() IIdentifierOrTextContext + + // SetUser sets the user rule contexts. + SetUser(IIdentifierOrTextContext) + + // SetHost sets the host rule contexts. + SetHost(IIdentifierOrTextContext) + + // Getter signatures + AllIdentifierOrText() []IIdentifierOrTextContext + IdentifierOrText(i int) IIdentifierOrTextContext + ATSIGN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsUserIdentifyContext differentiates from other interfaces. + IsUserIdentifyContext() +} + +type UserIdentifyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + user IIdentifierOrTextContext + host IIdentifierOrTextContext +} + +func NewEmptyUserIdentifyContext() *UserIdentifyContext { + var p = new(UserIdentifyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_userIdentify + return p +} + +func InitEmptyUserIdentifyContext(p *UserIdentifyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_userIdentify +} + +func (*UserIdentifyContext) IsUserIdentifyContext() {} + +func NewUserIdentifyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserIdentifyContext { + var p = new(UserIdentifyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_userIdentify + + return p +} + +func (s *UserIdentifyContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserIdentifyContext) GetUser() IIdentifierOrTextContext { return s.user } + +func (s *UserIdentifyContext) GetHost() IIdentifierOrTextContext { return s.host } + +func (s *UserIdentifyContext) SetUser(v IIdentifierOrTextContext) { s.user = v } + +func (s *UserIdentifyContext) SetHost(v IIdentifierOrTextContext) { s.host = v } + +func (s *UserIdentifyContext) AllIdentifierOrText() []IIdentifierOrTextContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + len++ + } + } + + tst := make([]IIdentifierOrTextContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierOrTextContext); ok { + tst[i] = t.(IIdentifierOrTextContext) + i++ + } + } + + return tst +} + +func (s *UserIdentifyContext) IdentifierOrText(i int) IIdentifierOrTextContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *UserIdentifyContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *UserIdentifyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *UserIdentifyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *UserIdentifyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserIdentifyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserIdentifyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUserIdentify(s) + } +} + +func (s *UserIdentifyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUserIdentify(s) + } +} + +func (s *UserIdentifyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUserIdentify(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) UserIdentify() (localctx IUserIdentifyContext) { + localctx = NewUserIdentifyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, DorisParserRULE_userIdentify) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4890) + + var _x = p.IdentifierOrText() + + localctx.(*UserIdentifyContext).user = _x + } + p.SetState(4899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserATSIGN { + { + p.SetState(4891) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserSTRING_LITERAL, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(4892) + + var _x = p.IdentifierOrText() + + localctx.(*UserIdentifyContext).host = _x + } + + case DorisParserLEFT_PAREN: + { + p.SetState(4893) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4894) + + var _x = p.IdentifierOrText() + + localctx.(*UserIdentifyContext).host = _x + } + { + p.SetState(4895) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantUserIdentifyContext is an interface to support dynamic dispatch. +type IGrantUserIdentifyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UserIdentify() IUserIdentifyContext + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + + // IsGrantUserIdentifyContext differentiates from other interfaces. + IsGrantUserIdentifyContext() +} + +type GrantUserIdentifyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantUserIdentifyContext() *GrantUserIdentifyContext { + var p = new(GrantUserIdentifyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_grantUserIdentify + return p +} + +func InitEmptyGrantUserIdentifyContext(p *GrantUserIdentifyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_grantUserIdentify +} + +func (*GrantUserIdentifyContext) IsGrantUserIdentifyContext() {} + +func NewGrantUserIdentifyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantUserIdentifyContext { + var p = new(GrantUserIdentifyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_grantUserIdentify + + return p +} + +func (s *GrantUserIdentifyContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantUserIdentifyContext) UserIdentify() IUserIdentifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserIdentifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserIdentifyContext) +} + +func (s *GrantUserIdentifyContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(DorisParserIDENTIFIED, 0) +} + +func (s *GrantUserIdentifyContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *GrantUserIdentifyContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *GrantUserIdentifyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD, 0) +} + +func (s *GrantUserIdentifyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantUserIdentifyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantUserIdentifyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGrantUserIdentify(s) + } +} + +func (s *GrantUserIdentifyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGrantUserIdentify(s) + } +} + +func (s *GrantUserIdentifyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGrantUserIdentify(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) GrantUserIdentify() (localctx IGrantUserIdentifyContext) { + localctx = NewGrantUserIdentifyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, DorisParserRULE_grantUserIdentify) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4901) + p.UserIdentify() + } + p.SetState(4908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIDENTIFIED { + { + p.SetState(4902) + p.Match(DorisParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4903) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPASSWORD { + { + p.SetState(4904) + p.Match(DorisParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4907) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplainContext is an interface to support dynamic dispatch. +type IExplainContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLevel returns the level token. + GetLevel() antlr.Token + + // SetLevel sets the level token. + SetLevel(antlr.Token) + + // Getter signatures + ExplainCommand() IExplainCommandContext + PlanType() IPlanTypeContext + PROCESS() antlr.TerminalNode + VERBOSE() antlr.TerminalNode + TREE() antlr.TerminalNode + GRAPH() antlr.TerminalNode + PLAN() antlr.TerminalNode + DUMP() antlr.TerminalNode + + // IsExplainContext differentiates from other interfaces. + IsExplainContext() +} + +type ExplainContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + level antlr.Token +} + +func NewEmptyExplainContext() *ExplainContext { + var p = new(ExplainContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_explain + return p +} + +func InitEmptyExplainContext(p *ExplainContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_explain +} + +func (*ExplainContext) IsExplainContext() {} + +func NewExplainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainContext { + var p = new(ExplainContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_explain + + return p +} + +func (s *ExplainContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExplainContext) GetLevel() antlr.Token { return s.level } + +func (s *ExplainContext) SetLevel(v antlr.Token) { s.level = v } + +func (s *ExplainContext) ExplainCommand() IExplainCommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainCommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainCommandContext) +} + +func (s *ExplainContext) PlanType() IPlanTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlanTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlanTypeContext) +} + +func (s *ExplainContext) PROCESS() antlr.TerminalNode { + return s.GetToken(DorisParserPROCESS, 0) +} + +func (s *ExplainContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(DorisParserVERBOSE, 0) +} + +func (s *ExplainContext) TREE() antlr.TerminalNode { + return s.GetToken(DorisParserTREE, 0) +} + +func (s *ExplainContext) GRAPH() antlr.TerminalNode { + return s.GetToken(DorisParserGRAPH, 0) +} + +func (s *ExplainContext) PLAN() antlr.TerminalNode { + return s.GetToken(DorisParserPLAN, 0) +} + +func (s *ExplainContext) DUMP() antlr.TerminalNode { + return s.GetToken(DorisParserDUMP, 0) +} + +func (s *ExplainContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExplainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExplainContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExplain(s) + } +} + +func (s *ExplainContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExplain(s) + } +} + +func (s *ExplainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExplain(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Explain() (localctx IExplainContext) { + localctx = NewExplainContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, DorisParserRULE_explain) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4910) + p.ExplainCommand() + } + p.SetState(4912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL || _la == DorisParserANALYZED || _la == DorisParserDISTRIBUTED || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&1157425104234348545) != 0) || _la == DorisParserPHYSICAL || _la == DorisParserREWRITTEN || _la == DorisParserSHAPE { + { + p.SetState(4911) + p.PlanType() + } + + } + p.SetState(4915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDUMP || _la == DorisParserGRAPH || _la == DorisParserPLAN || _la == DorisParserTREE || _la == DorisParserVERBOSE { + { + p.SetState(4914) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExplainContext).level = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDUMP || _la == DorisParserGRAPH || _la == DorisParserPLAN || _la == DorisParserTREE || _la == DorisParserVERBOSE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExplainContext).level = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROCESS { + { + p.SetState(4917) + p.Match(DorisParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplainCommandContext is an interface to support dynamic dispatch. +type IExplainCommandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPLAIN() antlr.TerminalNode + DESC() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + + // IsExplainCommandContext differentiates from other interfaces. + IsExplainCommandContext() +} + +type ExplainCommandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplainCommandContext() *ExplainCommandContext { + var p = new(ExplainCommandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_explainCommand + return p +} + +func InitEmptyExplainCommandContext(p *ExplainCommandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_explainCommand +} + +func (*ExplainCommandContext) IsExplainCommandContext() {} + +func NewExplainCommandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainCommandContext { + var p = new(ExplainCommandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_explainCommand + + return p +} + +func (s *ExplainCommandContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExplainCommandContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(DorisParserEXPLAIN, 0) +} + +func (s *ExplainCommandContext) DESC() antlr.TerminalNode { + return s.GetToken(DorisParserDESC, 0) +} + +func (s *ExplainCommandContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(DorisParserDESCRIBE, 0) +} + +func (s *ExplainCommandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExplainCommandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExplainCommandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExplainCommand(s) + } +} + +func (s *ExplainCommandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExplainCommand(s) + } +} + +func (s *ExplainCommandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExplainCommand(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ExplainCommand() (localctx IExplainCommandContext) { + localctx = NewExplainCommandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, DorisParserRULE_explainCommand) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4920) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-135)) & ^0x3f) == 0 && ((int64(1)<<(_la-135))&4398046511107) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlanTypeContext is an interface to support dynamic dispatch. +type IPlanTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARSED() antlr.TerminalNode + ANALYZED() antlr.TerminalNode + REWRITTEN() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + OPTIMIZED() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + SHAPE() antlr.TerminalNode + MEMO() antlr.TerminalNode + DISTRIBUTED() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsPlanTypeContext differentiates from other interfaces. + IsPlanTypeContext() +} + +type PlanTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlanTypeContext() *PlanTypeContext { + var p = new(PlanTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_planType + return p +} + +func InitEmptyPlanTypeContext(p *PlanTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_planType +} + +func (*PlanTypeContext) IsPlanTypeContext() {} + +func NewPlanTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlanTypeContext { + var p = new(PlanTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_planType + + return p +} + +func (s *PlanTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PlanTypeContext) PARSED() antlr.TerminalNode { + return s.GetToken(DorisParserPARSED, 0) +} + +func (s *PlanTypeContext) ANALYZED() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZED, 0) +} + +func (s *PlanTypeContext) REWRITTEN() antlr.TerminalNode { + return s.GetToken(DorisParserREWRITTEN, 0) +} + +func (s *PlanTypeContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOGICAL, 0) +} + +func (s *PlanTypeContext) OPTIMIZED() antlr.TerminalNode { + return s.GetToken(DorisParserOPTIMIZED, 0) +} + +func (s *PlanTypeContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(DorisParserPHYSICAL, 0) +} + +func (s *PlanTypeContext) SHAPE() antlr.TerminalNode { + return s.GetToken(DorisParserSHAPE, 0) +} + +func (s *PlanTypeContext) MEMO() antlr.TerminalNode { + return s.GetToken(DorisParserMEMO, 0) +} + +func (s *PlanTypeContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(DorisParserDISTRIBUTED, 0) +} + +func (s *PlanTypeContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *PlanTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlanTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PlanTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPlanType(s) + } +} + +func (s *PlanTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPlanType(s) + } +} + +func (s *PlanTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPlanType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PlanType() (localctx IPlanTypeContext) { + localctx = NewPlanTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, DorisParserRULE_planType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4922) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserALL || _la == DorisParserANALYZED || _la == DorisParserDISTRIBUTED || ((int64((_la-284)) & ^0x3f) == 0 && ((int64(1)<<(_la-284))&1157425104234348545) != 0) || _la == DorisParserPHYSICAL || _la == DorisParserREWRITTEN || _la == DorisParserSHAPE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplayCommandContext is an interface to support dynamic dispatch. +type IReplayCommandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLAN() antlr.TerminalNode + REPLAYER() antlr.TerminalNode + ReplayType() IReplayTypeContext + + // IsReplayCommandContext differentiates from other interfaces. + IsReplayCommandContext() +} + +type ReplayCommandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplayCommandContext() *ReplayCommandContext { + var p = new(ReplayCommandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_replayCommand + return p +} + +func InitEmptyReplayCommandContext(p *ReplayCommandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_replayCommand +} + +func (*ReplayCommandContext) IsReplayCommandContext() {} + +func NewReplayCommandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplayCommandContext { + var p = new(ReplayCommandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_replayCommand + + return p +} + +func (s *ReplayCommandContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplayCommandContext) PLAN() antlr.TerminalNode { + return s.GetToken(DorisParserPLAN, 0) +} + +func (s *ReplayCommandContext) REPLAYER() antlr.TerminalNode { + return s.GetToken(DorisParserREPLAYER, 0) +} + +func (s *ReplayCommandContext) ReplayType() IReplayTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplayTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplayTypeContext) +} + +func (s *ReplayCommandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplayCommandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReplayCommandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplayCommand(s) + } +} + +func (s *ReplayCommandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplayCommand(s) + } +} + +func (s *ReplayCommandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplayCommand(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ReplayCommand() (localctx IReplayCommandContext) { + localctx = NewReplayCommandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, DorisParserRULE_replayCommand) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4924) + p.Match(DorisParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4925) + p.Match(DorisParserREPLAYER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4926) + p.ReplayType() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplayTypeContext is an interface to support dynamic dispatch. +type IReplayTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilePath returns the filePath token. + GetFilePath() antlr.Token + + // SetFilePath sets the filePath token. + SetFilePath(antlr.Token) + + // Getter signatures + DUMP() antlr.TerminalNode + Query() IQueryContext + PLAY() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsReplayTypeContext differentiates from other interfaces. + IsReplayTypeContext() +} + +type ReplayTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + filePath antlr.Token +} + +func NewEmptyReplayTypeContext() *ReplayTypeContext { + var p = new(ReplayTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_replayType + return p +} + +func InitEmptyReplayTypeContext(p *ReplayTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_replayType +} + +func (*ReplayTypeContext) IsReplayTypeContext() {} + +func NewReplayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplayTypeContext { + var p = new(ReplayTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_replayType + + return p +} + +func (s *ReplayTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplayTypeContext) GetFilePath() antlr.Token { return s.filePath } + +func (s *ReplayTypeContext) SetFilePath(v antlr.Token) { s.filePath = v } + +func (s *ReplayTypeContext) DUMP() antlr.TerminalNode { + return s.GetToken(DorisParserDUMP, 0) +} + +func (s *ReplayTypeContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *ReplayTypeContext) PLAY() antlr.TerminalNode { + return s.GetToken(DorisParserPLAY, 0) +} + +func (s *ReplayTypeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *ReplayTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReplayTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplayType(s) + } +} + +func (s *ReplayTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplayType(s) + } +} + +func (s *ReplayTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplayType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ReplayType() (localctx IReplayTypeContext) { + localctx = NewReplayTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, DorisParserRULE_replayType) + p.SetState(4932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserDUMP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4928) + p.Match(DorisParserDUMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4929) + p.Query() + } + + case DorisParserPLAY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4930) + p.Match(DorisParserPLAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4931) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ReplayTypeContext).filePath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMergeTypeContext is an interface to support dynamic dispatch. +type IMergeTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + APPEND() antlr.TerminalNode + DELETE() antlr.TerminalNode + MERGE() antlr.TerminalNode + + // IsMergeTypeContext differentiates from other interfaces. + IsMergeTypeContext() +} + +type MergeTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMergeTypeContext() *MergeTypeContext { + var p = new(MergeTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mergeType + return p +} + +func InitEmptyMergeTypeContext(p *MergeTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mergeType +} + +func (*MergeTypeContext) IsMergeTypeContext() {} + +func NewMergeTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergeTypeContext { + var p = new(MergeTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_mergeType + + return p +} + +func (s *MergeTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *MergeTypeContext) APPEND() antlr.TerminalNode { + return s.GetToken(DorisParserAPPEND, 0) +} + +func (s *MergeTypeContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *MergeTypeContext) MERGE() antlr.TerminalNode { + return s.GetToken(DorisParserMERGE, 0) +} + +func (s *MergeTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MergeTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MergeTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMergeType(s) + } +} + +func (s *MergeTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMergeType(s) + } +} + +func (s *MergeTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMergeType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MergeType() (localctx IMergeTypeContext) { + localctx = NewMergeTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, DorisParserRULE_mergeType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4934) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAPPEND || _la == DorisParserDELETE || _la == DorisParserMERGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPreFilterClauseContext is an interface to support dynamic dispatch. +type IPreFilterClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRECEDING() antlr.TerminalNode + FILTER() antlr.TerminalNode + Expression() IExpressionContext + + // IsPreFilterClauseContext differentiates from other interfaces. + IsPreFilterClauseContext() +} + +type PreFilterClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPreFilterClauseContext() *PreFilterClauseContext { + var p = new(PreFilterClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_preFilterClause + return p +} + +func InitEmptyPreFilterClauseContext(p *PreFilterClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_preFilterClause +} + +func (*PreFilterClauseContext) IsPreFilterClauseContext() {} + +func NewPreFilterClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreFilterClauseContext { + var p = new(PreFilterClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_preFilterClause + + return p +} + +func (s *PreFilterClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PreFilterClauseContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(DorisParserPRECEDING, 0) +} + +func (s *PreFilterClauseContext) FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserFILTER, 0) +} + +func (s *PreFilterClauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PreFilterClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PreFilterClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PreFilterClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPreFilterClause(s) + } +} + +func (s *PreFilterClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPreFilterClause(s) + } +} + +func (s *PreFilterClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPreFilterClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PreFilterClause() (localctx IPreFilterClauseContext) { + localctx = NewPreFilterClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, DorisParserRULE_preFilterClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4936) + p.Match(DorisParserPRECEDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4937) + p.Match(DorisParserFILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4938) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeleteOnClauseContext is an interface to support dynamic dispatch. +type IDeleteOnClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + ON() antlr.TerminalNode + Expression() IExpressionContext + + // IsDeleteOnClauseContext differentiates from other interfaces. + IsDeleteOnClauseContext() +} + +type DeleteOnClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeleteOnClauseContext() *DeleteOnClauseContext { + var p = new(DeleteOnClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_deleteOnClause + return p +} + +func InitEmptyDeleteOnClauseContext(p *DeleteOnClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_deleteOnClause +} + +func (*DeleteOnClauseContext) IsDeleteOnClauseContext() {} + +func NewDeleteOnClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteOnClauseContext { + var p = new(DeleteOnClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_deleteOnClause + + return p +} + +func (s *DeleteOnClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeleteOnClauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(DorisParserDELETE, 0) +} + +func (s *DeleteOnClauseContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *DeleteOnClauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DeleteOnClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeleteOnClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeleteOnClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDeleteOnClause(s) + } +} + +func (s *DeleteOnClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDeleteOnClause(s) + } +} + +func (s *DeleteOnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDeleteOnClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DeleteOnClause() (localctx IDeleteOnClauseContext) { + localctx = NewDeleteOnClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, DorisParserRULE_deleteOnClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4940) + p.Match(DorisParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4941) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4942) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISequenceColClauseContext is an interface to support dynamic dispatch. +type ISequenceColClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsSequenceColClauseContext differentiates from other interfaces. + IsSequenceColClauseContext() +} + +type SequenceColClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequenceColClauseContext() *SequenceColClauseContext { + var p = new(SequenceColClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sequenceColClause + return p +} + +func InitEmptySequenceColClauseContext(p *SequenceColClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sequenceColClause +} + +func (*SequenceColClauseContext) IsSequenceColClauseContext() {} + +func NewSequenceColClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SequenceColClauseContext { + var p = new(SequenceColClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_sequenceColClause + + return p +} + +func (s *SequenceColClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SequenceColClauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(DorisParserORDER, 0) +} + +func (s *SequenceColClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *SequenceColClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SequenceColClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SequenceColClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SequenceColClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSequenceColClause(s) + } +} + +func (s *SequenceColClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSequenceColClause(s) + } +} + +func (s *SequenceColClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSequenceColClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SequenceColClause() (localctx ISequenceColClauseContext) { + localctx = NewSequenceColClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, DorisParserRULE_sequenceColClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4944) + p.Match(DorisParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4945) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4946) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColFromPathContext is an interface to support dynamic dispatch. +type IColFromPathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMNS() antlr.TerminalNode + FROM() antlr.TerminalNode + PATH() antlr.TerminalNode + AS() antlr.TerminalNode + IdentifierList() IIdentifierListContext + + // IsColFromPathContext differentiates from other interfaces. + IsColFromPathContext() +} + +type ColFromPathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColFromPathContext() *ColFromPathContext { + var p = new(ColFromPathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_colFromPath + return p +} + +func InitEmptyColFromPathContext(p *ColFromPathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_colFromPath +} + +func (*ColFromPathContext) IsColFromPathContext() {} + +func NewColFromPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColFromPathContext { + var p = new(ColFromPathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_colFromPath + + return p +} + +func (s *ColFromPathContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColFromPathContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *ColFromPathContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ColFromPathContext) PATH() antlr.TerminalNode { + return s.GetToken(DorisParserPATH, 0) +} + +func (s *ColFromPathContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *ColFromPathContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *ColFromPathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColFromPathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColFromPathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColFromPath(s) + } +} + +func (s *ColFromPathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColFromPath(s) + } +} + +func (s *ColFromPathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColFromPath(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ColFromPath() (localctx IColFromPathContext) { + localctx = NewColFromPathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, DorisParserRULE_colFromPath) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4948) + p.Match(DorisParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4949) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4950) + p.Match(DorisParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4951) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4952) + p.IdentifierList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColMappingListContext is an interface to support dynamic dispatch. +type IColMappingListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_mappingExpr returns the _mappingExpr rule contexts. + Get_mappingExpr() IMappingExprContext + + // Set_mappingExpr sets the _mappingExpr rule contexts. + Set_mappingExpr(IMappingExprContext) + + // GetMappingSet returns the mappingSet rule context list. + GetMappingSet() []IMappingExprContext + + // SetMappingSet sets the mappingSet rule context list. + SetMappingSet([]IMappingExprContext) + + // Getter signatures + SET() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllMappingExpr() []IMappingExprContext + MappingExpr(i int) IMappingExprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColMappingListContext differentiates from other interfaces. + IsColMappingListContext() +} + +type ColMappingListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _mappingExpr IMappingExprContext + mappingSet []IMappingExprContext +} + +func NewEmptyColMappingListContext() *ColMappingListContext { + var p = new(ColMappingListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_colMappingList + return p +} + +func InitEmptyColMappingListContext(p *ColMappingListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_colMappingList +} + +func (*ColMappingListContext) IsColMappingListContext() {} + +func NewColMappingListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColMappingListContext { + var p = new(ColMappingListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_colMappingList + + return p +} + +func (s *ColMappingListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColMappingListContext) Get_mappingExpr() IMappingExprContext { return s._mappingExpr } + +func (s *ColMappingListContext) Set_mappingExpr(v IMappingExprContext) { s._mappingExpr = v } + +func (s *ColMappingListContext) GetMappingSet() []IMappingExprContext { return s.mappingSet } + +func (s *ColMappingListContext) SetMappingSet(v []IMappingExprContext) { s.mappingSet = v } + +func (s *ColMappingListContext) SET() antlr.TerminalNode { + return s.GetToken(DorisParserSET, 0) +} + +func (s *ColMappingListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ColMappingListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ColMappingListContext) AllMappingExpr() []IMappingExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMappingExprContext); ok { + len++ + } + } + + tst := make([]IMappingExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMappingExprContext); ok { + tst[i] = t.(IMappingExprContext) + i++ + } + } + + return tst +} + +func (s *ColMappingListContext) MappingExpr(i int) IMappingExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMappingExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMappingExprContext) +} + +func (s *ColMappingListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ColMappingListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ColMappingListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColMappingListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColMappingListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColMappingList(s) + } +} + +func (s *ColMappingListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColMappingList(s) + } +} + +func (s *ColMappingListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColMappingList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ColMappingList() (localctx IColMappingListContext) { + localctx = NewColMappingListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, DorisParserRULE_colMappingList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4954) + p.Match(DorisParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4955) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4956) + + var _x = p.MappingExpr() + + localctx.(*ColMappingListContext)._mappingExpr = _x + } + localctx.(*ColMappingListContext).mappingSet = append(localctx.(*ColMappingListContext).mappingSet, localctx.(*ColMappingListContext)._mappingExpr) + p.SetState(4961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(4957) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4958) + + var _x = p.MappingExpr() + + localctx.(*ColMappingListContext)._mappingExpr = _x + } + localctx.(*ColMappingListContext).mappingSet = append(localctx.(*ColMappingListContext).mappingSet, localctx.(*ColMappingListContext)._mappingExpr) + + p.SetState(4963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4964) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMappingExprContext is an interface to support dynamic dispatch. +type IMappingExprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMappingCol returns the mappingCol rule contexts. + GetMappingCol() IIdentifierContext + + // SetMappingCol sets the mappingCol rule contexts. + SetMappingCol(IIdentifierContext) + + // Getter signatures + EQ() antlr.TerminalNode + Expression() IExpressionContext + Identifier() IIdentifierContext + + // IsMappingExprContext differentiates from other interfaces. + IsMappingExprContext() +} + +type MappingExprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mappingCol IIdentifierContext +} + +func NewEmptyMappingExprContext() *MappingExprContext { + var p = new(MappingExprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mappingExpr + return p +} + +func InitEmptyMappingExprContext(p *MappingExprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mappingExpr +} + +func (*MappingExprContext) IsMappingExprContext() {} + +func NewMappingExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MappingExprContext { + var p = new(MappingExprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_mappingExpr + + return p +} + +func (s *MappingExprContext) GetParser() antlr.Parser { return s.parser } + +func (s *MappingExprContext) GetMappingCol() IIdentifierContext { return s.mappingCol } + +func (s *MappingExprContext) SetMappingCol(v IIdentifierContext) { s.mappingCol = v } + +func (s *MappingExprContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *MappingExprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MappingExprContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *MappingExprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MappingExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MappingExprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMappingExpr(s) + } +} + +func (s *MappingExprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMappingExpr(s) + } +} + +func (s *MappingExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMappingExpr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MappingExpr() (localctx IMappingExprContext) { + localctx = NewMappingExprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, DorisParserRULE_mappingExpr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4966) + + var _x = p.Identifier() + + localctx.(*MappingExprContext).mappingCol = _x + } + { + p.SetState(4967) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4968) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithRemoteStorageSystemContext is an interface to support dynamic dispatch. +type IWithRemoteStorageSystemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBrokerProperties returns the brokerProperties rule contexts. + GetBrokerProperties() IPropertyItemListContext + + // GetBrokerName returns the brokerName rule contexts. + GetBrokerName() IIdentifierOrTextContext + + // SetBrokerProperties sets the brokerProperties rule contexts. + SetBrokerProperties(IPropertyItemListContext) + + // SetBrokerName sets the brokerName rule contexts. + SetBrokerName(IIdentifierOrTextContext) + + // Getter signatures + ResourceDesc() IResourceDescContext + WITH() antlr.TerminalNode + S3() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + PropertyItemList() IPropertyItemListContext + HDFS() antlr.TerminalNode + LOCAL() antlr.TerminalNode + BROKER() antlr.TerminalNode + IdentifierOrText() IIdentifierOrTextContext + + // IsWithRemoteStorageSystemContext differentiates from other interfaces. + IsWithRemoteStorageSystemContext() +} + +type WithRemoteStorageSystemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + brokerProperties IPropertyItemListContext + brokerName IIdentifierOrTextContext +} + +func NewEmptyWithRemoteStorageSystemContext() *WithRemoteStorageSystemContext { + var p = new(WithRemoteStorageSystemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_withRemoteStorageSystem + return p +} + +func InitEmptyWithRemoteStorageSystemContext(p *WithRemoteStorageSystemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_withRemoteStorageSystem +} + +func (*WithRemoteStorageSystemContext) IsWithRemoteStorageSystemContext() {} + +func NewWithRemoteStorageSystemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithRemoteStorageSystemContext { + var p = new(WithRemoteStorageSystemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_withRemoteStorageSystem + + return p +} + +func (s *WithRemoteStorageSystemContext) GetParser() antlr.Parser { return s.parser } + +func (s *WithRemoteStorageSystemContext) GetBrokerProperties() IPropertyItemListContext { + return s.brokerProperties +} + +func (s *WithRemoteStorageSystemContext) GetBrokerName() IIdentifierOrTextContext { + return s.brokerName +} + +func (s *WithRemoteStorageSystemContext) SetBrokerProperties(v IPropertyItemListContext) { + s.brokerProperties = v +} + +func (s *WithRemoteStorageSystemContext) SetBrokerName(v IIdentifierOrTextContext) { s.brokerName = v } + +func (s *WithRemoteStorageSystemContext) ResourceDesc() IResourceDescContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResourceDescContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResourceDescContext) +} + +func (s *WithRemoteStorageSystemContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *WithRemoteStorageSystemContext) S3() antlr.TerminalNode { + return s.GetToken(DorisParserS3, 0) +} + +func (s *WithRemoteStorageSystemContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *WithRemoteStorageSystemContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *WithRemoteStorageSystemContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *WithRemoteStorageSystemContext) HDFS() antlr.TerminalNode { + return s.GetToken(DorisParserHDFS, 0) +} + +func (s *WithRemoteStorageSystemContext) LOCAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOCAL, 0) +} + +func (s *WithRemoteStorageSystemContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *WithRemoteStorageSystemContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *WithRemoteStorageSystemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WithRemoteStorageSystemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WithRemoteStorageSystemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWithRemoteStorageSystem(s) + } +} + +func (s *WithRemoteStorageSystemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWithRemoteStorageSystem(s) + } +} + +func (s *WithRemoteStorageSystemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWithRemoteStorageSystem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WithRemoteStorageSystem() (localctx IWithRemoteStorageSystemContext) { + localctx = NewWithRemoteStorageSystemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, DorisParserRULE_withRemoteStorageSystem) + var _la int + + p.SetState(4998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 702, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4970) + p.ResourceDesc() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4971) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4972) + p.Match(DorisParserS3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4973) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4974) + + var _x = p.PropertyItemList() + + localctx.(*WithRemoteStorageSystemContext).brokerProperties = _x + } + { + p.SetState(4975) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4977) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4978) + p.Match(DorisParserHDFS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4979) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4980) + + var _x = p.PropertyItemList() + + localctx.(*WithRemoteStorageSystemContext).brokerProperties = _x + } + { + p.SetState(4981) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4983) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4984) + p.Match(DorisParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4985) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4986) + + var _x = p.PropertyItemList() + + localctx.(*WithRemoteStorageSystemContext).brokerProperties = _x + } + { + p.SetState(4987) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4989) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4990) + p.Match(DorisParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4991) + + var _x = p.IdentifierOrText() + + localctx.(*WithRemoteStorageSystemContext).brokerName = _x + } + p.SetState(4996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(4992) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4993) + + var _x = p.PropertyItemList() + + localctx.(*WithRemoteStorageSystemContext).brokerProperties = _x + } + { + p.SetState(4994) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResourceDescContext is an interface to support dynamic dispatch. +type IResourceDescContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetResourceName returns the resourceName rule contexts. + GetResourceName() IIdentifierOrTextContext + + // SetResourceName sets the resourceName rule contexts. + SetResourceName(IIdentifierOrTextContext) + + // Getter signatures + WITH() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + IdentifierOrText() IIdentifierOrTextContext + LEFT_PAREN() antlr.TerminalNode + PropertyItemList() IPropertyItemListContext + RIGHT_PAREN() antlr.TerminalNode + + // IsResourceDescContext differentiates from other interfaces. + IsResourceDescContext() +} + +type ResourceDescContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + resourceName IIdentifierOrTextContext +} + +func NewEmptyResourceDescContext() *ResourceDescContext { + var p = new(ResourceDescContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_resourceDesc + return p +} + +func InitEmptyResourceDescContext(p *ResourceDescContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_resourceDesc +} + +func (*ResourceDescContext) IsResourceDescContext() {} + +func NewResourceDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResourceDescContext { + var p = new(ResourceDescContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_resourceDesc + + return p +} + +func (s *ResourceDescContext) GetParser() antlr.Parser { return s.parser } + +func (s *ResourceDescContext) GetResourceName() IIdentifierOrTextContext { return s.resourceName } + +func (s *ResourceDescContext) SetResourceName(v IIdentifierOrTextContext) { s.resourceName = v } + +func (s *ResourceDescContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *ResourceDescContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *ResourceDescContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *ResourceDescContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ResourceDescContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *ResourceDescContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ResourceDescContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResourceDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ResourceDescContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterResourceDesc(s) + } +} + +func (s *ResourceDescContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitResourceDesc(s) + } +} + +func (s *ResourceDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitResourceDesc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ResourceDesc() (localctx IResourceDescContext) { + localctx = NewResourceDescContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, DorisParserRULE_resourceDesc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5000) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5001) + p.Match(DorisParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5002) + + var _x = p.IdentifierOrText() + + localctx.(*ResourceDescContext).resourceName = _x + } + p.SetState(5007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5003) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5004) + p.PropertyItemList() + } + { + p.SetState(5005) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMysqlDataDescContext is an interface to support dynamic dispatch. +type IMysqlDataDescContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilePath returns the filePath token. + GetFilePath() antlr.Token + + // GetComma returns the comma token. + GetComma() antlr.Token + + // GetSeparator returns the separator token. + GetSeparator() antlr.Token + + // SetFilePath sets the filePath token. + SetFilePath(antlr.Token) + + // SetComma sets the comma token. + SetComma(antlr.Token) + + // SetSeparator sets the separator token. + SetSeparator(antlr.Token) + + // GetTableName returns the tableName rule contexts. + GetTableName() IMultipartIdentifierContext + + // GetPartition returns the partition rule contexts. + GetPartition() IIdentifierListContext + + // GetColumns returns the columns rule contexts. + GetColumns() IIdentifierListContext + + // SetTableName sets the tableName rule contexts. + SetTableName(IMultipartIdentifierContext) + + // SetPartition sets the partition rule contexts. + SetPartition(IIdentifierListContext) + + // SetColumns sets the columns rule contexts. + SetColumns(IIdentifierListContext) + + // Getter signatures + DATA() antlr.TerminalNode + INFILE() antlr.TerminalNode + INTO() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + MultipartIdentifier() IMultipartIdentifierContext + LOCAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllTERMINATED() []antlr.TerminalNode + TERMINATED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + LINES() antlr.TerminalNode + SkipLines() ISkipLinesContext + ColMappingList() IColMappingListContext + PropertyClause() IPropertyClauseContext + AllIdentifierList() []IIdentifierListContext + IdentifierList(i int) IIdentifierListContext + + // IsMysqlDataDescContext differentiates from other interfaces. + IsMysqlDataDescContext() +} + +type MysqlDataDescContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + filePath antlr.Token + tableName IMultipartIdentifierContext + partition IIdentifierListContext + comma antlr.Token + separator antlr.Token + columns IIdentifierListContext +} + +func NewEmptyMysqlDataDescContext() *MysqlDataDescContext { + var p = new(MysqlDataDescContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mysqlDataDesc + return p +} + +func InitEmptyMysqlDataDescContext(p *MysqlDataDescContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_mysqlDataDesc +} + +func (*MysqlDataDescContext) IsMysqlDataDescContext() {} + +func NewMysqlDataDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MysqlDataDescContext { + var p = new(MysqlDataDescContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_mysqlDataDesc + + return p +} + +func (s *MysqlDataDescContext) GetParser() antlr.Parser { return s.parser } + +func (s *MysqlDataDescContext) GetFilePath() antlr.Token { return s.filePath } + +func (s *MysqlDataDescContext) GetComma() antlr.Token { return s.comma } + +func (s *MysqlDataDescContext) GetSeparator() antlr.Token { return s.separator } + +func (s *MysqlDataDescContext) SetFilePath(v antlr.Token) { s.filePath = v } + +func (s *MysqlDataDescContext) SetComma(v antlr.Token) { s.comma = v } + +func (s *MysqlDataDescContext) SetSeparator(v antlr.Token) { s.separator = v } + +func (s *MysqlDataDescContext) GetTableName() IMultipartIdentifierContext { return s.tableName } + +func (s *MysqlDataDescContext) GetPartition() IIdentifierListContext { return s.partition } + +func (s *MysqlDataDescContext) GetColumns() IIdentifierListContext { return s.columns } + +func (s *MysqlDataDescContext) SetTableName(v IMultipartIdentifierContext) { s.tableName = v } + +func (s *MysqlDataDescContext) SetPartition(v IIdentifierListContext) { s.partition = v } + +func (s *MysqlDataDescContext) SetColumns(v IIdentifierListContext) { s.columns = v } + +func (s *MysqlDataDescContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *MysqlDataDescContext) INFILE() antlr.TerminalNode { + return s.GetToken(DorisParserINFILE, 0) +} + +func (s *MysqlDataDescContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *MysqlDataDescContext) TABLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLE, 0) +} + +func (s *MysqlDataDescContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *MysqlDataDescContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *MysqlDataDescContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *MysqlDataDescContext) LOCAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOCAL, 0) +} + +func (s *MysqlDataDescContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *MysqlDataDescContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *MysqlDataDescContext) AllTERMINATED() []antlr.TerminalNode { + return s.GetTokens(DorisParserTERMINATED) +} + +func (s *MysqlDataDescContext) TERMINATED(i int) antlr.TerminalNode { + return s.GetToken(DorisParserTERMINATED, i) +} + +func (s *MysqlDataDescContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(DorisParserBY) +} + +func (s *MysqlDataDescContext) BY(i int) antlr.TerminalNode { + return s.GetToken(DorisParserBY, i) +} + +func (s *MysqlDataDescContext) LINES() antlr.TerminalNode { + return s.GetToken(DorisParserLINES, 0) +} + +func (s *MysqlDataDescContext) SkipLines() ISkipLinesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISkipLinesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISkipLinesContext) +} + +func (s *MysqlDataDescContext) ColMappingList() IColMappingListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColMappingListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColMappingListContext) +} + +func (s *MysqlDataDescContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *MysqlDataDescContext) AllIdentifierList() []IIdentifierListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierListContext); ok { + len++ + } + } + + tst := make([]IIdentifierListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierListContext); ok { + tst[i] = t.(IIdentifierListContext) + i++ + } + } + + return tst +} + +func (s *MysqlDataDescContext) IdentifierList(i int) IIdentifierListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *MysqlDataDescContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MysqlDataDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MysqlDataDescContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMysqlDataDesc(s) + } +} + +func (s *MysqlDataDescContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMysqlDataDesc(s) + } +} + +func (s *MysqlDataDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMysqlDataDesc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MysqlDataDesc() (localctx IMysqlDataDescContext) { + localctx = NewMysqlDataDescContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, DorisParserRULE_mysqlDataDesc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5009) + p.Match(DorisParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLOCAL { + { + p.SetState(5010) + p.Match(DorisParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5013) + p.Match(DorisParserINFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5014) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*MysqlDataDescContext).filePath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5015) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5016) + p.Match(DorisParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5017) + + var _x = p.MultipartIdentifier() + + localctx.(*MysqlDataDescContext).tableName = _x + } + p.SetState(5020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION { + { + p.SetState(5018) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5019) + + var _x = p.IdentifierList() + + localctx.(*MysqlDataDescContext).partition = _x + } + + } + p.SetState(5026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOLUMNS { + { + p.SetState(5022) + p.Match(DorisParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5023) + p.Match(DorisParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5024) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5025) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*MysqlDataDescContext).comma = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLINES { + { + p.SetState(5028) + p.Match(DorisParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5029) + p.Match(DorisParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5030) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5031) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*MysqlDataDescContext).separator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIGNORE { + { + p.SetState(5034) + p.SkipLines() + } + + } + p.SetState(5038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5037) + + var _x = p.IdentifierList() + + localctx.(*MysqlDataDescContext).columns = _x + } + + } + p.SetState(5041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSET { + { + p.SetState(5040) + p.ColMappingList() + } + + } + p.SetState(5044) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 711, p.GetParserRuleContext()) == 1 { + { + p.SetState(5043) + p.PropertyClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISkipLinesContext is an interface to support dynamic dispatch. +type ISkipLinesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLines returns the lines token. + GetLines() antlr.Token + + // SetLines sets the lines token. + SetLines(antlr.Token) + + // Getter signatures + IGNORE() antlr.TerminalNode + LINES() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + ROWS() antlr.TerminalNode + + // IsSkipLinesContext differentiates from other interfaces. + IsSkipLinesContext() +} + +type SkipLinesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + lines antlr.Token +} + +func NewEmptySkipLinesContext() *SkipLinesContext { + var p = new(SkipLinesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_skipLines + return p +} + +func InitEmptySkipLinesContext(p *SkipLinesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_skipLines +} + +func (*SkipLinesContext) IsSkipLinesContext() {} + +func NewSkipLinesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SkipLinesContext { + var p = new(SkipLinesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_skipLines + + return p +} + +func (s *SkipLinesContext) GetParser() antlr.Parser { return s.parser } + +func (s *SkipLinesContext) GetLines() antlr.Token { return s.lines } + +func (s *SkipLinesContext) SetLines(v antlr.Token) { s.lines = v } + +func (s *SkipLinesContext) IGNORE() antlr.TerminalNode { + return s.GetToken(DorisParserIGNORE, 0) +} + +func (s *SkipLinesContext) LINES() antlr.TerminalNode { + return s.GetToken(DorisParserLINES, 0) +} + +func (s *SkipLinesContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *SkipLinesContext) ROWS() antlr.TerminalNode { + return s.GetToken(DorisParserROWS, 0) +} + +func (s *SkipLinesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SkipLinesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SkipLinesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSkipLines(s) + } +} + +func (s *SkipLinesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSkipLines(s) + } +} + +func (s *SkipLinesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSkipLines(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SkipLines() (localctx ISkipLinesContext) { + localctx = NewSkipLinesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, DorisParserRULE_skipLines) + p.SetState(5052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 712, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5046) + p.Match(DorisParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5047) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*SkipLinesContext).lines = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5048) + p.Match(DorisParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5049) + p.Match(DorisParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5050) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*SkipLinesContext).lines = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5051) + p.Match(DorisParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOutFileClauseContext is an interface to support dynamic dispatch. +type IOutFileClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilePath returns the filePath rule contexts. + GetFilePath() IConstantContext + + // GetFormat returns the format rule contexts. + GetFormat() IIdentifierContext + + // SetFilePath sets the filePath rule contexts. + SetFilePath(IConstantContext) + + // SetFormat sets the format rule contexts. + SetFormat(IIdentifierContext) + + // Getter signatures + INTO() antlr.TerminalNode + OUTFILE() antlr.TerminalNode + Constant() IConstantContext + FORMAT() antlr.TerminalNode + AS() antlr.TerminalNode + PropertyClause() IPropertyClauseContext + Identifier() IIdentifierContext + + // IsOutFileClauseContext differentiates from other interfaces. + IsOutFileClauseContext() +} + +type OutFileClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + filePath IConstantContext + format IIdentifierContext +} + +func NewEmptyOutFileClauseContext() *OutFileClauseContext { + var p = new(OutFileClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_outFileClause + return p +} + +func InitEmptyOutFileClauseContext(p *OutFileClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_outFileClause +} + +func (*OutFileClauseContext) IsOutFileClauseContext() {} + +func NewOutFileClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OutFileClauseContext { + var p = new(OutFileClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_outFileClause + + return p +} + +func (s *OutFileClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *OutFileClauseContext) GetFilePath() IConstantContext { return s.filePath } + +func (s *OutFileClauseContext) GetFormat() IIdentifierContext { return s.format } + +func (s *OutFileClauseContext) SetFilePath(v IConstantContext) { s.filePath = v } + +func (s *OutFileClauseContext) SetFormat(v IIdentifierContext) { s.format = v } + +func (s *OutFileClauseContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *OutFileClauseContext) OUTFILE() antlr.TerminalNode { + return s.GetToken(DorisParserOUTFILE, 0) +} + +func (s *OutFileClauseContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *OutFileClauseContext) FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserFORMAT, 0) +} + +func (s *OutFileClauseContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *OutFileClauseContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *OutFileClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *OutFileClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OutFileClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OutFileClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterOutFileClause(s) + } +} + +func (s *OutFileClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitOutFileClause(s) + } +} + +func (s *OutFileClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitOutFileClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) OutFileClause() (localctx IOutFileClauseContext) { + localctx = NewOutFileClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, DorisParserRULE_outFileClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5054) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5055) + p.Match(DorisParserOUTFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5056) + + var _x = p.Constant() + + localctx.(*OutFileClauseContext).filePath = _x + } + p.SetState(5060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFORMAT { + { + p.SetState(5057) + p.Match(DorisParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5058) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5059) + + var _x = p.Identifier() + + localctx.(*OutFileClauseContext).format = _x + } + + } + p.SetState(5063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(5062) + p.PropertyClause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryContext is an interface to support dynamic dispatch. +type IQueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QueryTerm() IQueryTermContext + QueryOrganization() IQueryOrganizationContext + Cte() ICteContext + + // IsQueryContext differentiates from other interfaces. + IsQueryContext() +} + +type QueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryContext() *QueryContext { + var p = new(QueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_query + return p +} + +func InitEmptyQueryContext(p *QueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_query +} + +func (*QueryContext) IsQueryContext() {} + +func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext { + var p = new(QueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_query + + return p +} + +func (s *QueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryContext) QueryTerm() IQueryTermContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryTermContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryTermContext) +} + +func (s *QueryContext) QueryOrganization() IQueryOrganizationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryOrganizationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryOrganizationContext) +} + +func (s *QueryContext) Cte() ICteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICteContext) +} + +func (s *QueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQuery(s) + } +} + +func (s *QueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQuery(s) + } +} + +func (s *QueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQuery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Query() (localctx IQueryContext) { + localctx = NewQueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, DorisParserRULE_query) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserWITH { + { + p.SetState(5065) + p.Cte() + } + + } + { + p.SetState(5068) + p.queryTerm(0) + } + { + p.SetState(5069) + p.QueryOrganization() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryTermContext is an interface to support dynamic dispatch. +type IQueryTermContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsQueryTermContext differentiates from other interfaces. + IsQueryTermContext() +} + +type QueryTermContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryTermContext() *QueryTermContext { + var p = new(QueryTermContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_queryTerm + return p +} + +func InitEmptyQueryTermContext(p *QueryTermContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_queryTerm +} + +func (*QueryTermContext) IsQueryTermContext() {} + +func NewQueryTermContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryTermContext { + var p = new(QueryTermContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_queryTerm + + return p +} + +func (s *QueryTermContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryTermContext) CopyAll(ctx *QueryTermContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *QueryTermContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryTermContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type QueryTermDefaultContext struct { + QueryTermContext +} + +func NewQueryTermDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryTermDefaultContext { + var p = new(QueryTermDefaultContext) + + InitEmptyQueryTermContext(&p.QueryTermContext) + p.parser = parser + p.CopyAll(ctx.(*QueryTermContext)) + + return p +} + +func (s *QueryTermDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryTermDefaultContext) QueryPrimary() IQueryPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryPrimaryContext) +} + +func (s *QueryTermDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQueryTermDefault(s) + } +} + +func (s *QueryTermDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQueryTermDefault(s) + } +} + +func (s *QueryTermDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQueryTermDefault(s) + + default: + return t.VisitChildren(s) + } +} + +type SetOperationContext struct { + QueryTermContext + left IQueryTermContext + operator antlr.Token + right IQueryTermContext +} + +func NewSetOperationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetOperationContext { + var p = new(SetOperationContext) + + InitEmptyQueryTermContext(&p.QueryTermContext) + p.parser = parser + p.CopyAll(ctx.(*QueryTermContext)) + + return p +} + +func (s *SetOperationContext) GetOperator() antlr.Token { return s.operator } + +func (s *SetOperationContext) SetOperator(v antlr.Token) { s.operator = v } + +func (s *SetOperationContext) GetLeft() IQueryTermContext { return s.left } + +func (s *SetOperationContext) GetRight() IQueryTermContext { return s.right } + +func (s *SetOperationContext) SetLeft(v IQueryTermContext) { s.left = v } + +func (s *SetOperationContext) SetRight(v IQueryTermContext) { s.right = v } + +func (s *SetOperationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetOperationContext) AllQueryTerm() []IQueryTermContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQueryTermContext); ok { + len++ + } + } + + tst := make([]IQueryTermContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQueryTermContext); ok { + tst[i] = t.(IQueryTermContext) + i++ + } + } + + return tst +} + +func (s *SetOperationContext) QueryTerm(i int) IQueryTermContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryTermContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQueryTermContext) +} + +func (s *SetOperationContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(DorisParserINTERSECT, 0) +} + +func (s *SetOperationContext) SetQuantifier() ISetQuantifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetQuantifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetQuantifierContext) +} + +func (s *SetOperationContext) UNION() antlr.TerminalNode { + return s.GetToken(DorisParserUNION, 0) +} + +func (s *SetOperationContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(DorisParserEXCEPT, 0) +} + +func (s *SetOperationContext) MINUS() antlr.TerminalNode { + return s.GetToken(DorisParserMINUS, 0) +} + +func (s *SetOperationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetOperation(s) + } +} + +func (s *SetOperationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetOperation(s) + } +} + +func (s *SetOperationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetOperation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QueryTerm() (localctx IQueryTermContext) { + return p.queryTerm(0) +} + +func (p *DorisParser) queryTerm(_p int) (localctx IQueryTermContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewQueryTermContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IQueryTermContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 234 + p.EnterRecursionRule(localctx, 234, DorisParserRULE_queryTerm, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + localctx = NewQueryTermDefaultContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(5072) + p.QueryPrimary() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(5088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 719, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(5086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 718, p.GetParserRuleContext()) { + case 1: + localctx = NewSetOperationContext(p, NewQueryTermContext(p, _parentctx, _parentState)) + localctx.(*SetOperationContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_queryTerm) + p.SetState(5074) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(5075) + + var _m = p.Match(DorisParserINTERSECT) + + localctx.(*SetOperationContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL || _la == DorisParserDISTINCT { + { + p.SetState(5076) + p.SetQuantifier() + } + + } + { + p.SetState(5079) + + var _x = p.queryTerm(3) + + localctx.(*SetOperationContext).right = _x + } + + case 2: + localctx = NewSetOperationContext(p, NewQueryTermContext(p, _parentctx, _parentState)) + localctx.(*SetOperationContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_queryTerm) + p.SetState(5080) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(5081) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SetOperationContext).operator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserEXCEPT || _la == DorisParserMINUS || _la == DorisParserUNION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SetOperationContext).operator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5083) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL || _la == DorisParserDISTINCT { + { + p.SetState(5082) + p.SetQuantifier() + } + + } + { + p.SetState(5085) + + var _x = p.queryTerm(2) + + localctx.(*SetOperationContext).right = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 719, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetQuantifierContext is an interface to support dynamic dispatch. +type ISetQuantifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISTINCT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsSetQuantifierContext differentiates from other interfaces. + IsSetQuantifierContext() +} + +type SetQuantifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetQuantifierContext() *SetQuantifierContext { + var p = new(SetQuantifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_setQuantifier + return p +} + +func InitEmptySetQuantifierContext(p *SetQuantifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_setQuantifier +} + +func (*SetQuantifierContext) IsSetQuantifierContext() {} + +func NewSetQuantifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetQuantifierContext { + var p = new(SetQuantifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_setQuantifier + + return p +} + +func (s *SetQuantifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetQuantifierContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(DorisParserDISTINCT, 0) +} + +func (s *SetQuantifierContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *SetQuantifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetQuantifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetQuantifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSetQuantifier(s) + } +} + +func (s *SetQuantifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSetQuantifier(s) + } +} + +func (s *SetQuantifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSetQuantifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SetQuantifier() (localctx ISetQuantifierContext) { + localctx = NewSetQuantifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, DorisParserRULE_setQuantifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5091) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserALL || _la == DorisParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryPrimaryContext is an interface to support dynamic dispatch. +type IQueryPrimaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsQueryPrimaryContext differentiates from other interfaces. + IsQueryPrimaryContext() +} + +type QueryPrimaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryPrimaryContext() *QueryPrimaryContext { + var p = new(QueryPrimaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_queryPrimary + return p +} + +func InitEmptyQueryPrimaryContext(p *QueryPrimaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_queryPrimary +} + +func (*QueryPrimaryContext) IsQueryPrimaryContext() {} + +func NewQueryPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryPrimaryContext { + var p = new(QueryPrimaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_queryPrimary + + return p +} + +func (s *QueryPrimaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryPrimaryContext) CopyAll(ctx *QueryPrimaryContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *QueryPrimaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryPrimaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SubqueryContext struct { + QueryPrimaryContext +} + +func NewSubqueryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryContext { + var p = new(SubqueryContext) + + InitEmptyQueryPrimaryContext(&p.QueryPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*QueryPrimaryContext)) + + return p +} + +func (s *SubqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SubqueryContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *SubqueryContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SubqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSubquery(s) + } +} + +func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSubquery(s) + } +} + +func (s *SubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSubquery(s) + + default: + return t.VisitChildren(s) + } +} + +type ValuesTableContext struct { + QueryPrimaryContext +} + +func NewValuesTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ValuesTableContext { + var p = new(ValuesTableContext) + + InitEmptyQueryPrimaryContext(&p.QueryPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*QueryPrimaryContext)) + + return p +} + +func (s *ValuesTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValuesTableContext) InlineTable() IInlineTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInlineTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInlineTableContext) +} + +func (s *ValuesTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterValuesTable(s) + } +} + +func (s *ValuesTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitValuesTable(s) + } +} + +func (s *ValuesTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitValuesTable(s) + + default: + return t.VisitChildren(s) + } +} + +type QueryPrimaryDefaultContext struct { + QueryPrimaryContext +} + +func NewQueryPrimaryDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryPrimaryDefaultContext { + var p = new(QueryPrimaryDefaultContext) + + InitEmptyQueryPrimaryContext(&p.QueryPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*QueryPrimaryContext)) + + return p +} + +func (s *QueryPrimaryDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryPrimaryDefaultContext) QuerySpecification() IQuerySpecificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuerySpecificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuerySpecificationContext) +} + +func (s *QueryPrimaryDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQueryPrimaryDefault(s) + } +} + +func (s *QueryPrimaryDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQueryPrimaryDefault(s) + } +} + +func (s *QueryPrimaryDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQueryPrimaryDefault(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QueryPrimary() (localctx IQueryPrimaryContext) { + localctx = NewQueryPrimaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, DorisParserRULE_queryPrimary) + p.SetState(5099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSELECT: + localctx = NewQueryPrimaryDefaultContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5093) + p.QuerySpecification() + } + + case DorisParserLEFT_PAREN: + localctx = NewSubqueryContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5094) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5095) + p.Query() + } + { + p.SetState(5096) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserVALUES: + localctx = NewValuesTableContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5098) + p.InlineTable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuerySpecificationContext is an interface to support dynamic dispatch. +type IQuerySpecificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsQuerySpecificationContext differentiates from other interfaces. + IsQuerySpecificationContext() +} + +type QuerySpecificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuerySpecificationContext() *QuerySpecificationContext { + var p = new(QuerySpecificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_querySpecification + return p +} + +func InitEmptyQuerySpecificationContext(p *QuerySpecificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_querySpecification +} + +func (*QuerySpecificationContext) IsQuerySpecificationContext() {} + +func NewQuerySpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuerySpecificationContext { + var p = new(QuerySpecificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_querySpecification + + return p +} + +func (s *QuerySpecificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *QuerySpecificationContext) CopyAll(ctx *QuerySpecificationContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *QuerySpecificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QuerySpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type RegularQuerySpecificationContext struct { + QuerySpecificationContext +} + +func NewRegularQuerySpecificationContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RegularQuerySpecificationContext { + var p = new(RegularQuerySpecificationContext) + + InitEmptyQuerySpecificationContext(&p.QuerySpecificationContext) + p.parser = parser + p.CopyAll(ctx.(*QuerySpecificationContext)) + + return p +} + +func (s *RegularQuerySpecificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RegularQuerySpecificationContext) SelectClause() ISelectClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectClauseContext) +} + +func (s *RegularQuerySpecificationContext) IntoClause() IIntoClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntoClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntoClauseContext) +} + +func (s *RegularQuerySpecificationContext) FromClause() IFromClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromClauseContext) +} + +func (s *RegularQuerySpecificationContext) WhereClause() IWhereClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereClauseContext) +} + +func (s *RegularQuerySpecificationContext) AggClause() IAggClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggClauseContext) +} + +func (s *RegularQuerySpecificationContext) HavingClause() IHavingClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHavingClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHavingClauseContext) +} + +func (s *RegularQuerySpecificationContext) QualifyClause() IQualifyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifyClauseContext) +} + +func (s *RegularQuerySpecificationContext) QueryOrganization() IQueryOrganizationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryOrganizationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryOrganizationContext) +} + +func (s *RegularQuerySpecificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRegularQuerySpecification(s) + } +} + +func (s *RegularQuerySpecificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRegularQuerySpecification(s) + } +} + +func (s *RegularQuerySpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRegularQuerySpecification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QuerySpecification() (localctx IQuerySpecificationContext) { + localctx = NewQuerySpecificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, DorisParserRULE_querySpecification) + localctx = NewRegularQuerySpecificationContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5101) + p.SelectClause() + } + p.SetState(5103) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 721, p.GetParserRuleContext()) == 1 { + { + p.SetState(5102) + p.IntoClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5106) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 722, p.GetParserRuleContext()) == 1 { + { + p.SetState(5105) + p.FromClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5109) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 723, p.GetParserRuleContext()) == 1 { + { + p.SetState(5108) + p.WhereClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5112) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 724, p.GetParserRuleContext()) == 1 { + { + p.SetState(5111) + p.AggClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5115) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 725, p.GetParserRuleContext()) == 1 { + { + p.SetState(5114) + p.HavingClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5118) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 726, p.GetParserRuleContext()) == 1 { + { + p.SetState(5117) + p.QualifyClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5121) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 1 { + { + p.SetState(5120) + p.QueryOrganization() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICteContext is an interface to support dynamic dispatch. +type ICteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllAliasQuery() []IAliasQueryContext + AliasQuery(i int) IAliasQueryContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCteContext differentiates from other interfaces. + IsCteContext() +} + +type CteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCteContext() *CteContext { + var p = new(CteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_cte + return p +} + +func InitEmptyCteContext(p *CteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_cte +} + +func (*CteContext) IsCteContext() {} + +func NewCteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CteContext { + var p = new(CteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_cte + + return p +} + +func (s *CteContext) GetParser() antlr.Parser { return s.parser } + +func (s *CteContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *CteContext) AllAliasQuery() []IAliasQueryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAliasQueryContext); ok { + len++ + } + } + + tst := make([]IAliasQueryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAliasQueryContext); ok { + tst[i] = t.(IAliasQueryContext) + i++ + } + } + + return tst +} + +func (s *CteContext) AliasQuery(i int) IAliasQueryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliasQueryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAliasQueryContext) +} + +func (s *CteContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CteContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCte(s) + } +} + +func (s *CteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCte(s) + } +} + +func (s *CteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCte(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Cte() (localctx ICteContext) { + localctx = NewCteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, DorisParserRULE_cte) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5123) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5124) + p.AliasQuery() + } + p.SetState(5129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5125) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5126) + p.AliasQuery() + } + + p.SetState(5131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAliasQueryContext is an interface to support dynamic dispatch. +type IAliasQueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Query() IQueryContext + RIGHT_PAREN() antlr.TerminalNode + ColumnAliases() IColumnAliasesContext + + // IsAliasQueryContext differentiates from other interfaces. + IsAliasQueryContext() +} + +type AliasQueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAliasQueryContext() *AliasQueryContext { + var p = new(AliasQueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_aliasQuery + return p +} + +func InitEmptyAliasQueryContext(p *AliasQueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_aliasQuery +} + +func (*AliasQueryContext) IsAliasQueryContext() {} + +func NewAliasQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasQueryContext { + var p = new(AliasQueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_aliasQuery + + return p +} + +func (s *AliasQueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *AliasQueryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AliasQueryContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *AliasQueryContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AliasQueryContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *AliasQueryContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AliasQueryContext) ColumnAliases() IColumnAliasesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnAliasesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnAliasesContext) +} + +func (s *AliasQueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AliasQueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AliasQueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAliasQuery(s) + } +} + +func (s *AliasQueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAliasQuery(s) + } +} + +func (s *AliasQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAliasQuery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AliasQuery() (localctx IAliasQueryContext) { + localctx = NewAliasQueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, DorisParserRULE_aliasQuery) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5132) + p.Identifier() + } + p.SetState(5134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5133) + p.ColumnAliases() + } + + } + { + p.SetState(5136) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5137) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5138) + p.Query() + } + { + p.SetState(5139) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnAliasesContext is an interface to support dynamic dispatch. +type IColumnAliasesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumnAliasesContext differentiates from other interfaces. + IsColumnAliasesContext() +} + +type ColumnAliasesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnAliasesContext() *ColumnAliasesContext { + var p = new(ColumnAliasesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnAliases + return p +} + +func InitEmptyColumnAliasesContext(p *ColumnAliasesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnAliases +} + +func (*ColumnAliasesContext) IsColumnAliasesContext() {} + +func NewColumnAliasesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnAliasesContext { + var p = new(ColumnAliasesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_columnAliases + + return p +} + +func (s *ColumnAliasesContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnAliasesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ColumnAliasesContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *ColumnAliasesContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ColumnAliasesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ColumnAliasesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ColumnAliasesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ColumnAliasesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnAliasesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnAliasesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColumnAliases(s) + } +} + +func (s *ColumnAliasesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColumnAliases(s) + } +} + +func (s *ColumnAliasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColumnAliases(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ColumnAliases() (localctx IColumnAliasesContext) { + localctx = NewColumnAliasesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, DorisParserRULE_columnAliases) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5141) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5142) + p.Identifier() + } + p.SetState(5147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5143) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5144) + p.Identifier() + } + + p.SetState(5149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5150) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectClauseContext is an interface to support dynamic dispatch. +type ISelectClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + SelectColumnClause() ISelectColumnClauseContext + DISTINCT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsSelectClauseContext differentiates from other interfaces. + IsSelectClauseContext() +} + +type SelectClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectClauseContext() *SelectClauseContext { + var p = new(SelectClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_selectClause + return p +} + +func InitEmptySelectClauseContext(p *SelectClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_selectClause +} + +func (*SelectClauseContext) IsSelectClauseContext() {} + +func NewSelectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectClauseContext { + var p = new(SelectClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_selectClause + + return p +} + +func (s *SelectClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectClauseContext) SELECT() antlr.TerminalNode { + return s.GetToken(DorisParserSELECT, 0) +} + +func (s *SelectClauseContext) SelectColumnClause() ISelectColumnClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectColumnClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectColumnClauseContext) +} + +func (s *SelectClauseContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(DorisParserDISTINCT, 0) +} + +func (s *SelectClauseContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *SelectClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSelectClause(s) + } +} + +func (s *SelectClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSelectClause(s) + } +} + +func (s *SelectClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSelectClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SelectClause() (localctx ISelectClauseContext) { + localctx = NewSelectClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, DorisParserRULE_selectClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5152) + p.Match(DorisParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL || _la == DorisParserDISTINCT { + { + p.SetState(5153) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserALL || _la == DorisParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5156) + p.SelectColumnClause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectColumnClauseContext is an interface to support dynamic dispatch. +type ISelectColumnClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NamedExpressionSeq() INamedExpressionSeqContext + + // IsSelectColumnClauseContext differentiates from other interfaces. + IsSelectColumnClauseContext() +} + +type SelectColumnClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectColumnClauseContext() *SelectColumnClauseContext { + var p = new(SelectColumnClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_selectColumnClause + return p +} + +func InitEmptySelectColumnClauseContext(p *SelectColumnClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_selectColumnClause +} + +func (*SelectColumnClauseContext) IsSelectColumnClauseContext() {} + +func NewSelectColumnClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectColumnClauseContext { + var p = new(SelectColumnClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_selectColumnClause + + return p +} + +func (s *SelectColumnClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectColumnClauseContext) NamedExpressionSeq() INamedExpressionSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamedExpressionSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamedExpressionSeqContext) +} + +func (s *SelectColumnClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectColumnClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSelectColumnClause(s) + } +} + +func (s *SelectColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSelectColumnClause(s) + } +} + +func (s *SelectColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSelectColumnClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SelectColumnClause() (localctx ISelectColumnClauseContext) { + localctx = NewSelectColumnClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, DorisParserRULE_selectColumnClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5158) + p.NamedExpressionSeq() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhereClauseContext is an interface to support dynamic dispatch. +type IWhereClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + + // IsWhereClauseContext differentiates from other interfaces. + IsWhereClauseContext() +} + +type WhereClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhereClauseContext() *WhereClauseContext { + var p = new(WhereClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_whereClause + return p +} + +func InitEmptyWhereClauseContext(p *WhereClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_whereClause +} + +func (*WhereClauseContext) IsWhereClauseContext() {} + +func NewWhereClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereClauseContext { + var p = new(WhereClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_whereClause + + return p +} + +func (s *WhereClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhereClauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(DorisParserWHERE, 0) +} + +func (s *WhereClauseContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *WhereClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhereClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhereClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWhereClause(s) + } +} + +func (s *WhereClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWhereClause(s) + } +} + +func (s *WhereClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWhereClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WhereClause() (localctx IWhereClauseContext) { + localctx = NewWhereClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, DorisParserRULE_whereClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5160) + p.Match(DorisParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5161) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromClauseContext is an interface to support dynamic dispatch. +type IFromClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + Relations() IRelationsContext + + // IsFromClauseContext differentiates from other interfaces. + IsFromClauseContext() +} + +type FromClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromClauseContext() *FromClauseContext { + var p = new(FromClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_fromClause + return p +} + +func InitEmptyFromClauseContext(p *FromClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_fromClause +} + +func (*FromClauseContext) IsFromClauseContext() {} + +func NewFromClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromClauseContext { + var p = new(FromClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_fromClause + + return p +} + +func (s *FromClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromClauseContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *FromClauseContext) Relations() IRelationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationsContext) +} + +func (s *FromClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFromClause(s) + } +} + +func (s *FromClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFromClause(s) + } +} + +func (s *FromClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFromClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FromClause() (localctx IFromClauseContext) { + localctx = NewFromClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, DorisParserRULE_fromClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5163) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5164) + p.Relations() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIntoClauseContext is an interface to support dynamic dispatch. +type IIntoClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + AllTableRow() []ITableRowContext + TableRow(i int) ITableRowContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + BulkCollectClause() IBulkCollectClauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIntoClauseContext differentiates from other interfaces. + IsIntoClauseContext() +} + +type IntoClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIntoClauseContext() *IntoClauseContext { + var p = new(IntoClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_intoClause + return p +} + +func InitEmptyIntoClauseContext(p *IntoClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_intoClause +} + +func (*IntoClauseContext) IsIntoClauseContext() {} + +func NewIntoClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntoClauseContext { + var p = new(IntoClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_intoClause + + return p +} + +func (s *IntoClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *IntoClauseContext) INTO() antlr.TerminalNode { + return s.GetToken(DorisParserINTO, 0) +} + +func (s *IntoClauseContext) AllTableRow() []ITableRowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableRowContext); ok { + len++ + } + } + + tst := make([]ITableRowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableRowContext); ok { + tst[i] = t.(ITableRowContext) + i++ + } + } + + return tst +} + +func (s *IntoClauseContext) TableRow(i int) ITableRowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableRowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableRowContext) +} + +func (s *IntoClauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *IntoClauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *IntoClauseContext) BulkCollectClause() IBulkCollectClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBulkCollectClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBulkCollectClauseContext) +} + +func (s *IntoClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *IntoClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *IntoClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntoClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IntoClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIntoClause(s) + } +} + +func (s *IntoClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIntoClause(s) + } +} + +func (s *IntoClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIntoClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IntoClause() (localctx IIntoClauseContext) { + localctx = NewIntoClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, DorisParserRULE_intoClause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBULK { + { + p.SetState(5166) + p.BulkCollectClause() + } + + } + { + p.SetState(5169) + p.Match(DorisParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 733, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5170) + p.TableRow() + } + + case 2: + { + p.SetState(5171) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 735, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5174) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 734, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5175) + p.TableRow() + } + + case 2: + { + p.SetState(5176) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 735, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBulkCollectClauseContext is an interface to support dynamic dispatch. +type IBulkCollectClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BULK() antlr.TerminalNode + COLLECT() antlr.TerminalNode + + // IsBulkCollectClauseContext differentiates from other interfaces. + IsBulkCollectClauseContext() +} + +type BulkCollectClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBulkCollectClauseContext() *BulkCollectClauseContext { + var p = new(BulkCollectClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_bulkCollectClause + return p +} + +func InitEmptyBulkCollectClauseContext(p *BulkCollectClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_bulkCollectClause +} + +func (*BulkCollectClauseContext) IsBulkCollectClauseContext() {} + +func NewBulkCollectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BulkCollectClauseContext { + var p = new(BulkCollectClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_bulkCollectClause + + return p +} + +func (s *BulkCollectClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *BulkCollectClauseContext) BULK() antlr.TerminalNode { + return s.GetToken(DorisParserBULK, 0) +} + +func (s *BulkCollectClauseContext) COLLECT() antlr.TerminalNode { + return s.GetToken(DorisParserCOLLECT, 0) +} + +func (s *BulkCollectClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BulkCollectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BulkCollectClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBulkCollectClause(s) + } +} + +func (s *BulkCollectClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBulkCollectClause(s) + } +} + +func (s *BulkCollectClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBulkCollectClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) BulkCollectClause() (localctx IBulkCollectClauseContext) { + localctx = NewBulkCollectClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, DorisParserRULE_bulkCollectClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5184) + p.Match(DorisParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5185) + p.Match(DorisParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableRowContext is an interface to support dynamic dispatch. +type ITableRowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + LEFT_PAREN() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsTableRowContext differentiates from other interfaces. + IsTableRowContext() +} + +type TableRowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableRowContext() *TableRowContext { + var p = new(TableRowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tableRow + return p +} + +func InitEmptyTableRowContext(p *TableRowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tableRow +} + +func (*TableRowContext) IsTableRowContext() {} + +func NewTableRowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableRowContext { + var p = new(TableRowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_tableRow + + return p +} + +func (s *TableRowContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableRowContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *TableRowContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *TableRowContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *TableRowContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *TableRowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableRowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableRowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTableRow(s) + } +} + +func (s *TableRowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTableRow(s) + } +} + +func (s *TableRowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTableRow(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TableRow() (localctx ITableRowContext) { + localctx = NewTableRowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, DorisParserRULE_tableRow) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5187) + p.Identifier() + } + { + p.SetState(5188) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5189) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5190) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationsContext is an interface to support dynamic dispatch. +type IRelationsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRelation() []IRelationContext + Relation(i int) IRelationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRelationsContext differentiates from other interfaces. + IsRelationsContext() +} + +type RelationsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationsContext() *RelationsContext { + var p = new(RelationsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relations + return p +} + +func InitEmptyRelationsContext(p *RelationsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relations +} + +func (*RelationsContext) IsRelationsContext() {} + +func NewRelationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationsContext { + var p = new(RelationsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_relations + + return p +} + +func (s *RelationsContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationsContext) AllRelation() []IRelationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelationContext); ok { + len++ + } + } + + tst := make([]IRelationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelationContext); ok { + tst[i] = t.(IRelationContext) + i++ + } + } + + return tst +} + +func (s *RelationsContext) Relation(i int) IRelationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelationContext) +} + +func (s *RelationsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *RelationsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *RelationsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelationsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRelations(s) + } +} + +func (s *RelationsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRelations(s) + } +} + +func (s *RelationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRelations(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Relations() (localctx IRelationsContext) { + localctx = NewRelationsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, DorisParserRULE_relations) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5192) + p.Relation() + } + p.SetState(5197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 736, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5193) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5194) + p.Relation() + } + + } + p.SetState(5199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 736, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationContext is an interface to support dynamic dispatch. +type IRelationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RelationPrimary() IRelationPrimaryContext + AllJoinRelation() []IJoinRelationContext + JoinRelation(i int) IJoinRelationContext + + // IsRelationContext differentiates from other interfaces. + IsRelationContext() +} + +type RelationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationContext() *RelationContext { + var p = new(RelationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relation + return p +} + +func InitEmptyRelationContext(p *RelationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relation +} + +func (*RelationContext) IsRelationContext() {} + +func NewRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationContext { + var p = new(RelationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_relation + + return p +} + +func (s *RelationContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationContext) RelationPrimary() IRelationPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationPrimaryContext) +} + +func (s *RelationContext) AllJoinRelation() []IJoinRelationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoinRelationContext); ok { + len++ + } + } + + tst := make([]IJoinRelationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoinRelationContext); ok { + tst[i] = t.(IJoinRelationContext) + i++ + } + } + + return tst +} + +func (s *RelationContext) JoinRelation(i int) IJoinRelationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinRelationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoinRelationContext) +} + +func (s *RelationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRelation(s) + } +} + +func (s *RelationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRelation(s) + } +} + +func (s *RelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRelation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Relation() (localctx IRelationContext) { + localctx = NewRelationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, DorisParserRULE_relation) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5200) + p.RelationPrimary() + } + p.SetState(5204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 737, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5201) + p.JoinRelation() + } + + } + p.SetState(5206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 737, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoinRelationContext is an interface to support dynamic dispatch. +type IJoinRelationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRight returns the right rule contexts. + GetRight() IRelationPrimaryContext + + // SetRight sets the right rule contexts. + SetRight(IRelationPrimaryContext) + + // Getter signatures + JOIN() antlr.TerminalNode + RelationPrimary() IRelationPrimaryContext + JoinType() IJoinTypeContext + DistributeType() IDistributeTypeContext + JoinCriteria() IJoinCriteriaContext + + // IsJoinRelationContext differentiates from other interfaces. + IsJoinRelationContext() +} + +type JoinRelationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + right IRelationPrimaryContext +} + +func NewEmptyJoinRelationContext() *JoinRelationContext { + var p = new(JoinRelationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_joinRelation + return p +} + +func InitEmptyJoinRelationContext(p *JoinRelationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_joinRelation +} + +func (*JoinRelationContext) IsJoinRelationContext() {} + +func NewJoinRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinRelationContext { + var p = new(JoinRelationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_joinRelation + + return p +} + +func (s *JoinRelationContext) GetParser() antlr.Parser { return s.parser } + +func (s *JoinRelationContext) GetRight() IRelationPrimaryContext { return s.right } + +func (s *JoinRelationContext) SetRight(v IRelationPrimaryContext) { s.right = v } + +func (s *JoinRelationContext) JOIN() antlr.TerminalNode { + return s.GetToken(DorisParserJOIN, 0) +} + +func (s *JoinRelationContext) RelationPrimary() IRelationPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationPrimaryContext) +} + +func (s *JoinRelationContext) JoinType() IJoinTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoinTypeContext) +} + +func (s *JoinRelationContext) DistributeType() IDistributeTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDistributeTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDistributeTypeContext) +} + +func (s *JoinRelationContext) JoinCriteria() IJoinCriteriaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoinCriteriaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoinCriteriaContext) +} + +func (s *JoinRelationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JoinRelationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JoinRelationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterJoinRelation(s) + } +} + +func (s *JoinRelationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitJoinRelation(s) + } +} + +func (s *JoinRelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitJoinRelation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) JoinRelation() (localctx IJoinRelationContext) { + localctx = NewJoinRelationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, DorisParserRULE_joinRelation) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5207) + p.JoinType() + } + + { + p.SetState(5208) + p.Match(DorisParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5210) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 738, p.GetParserRuleContext()) == 1 { + { + p.SetState(5209) + p.DistributeType() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5212) + + var _x = p.RelationPrimary() + + localctx.(*JoinRelationContext).right = _x + } + p.SetState(5214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 739, p.GetParserRuleContext()) == 1 { + { + p.SetState(5213) + p.JoinCriteria() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDistributeTypeContext is an interface to support dynamic dispatch. +type IDistributeTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_BRACKET() antlr.TerminalNode + Identifier() IIdentifierContext + RIGHT_BRACKET() antlr.TerminalNode + SkewHint() ISkewHintContext + HINT_START() antlr.TerminalNode + HINT_END() antlr.TerminalNode + + // IsDistributeTypeContext differentiates from other interfaces. + IsDistributeTypeContext() +} + +type DistributeTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDistributeTypeContext() *DistributeTypeContext { + var p = new(DistributeTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_distributeType + return p +} + +func InitEmptyDistributeTypeContext(p *DistributeTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_distributeType +} + +func (*DistributeTypeContext) IsDistributeTypeContext() {} + +func NewDistributeTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DistributeTypeContext { + var p = new(DistributeTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_distributeType + + return p +} + +func (s *DistributeTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DistributeTypeContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *DistributeTypeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DistributeTypeContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *DistributeTypeContext) SkewHint() ISkewHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISkewHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISkewHintContext) +} + +func (s *DistributeTypeContext) HINT_START() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_START, 0) +} + +func (s *DistributeTypeContext) HINT_END() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_END, 0) +} + +func (s *DistributeTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DistributeTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DistributeTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDistributeType(s) + } +} + +func (s *DistributeTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDistributeType(s) + } +} + +func (s *DistributeTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDistributeType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DistributeType() (localctx IDistributeTypeContext) { + localctx = NewDistributeTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, DorisParserRULE_distributeType) + var _la int + + p.SetState(5230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACKET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5216) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5217) + p.Identifier() + } + p.SetState(5219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_BRACKET { + { + p.SetState(5218) + p.SkewHint() + } + + } + { + p.SetState(5221) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserHINT_START: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5223) + p.Match(DorisParserHINT_START) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5224) + p.Identifier() + } + p.SetState(5226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_BRACKET { + { + p.SetState(5225) + p.SkewHint() + } + + } + { + p.SetState(5228) + p.Match(DorisParserHINT_END) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISkewHintContext is an interface to support dynamic dispatch. +type ISkewHintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_BRACKET() antlr.TerminalNode + Identifier() IIdentifierContext + LEFT_PAREN() antlr.TerminalNode + QualifiedName() IQualifiedNameContext + ConstantList() IConstantListContext + RIGHT_PAREN() antlr.TerminalNode + RIGHT_BRACKET() antlr.TerminalNode + + // IsSkewHintContext differentiates from other interfaces. + IsSkewHintContext() +} + +type SkewHintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySkewHintContext() *SkewHintContext { + var p = new(SkewHintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_skewHint + return p +} + +func InitEmptySkewHintContext(p *SkewHintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_skewHint +} + +func (*SkewHintContext) IsSkewHintContext() {} + +func NewSkewHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SkewHintContext { + var p = new(SkewHintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_skewHint + + return p +} + +func (s *SkewHintContext) GetParser() antlr.Parser { return s.parser } + +func (s *SkewHintContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *SkewHintContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SkewHintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SkewHintContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *SkewHintContext) ConstantList() IConstantListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantListContext) +} + +func (s *SkewHintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SkewHintContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *SkewHintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SkewHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SkewHintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSkewHint(s) + } +} + +func (s *SkewHintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSkewHint(s) + } +} + +func (s *SkewHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSkewHint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SkewHint() (localctx ISkewHintContext) { + localctx = NewSkewHintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, DorisParserRULE_skewHint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5232) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5233) + p.Identifier() + } + { + p.SetState(5234) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5235) + p.QualifiedName() + } + { + p.SetState(5236) + p.ConstantList() + } + { + p.SetState(5237) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5238) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantListContext is an interface to support dynamic dispatch. +type IConstantListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_constant returns the _constant rule contexts. + Get_constant() IConstantContext + + // Set_constant sets the _constant rule contexts. + Set_constant(IConstantContext) + + // GetValues returns the values rule context list. + GetValues() []IConstantContext + + // SetValues sets the values rule context list. + SetValues([]IConstantContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllConstant() []IConstantContext + Constant(i int) IConstantContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsConstantListContext differentiates from other interfaces. + IsConstantListContext() +} + +type ConstantListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _constant IConstantContext + values []IConstantContext +} + +func NewEmptyConstantListContext() *ConstantListContext { + var p = new(ConstantListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constantList + return p +} + +func InitEmptyConstantListContext(p *ConstantListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constantList +} + +func (*ConstantListContext) IsConstantListContext() {} + +func NewConstantListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantListContext { + var p = new(ConstantListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_constantList + + return p +} + +func (s *ConstantListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantListContext) Get_constant() IConstantContext { return s._constant } + +func (s *ConstantListContext) Set_constant(v IConstantContext) { s._constant = v } + +func (s *ConstantListContext) GetValues() []IConstantContext { return s.values } + +func (s *ConstantListContext) SetValues(v []IConstantContext) { s.values = v } + +func (s *ConstantListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ConstantListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ConstantListContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *ConstantListContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *ConstantListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ConstantListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ConstantListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterConstantList(s) + } +} + +func (s *ConstantListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitConstantList(s) + } +} + +func (s *ConstantListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitConstantList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ConstantList() (localctx IConstantListContext) { + localctx = NewConstantListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, DorisParserRULE_constantList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5240) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5241) + + var _x = p.Constant() + + localctx.(*ConstantListContext)._constant = _x + } + localctx.(*ConstantListContext).values = append(localctx.(*ConstantListContext).values, localctx.(*ConstantListContext)._constant) + p.SetState(5246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5242) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5243) + + var _x = p.Constant() + + localctx.(*ConstantListContext)._constant = _x + } + localctx.(*ConstantListContext).values = append(localctx.(*ConstantListContext).values, localctx.(*ConstantListContext)._constant) + + p.SetState(5248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5249) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationHintContext is an interface to support dynamic dispatch. +type IRelationHintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsRelationHintContext differentiates from other interfaces. + IsRelationHintContext() +} + +type RelationHintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationHintContext() *RelationHintContext { + var p = new(RelationHintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relationHint + return p +} + +func InitEmptyRelationHintContext(p *RelationHintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relationHint +} + +func (*RelationHintContext) IsRelationHintContext() {} + +func NewRelationHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationHintContext { + var p = new(RelationHintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_relationHint + + return p +} + +func (s *RelationHintContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationHintContext) CopyAll(ctx *RelationHintContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *RelationHintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type BracketRelationHintContext struct { + RelationHintContext +} + +func NewBracketRelationHintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BracketRelationHintContext { + var p = new(BracketRelationHintContext) + + InitEmptyRelationHintContext(&p.RelationHintContext) + p.parser = parser + p.CopyAll(ctx.(*RelationHintContext)) + + return p +} + +func (s *BracketRelationHintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BracketRelationHintContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *BracketRelationHintContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *BracketRelationHintContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *BracketRelationHintContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *BracketRelationHintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *BracketRelationHintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *BracketRelationHintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBracketRelationHint(s) + } +} + +func (s *BracketRelationHintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBracketRelationHint(s) + } +} + +func (s *BracketRelationHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBracketRelationHint(s) + + default: + return t.VisitChildren(s) + } +} + +type CommentRelationHintContext struct { + RelationHintContext +} + +func NewCommentRelationHintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CommentRelationHintContext { + var p = new(CommentRelationHintContext) + + InitEmptyRelationHintContext(&p.RelationHintContext) + p.parser = parser + p.CopyAll(ctx.(*RelationHintContext)) + + return p +} + +func (s *CommentRelationHintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommentRelationHintContext) HINT_START() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_START, 0) +} + +func (s *CommentRelationHintContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *CommentRelationHintContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CommentRelationHintContext) HINT_END() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_END, 0) +} + +func (s *CommentRelationHintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CommentRelationHintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CommentRelationHintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCommentRelationHint(s) + } +} + +func (s *CommentRelationHintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCommentRelationHint(s) + } +} + +func (s *CommentRelationHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCommentRelationHint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RelationHint() (localctx IRelationHintContext) { + localctx = NewRelationHintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, DorisParserRULE_relationHint) + var _la int + + p.SetState(5273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACKET: + localctx = NewBracketRelationHintContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5251) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5252) + p.Identifier() + } + p.SetState(5257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5253) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5254) + p.Identifier() + } + + p.SetState(5259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5260) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserHINT_START: + localctx = NewCommentRelationHintContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5262) + p.Match(DorisParserHINT_START) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5263) + p.Identifier() + } + p.SetState(5268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5264) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5265) + p.Identifier() + } + + p.SetState(5270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5271) + p.Match(DorisParserHINT_END) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionWithOrderContext is an interface to support dynamic dispatch. +type IExpressionWithOrderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOrdering returns the ordering token. + GetOrdering() antlr.Token + + // SetOrdering sets the ordering token. + SetOrdering(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsExpressionWithOrderContext differentiates from other interfaces. + IsExpressionWithOrderContext() +} + +type ExpressionWithOrderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ordering antlr.Token +} + +func NewEmptyExpressionWithOrderContext() *ExpressionWithOrderContext { + var p = new(ExpressionWithOrderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_expressionWithOrder + return p +} + +func InitEmptyExpressionWithOrderContext(p *ExpressionWithOrderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_expressionWithOrder +} + +func (*ExpressionWithOrderContext) IsExpressionWithOrderContext() {} + +func NewExpressionWithOrderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionWithOrderContext { + var p = new(ExpressionWithOrderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_expressionWithOrder + + return p +} + +func (s *ExpressionWithOrderContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionWithOrderContext) GetOrdering() antlr.Token { return s.ordering } + +func (s *ExpressionWithOrderContext) SetOrdering(v antlr.Token) { s.ordering = v } + +func (s *ExpressionWithOrderContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionWithOrderContext) ASC() antlr.TerminalNode { + return s.GetToken(DorisParserASC, 0) +} + +func (s *ExpressionWithOrderContext) DESC() antlr.TerminalNode { + return s.GetToken(DorisParserDESC, 0) +} + +func (s *ExpressionWithOrderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionWithOrderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionWithOrderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExpressionWithOrder(s) + } +} + +func (s *ExpressionWithOrderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExpressionWithOrder(s) + } +} + +func (s *ExpressionWithOrderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExpressionWithOrder(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ExpressionWithOrder() (localctx IExpressionWithOrderContext) { + localctx = NewExpressionWithOrderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, DorisParserRULE_expressionWithOrder) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5275) + p.Expression() + } + p.SetState(5277) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 747, p.GetParserRuleContext()) == 1 { + { + p.SetState(5276) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExpressionWithOrderContext).ordering = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserASC || _la == DorisParserDESC) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExpressionWithOrderContext).ordering = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggClauseContext is an interface to support dynamic dispatch. +type IAggClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + BY() antlr.TerminalNode + GroupingElement() IGroupingElementContext + + // IsAggClauseContext differentiates from other interfaces. + IsAggClauseContext() +} + +type AggClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggClauseContext() *AggClauseContext { + var p = new(AggClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_aggClause + return p +} + +func InitEmptyAggClauseContext(p *AggClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_aggClause +} + +func (*AggClauseContext) IsAggClauseContext() {} + +func NewAggClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggClauseContext { + var p = new(AggClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_aggClause + + return p +} + +func (s *AggClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *AggClauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP, 0) +} + +func (s *AggClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *AggClauseContext) GroupingElement() IGroupingElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroupingElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroupingElementContext) +} + +func (s *AggClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AggClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AggClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAggClause(s) + } +} + +func (s *AggClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAggClause(s) + } +} + +func (s *AggClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAggClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AggClause() (localctx IAggClauseContext) { + localctx = NewAggClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, DorisParserRULE_aggClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5279) + p.Match(DorisParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5280) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5281) + p.GroupingElement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroupingElementContext is an interface to support dynamic dispatch. +type IGroupingElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLUP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CUBE() antlr.TerminalNode + GROUPING() antlr.TerminalNode + SETS() antlr.TerminalNode + AllGroupingSet() []IGroupingSetContext + GroupingSet(i int) IGroupingSetContext + AllExpressionWithOrder() []IExpressionWithOrderContext + ExpressionWithOrder(i int) IExpressionWithOrderContext + WITH() antlr.TerminalNode + + // IsGroupingElementContext differentiates from other interfaces. + IsGroupingElementContext() +} + +type GroupingElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroupingElementContext() *GroupingElementContext { + var p = new(GroupingElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_groupingElement + return p +} + +func InitEmptyGroupingElementContext(p *GroupingElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_groupingElement +} + +func (*GroupingElementContext) IsGroupingElementContext() {} + +func NewGroupingElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupingElementContext { + var p = new(GroupingElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_groupingElement + + return p +} + +func (s *GroupingElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *GroupingElementContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *GroupingElementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *GroupingElementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *GroupingElementContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *GroupingElementContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *GroupingElementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *GroupingElementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *GroupingElementContext) CUBE() antlr.TerminalNode { + return s.GetToken(DorisParserCUBE, 0) +} + +func (s *GroupingElementContext) GROUPING() antlr.TerminalNode { + return s.GetToken(DorisParserGROUPING, 0) +} + +func (s *GroupingElementContext) SETS() antlr.TerminalNode { + return s.GetToken(DorisParserSETS, 0) +} + +func (s *GroupingElementContext) AllGroupingSet() []IGroupingSetContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroupingSetContext); ok { + len++ + } + } + + tst := make([]IGroupingSetContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroupingSetContext); ok { + tst[i] = t.(IGroupingSetContext) + i++ + } + } + + return tst +} + +func (s *GroupingElementContext) GroupingSet(i int) IGroupingSetContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroupingSetContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroupingSetContext) +} + +func (s *GroupingElementContext) AllExpressionWithOrder() []IExpressionWithOrderContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionWithOrderContext); ok { + len++ + } + } + + tst := make([]IExpressionWithOrderContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionWithOrderContext); ok { + tst[i] = t.(IExpressionWithOrderContext) + i++ + } + } + + return tst +} + +func (s *GroupingElementContext) ExpressionWithOrder(i int) IExpressionWithOrderContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionWithOrderContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionWithOrderContext) +} + +func (s *GroupingElementContext) WITH() antlr.TerminalNode { + return s.GetToken(DorisParserWITH, 0) +} + +func (s *GroupingElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GroupingElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GroupingElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGroupingElement(s) + } +} + +func (s *GroupingElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGroupingElement(s) + } +} + +func (s *GroupingElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGroupingElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) GroupingElement() (localctx IGroupingElementContext) { + localctx = NewGroupingElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, DorisParserRULE_groupingElement) + var _la int + + var _alt int + + p.SetState(5334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 755, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5283) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5284) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031699) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(5285) + p.Expression() + } + p.SetState(5290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5286) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5287) + p.Expression() + } + + p.SetState(5292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(5295) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5296) + p.Match(DorisParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5297) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031699) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(5298) + p.Expression() + } + p.SetState(5303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5299) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5300) + p.Expression() + } + + p.SetState(5305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(5308) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5309) + p.Match(DorisParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5310) + p.Match(DorisParserSETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5311) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5312) + p.GroupingSet() + } + p.SetState(5317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5313) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5314) + p.GroupingSet() + } + + p.SetState(5319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5320) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5322) + p.ExpressionWithOrder() + } + p.SetState(5327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 753, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5323) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5324) + p.ExpressionWithOrder() + } + + } + p.SetState(5329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 753, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5332) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 754, p.GetParserRuleContext()) == 1 { + { + p.SetState(5330) + p.Match(DorisParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5331) + p.Match(DorisParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroupingSetContext is an interface to support dynamic dispatch. +type IGroupingSetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGroupingSetContext differentiates from other interfaces. + IsGroupingSetContext() +} + +type GroupingSetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroupingSetContext() *GroupingSetContext { + var p = new(GroupingSetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_groupingSet + return p +} + +func InitEmptyGroupingSetContext(p *GroupingSetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_groupingSet +} + +func (*GroupingSetContext) IsGroupingSetContext() {} + +func NewGroupingSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupingSetContext { + var p = new(GroupingSetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_groupingSet + + return p +} + +func (s *GroupingSetContext) GetParser() antlr.Parser { return s.parser } + +func (s *GroupingSetContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *GroupingSetContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *GroupingSetContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *GroupingSetContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *GroupingSetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *GroupingSetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *GroupingSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GroupingSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GroupingSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGroupingSet(s) + } +} + +func (s *GroupingSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGroupingSet(s) + } +} + +func (s *GroupingSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGroupingSet(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) GroupingSet() (localctx IGroupingSetContext) { + localctx = NewGroupingSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, DorisParserRULE_groupingSet) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5336) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031699) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(5337) + p.Expression() + } + p.SetState(5342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5338) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5339) + p.Expression() + } + + p.SetState(5344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(5347) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHavingClauseContext is an interface to support dynamic dispatch. +type IHavingClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HAVING() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + + // IsHavingClauseContext differentiates from other interfaces. + IsHavingClauseContext() +} + +type HavingClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHavingClauseContext() *HavingClauseContext { + var p = new(HavingClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_havingClause + return p +} + +func InitEmptyHavingClauseContext(p *HavingClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_havingClause +} + +func (*HavingClauseContext) IsHavingClauseContext() {} + +func NewHavingClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HavingClauseContext { + var p = new(HavingClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_havingClause + + return p +} + +func (s *HavingClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *HavingClauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(DorisParserHAVING, 0) +} + +func (s *HavingClauseContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *HavingClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HavingClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HavingClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterHavingClause(s) + } +} + +func (s *HavingClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitHavingClause(s) + } +} + +func (s *HavingClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitHavingClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) HavingClause() (localctx IHavingClauseContext) { + localctx = NewHavingClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, DorisParserRULE_havingClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5349) + p.Match(DorisParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5350) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualifyClauseContext is an interface to support dynamic dispatch. +type IQualifyClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUALIFY() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + + // IsQualifyClauseContext differentiates from other interfaces. + IsQualifyClauseContext() +} + +type QualifyClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualifyClauseContext() *QualifyClauseContext { + var p = new(QualifyClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_qualifyClause + return p +} + +func InitEmptyQualifyClauseContext(p *QualifyClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_qualifyClause +} + +func (*QualifyClauseContext) IsQualifyClauseContext() {} + +func NewQualifyClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QualifyClauseContext { + var p = new(QualifyClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_qualifyClause + + return p +} + +func (s *QualifyClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *QualifyClauseContext) QUALIFY() antlr.TerminalNode { + return s.GetToken(DorisParserQUALIFY, 0) +} + +func (s *QualifyClauseContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *QualifyClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QualifyClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QualifyClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQualifyClause(s) + } +} + +func (s *QualifyClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQualifyClause(s) + } +} + +func (s *QualifyClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQualifyClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QualifyClause() (localctx IQualifyClauseContext) { + localctx = NewQualifyClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, DorisParserRULE_qualifyClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5352) + p.Match(DorisParserQUALIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5353) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectHintContext is an interface to support dynamic dispatch. +type ISelectHintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_hintStatement returns the _hintStatement rule contexts. + Get_hintStatement() IHintStatementContext + + // Set_hintStatement sets the _hintStatement rule contexts. + Set_hintStatement(IHintStatementContext) + + // GetHintStatements returns the hintStatements rule context list. + GetHintStatements() []IHintStatementContext + + // SetHintStatements sets the hintStatements rule context list. + SetHintStatements([]IHintStatementContext) + + // Getter signatures + HINT_END() antlr.TerminalNode + AllHintStatement() []IHintStatementContext + HintStatement(i int) IHintStatementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSelectHintContext differentiates from other interfaces. + IsSelectHintContext() +} + +type SelectHintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _hintStatement IHintStatementContext + hintStatements []IHintStatementContext +} + +func NewEmptySelectHintContext() *SelectHintContext { + var p = new(SelectHintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_selectHint + return p +} + +func InitEmptySelectHintContext(p *SelectHintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_selectHint +} + +func (*SelectHintContext) IsSelectHintContext() {} + +func NewSelectHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectHintContext { + var p = new(SelectHintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_selectHint + + return p +} + +func (s *SelectHintContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectHintContext) Get_hintStatement() IHintStatementContext { return s._hintStatement } + +func (s *SelectHintContext) Set_hintStatement(v IHintStatementContext) { s._hintStatement = v } + +func (s *SelectHintContext) GetHintStatements() []IHintStatementContext { return s.hintStatements } + +func (s *SelectHintContext) SetHintStatements(v []IHintStatementContext) { s.hintStatements = v } + +func (s *SelectHintContext) HINT_END() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_END, 0) +} + +func (s *SelectHintContext) AllHintStatement() []IHintStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHintStatementContext); ok { + len++ + } + } + + tst := make([]IHintStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHintStatementContext); ok { + tst[i] = t.(IHintStatementContext) + i++ + } + } + + return tst +} + +func (s *SelectHintContext) HintStatement(i int) IHintStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHintStatementContext) +} + +func (s *SelectHintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *SelectHintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *SelectHintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectHintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSelectHint(s) + } +} + +func (s *SelectHintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSelectHint(s) + } +} + +func (s *SelectHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSelectHint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SelectHint() (localctx ISelectHintContext) { + localctx = NewSelectHintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, DorisParserRULE_selectHint) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5355) + + var _x = p.HintStatement() + + localctx.(*SelectHintContext)._hintStatement = _x + } + localctx.(*SelectHintContext).hintStatements = append(localctx.(*SelectHintContext).hintStatements, localctx.(*SelectHintContext)._hintStatement) + p.SetState(5362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMA { + { + p.SetState(5356) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5359) + + var _x = p.HintStatement() + + localctx.(*SelectHintContext)._hintStatement = _x + } + localctx.(*SelectHintContext).hintStatements = append(localctx.(*SelectHintContext).hintStatements, localctx.(*SelectHintContext)._hintStatement) + + } + p.SetState(5364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(5365) + p.Match(DorisParserHINT_END) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHintStatementContext is an interface to support dynamic dispatch. +type IHintStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_hintAssignment returns the _hintAssignment rule contexts. + Get_hintAssignment() IHintAssignmentContext + + // Get_multipartIdentifier returns the _multipartIdentifier rule contexts. + Get_multipartIdentifier() IMultipartIdentifierContext + + // Set_hintAssignment sets the _hintAssignment rule contexts. + Set_hintAssignment(IHintAssignmentContext) + + // Set_multipartIdentifier sets the _multipartIdentifier rule contexts. + Set_multipartIdentifier(IMultipartIdentifierContext) + + // GetParameters returns the parameters rule context list. + GetParameters() []IHintAssignmentContext + + // GetTableList returns the tableList rule context list. + GetTableList() []IMultipartIdentifierContext + + // SetParameters sets the parameters rule context list. + SetParameters([]IHintAssignmentContext) + + // SetTableList sets the tableList rule context list. + SetTableList([]IMultipartIdentifierContext) + + // Getter signatures + HintName() IHintNameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllHintAssignment() []IHintAssignmentContext + HintAssignment(i int) IHintAssignmentContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + USE_MV() antlr.TerminalNode + NO_USE_MV() antlr.TerminalNode + AllMultipartIdentifier() []IMultipartIdentifierContext + MultipartIdentifier(i int) IMultipartIdentifierContext + + // IsHintStatementContext differentiates from other interfaces. + IsHintStatementContext() +} + +type HintStatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _hintAssignment IHintAssignmentContext + parameters []IHintAssignmentContext + _multipartIdentifier IMultipartIdentifierContext + tableList []IMultipartIdentifierContext +} + +func NewEmptyHintStatementContext() *HintStatementContext { + var p = new(HintStatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_hintStatement + return p +} + +func InitEmptyHintStatementContext(p *HintStatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_hintStatement +} + +func (*HintStatementContext) IsHintStatementContext() {} + +func NewHintStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HintStatementContext { + var p = new(HintStatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_hintStatement + + return p +} + +func (s *HintStatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *HintStatementContext) Get_hintAssignment() IHintAssignmentContext { return s._hintAssignment } + +func (s *HintStatementContext) Get_multipartIdentifier() IMultipartIdentifierContext { + return s._multipartIdentifier +} + +func (s *HintStatementContext) Set_hintAssignment(v IHintAssignmentContext) { s._hintAssignment = v } + +func (s *HintStatementContext) Set_multipartIdentifier(v IMultipartIdentifierContext) { + s._multipartIdentifier = v +} + +func (s *HintStatementContext) GetParameters() []IHintAssignmentContext { return s.parameters } + +func (s *HintStatementContext) GetTableList() []IMultipartIdentifierContext { return s.tableList } + +func (s *HintStatementContext) SetParameters(v []IHintAssignmentContext) { s.parameters = v } + +func (s *HintStatementContext) SetTableList(v []IMultipartIdentifierContext) { s.tableList = v } + +func (s *HintStatementContext) HintName() IHintNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHintNameContext) +} + +func (s *HintStatementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *HintStatementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *HintStatementContext) AllHintAssignment() []IHintAssignmentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHintAssignmentContext); ok { + len++ + } + } + + tst := make([]IHintAssignmentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHintAssignmentContext); ok { + tst[i] = t.(IHintAssignmentContext) + i++ + } + } + + return tst +} + +func (s *HintStatementContext) HintAssignment(i int) IHintAssignmentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHintAssignmentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHintAssignmentContext) +} + +func (s *HintStatementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *HintStatementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *HintStatementContext) USE_MV() antlr.TerminalNode { + return s.GetToken(DorisParserUSE_MV, 0) +} + +func (s *HintStatementContext) NO_USE_MV() antlr.TerminalNode { + return s.GetToken(DorisParserNO_USE_MV, 0) +} + +func (s *HintStatementContext) AllMultipartIdentifier() []IMultipartIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + len++ + } + } + + tst := make([]IMultipartIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMultipartIdentifierContext); ok { + tst[i] = t.(IMultipartIdentifierContext) + i++ + } + } + + return tst +} + +func (s *HintStatementContext) MultipartIdentifier(i int) IMultipartIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *HintStatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HintStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HintStatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterHintStatement(s) + } +} + +func (s *HintStatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitHintStatement(s) + } +} + +func (s *HintStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitHintStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) HintStatement() (localctx IHintStatementContext) { + localctx = NewHintStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, DorisParserRULE_hintStatement) + var _la int + + p.SetState(5397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLEADING, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5367) + p.HintName() + } + p.SetState(5381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5368) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5369) + + var _x = p.HintAssignment() + + localctx.(*HintStatementContext)._hintAssignment = _x + } + localctx.(*HintStatementContext).parameters = append(localctx.(*HintStatementContext).parameters, localctx.(*HintStatementContext)._hintAssignment) + p.SetState(5376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-4)) & ^0x3f) == 0 && ((int64(1)<<(_la-4))&4322327126080025193) != 0) || ((int64((_la-69)) & ^0x3f) == 0 && ((int64(1)<<(_la-69))&-7097885098489431201) != 0) || ((int64((_la-134)) & ^0x3f) == 0 && ((int64(1)<<(_la-134))&-4539834316552092039) != 0) || ((int64((_la-200)) & ^0x3f) == 0 && ((int64(1)<<(_la-200))&5115491203159095925) != 0) || ((int64((_la-265)) & ^0x3f) == 0 && ((int64(1)<<(_la-265))&7779928739494743245) != 0) || ((int64((_la-329)) & ^0x3f) == 0 && ((int64(1)<<(_la-329))&-1080876559247687429) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605691481683905) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1183912064503058687) != 0) { + p.SetState(5371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMA { + { + p.SetState(5370) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5373) + + var _x = p.HintAssignment() + + localctx.(*HintStatementContext)._hintAssignment = _x + } + localctx.(*HintStatementContext).parameters = append(localctx.(*HintStatementContext).parameters, localctx.(*HintStatementContext)._hintAssignment) + + p.SetState(5378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5379) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case DorisParserNO_USE_MV, DorisParserUSE_MV: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5383) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserNO_USE_MV || _la == DorisParserUSE_MV) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5384) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5385) + + var _x = p.MultipartIdentifier() + + localctx.(*HintStatementContext)._multipartIdentifier = _x + } + localctx.(*HintStatementContext).tableList = append(localctx.(*HintStatementContext).tableList, localctx.(*HintStatementContext)._multipartIdentifier) + p.SetState(5390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5386) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5387) + + var _x = p.MultipartIdentifier() + + localctx.(*HintStatementContext)._multipartIdentifier = _x + } + localctx.(*HintStatementContext).tableList = append(localctx.(*HintStatementContext).tableList, localctx.(*HintStatementContext)._multipartIdentifier) + + p.SetState(5392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5393) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHintNameContext is an interface to support dynamic dispatch. +type IHintNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + LEADING() antlr.TerminalNode + + // IsHintNameContext differentiates from other interfaces. + IsHintNameContext() +} + +type HintNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHintNameContext() *HintNameContext { + var p = new(HintNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_hintName + return p +} + +func InitEmptyHintNameContext(p *HintNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_hintName +} + +func (*HintNameContext) IsHintNameContext() {} + +func NewHintNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HintNameContext { + var p = new(HintNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_hintName + + return p +} + +func (s *HintNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *HintNameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *HintNameContext) LEADING() antlr.TerminalNode { + return s.GetToken(DorisParserLEADING, 0) +} + +func (s *HintNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HintNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HintNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterHintName(s) + } +} + +func (s *HintNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitHintName(s) + } +} + +func (s *HintNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitHintName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) HintName() (localctx IHintNameContext) { + localctx = NewHintNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, DorisParserRULE_hintName) + p.SetState(5401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5399) + p.Identifier() + } + + case DorisParserLEADING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5400) + p.Match(DorisParserLEADING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHintAssignmentContext is an interface to support dynamic dispatch. +type IHintAssignmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey returns the key rule contexts. + GetKey() IIdentifierOrTextContext + + // GetSkew returns the skew rule contexts. + GetSkew() ISkewHintContext + + // GetConstantValue returns the constantValue rule contexts. + GetConstantValue() IConstantContext + + // GetIdentifierValue returns the identifierValue rule contexts. + GetIdentifierValue() IIdentifierContext + + // SetKey sets the key rule contexts. + SetKey(IIdentifierOrTextContext) + + // SetSkew sets the skew rule contexts. + SetSkew(ISkewHintContext) + + // SetConstantValue sets the constantValue rule contexts. + SetConstantValue(IConstantContext) + + // SetIdentifierValue sets the identifierValue rule contexts. + SetIdentifierValue(IIdentifierContext) + + // Getter signatures + IdentifierOrText() IIdentifierOrTextContext + EQ() antlr.TerminalNode + SkewHint() ISkewHintContext + Constant() IConstantContext + Identifier() IIdentifierContext + + // IsHintAssignmentContext differentiates from other interfaces. + IsHintAssignmentContext() +} + +type HintAssignmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key IIdentifierOrTextContext + skew ISkewHintContext + constantValue IConstantContext + identifierValue IIdentifierContext +} + +func NewEmptyHintAssignmentContext() *HintAssignmentContext { + var p = new(HintAssignmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_hintAssignment + return p +} + +func InitEmptyHintAssignmentContext(p *HintAssignmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_hintAssignment +} + +func (*HintAssignmentContext) IsHintAssignmentContext() {} + +func NewHintAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HintAssignmentContext { + var p = new(HintAssignmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_hintAssignment + + return p +} + +func (s *HintAssignmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *HintAssignmentContext) GetKey() IIdentifierOrTextContext { return s.key } + +func (s *HintAssignmentContext) GetSkew() ISkewHintContext { return s.skew } + +func (s *HintAssignmentContext) GetConstantValue() IConstantContext { return s.constantValue } + +func (s *HintAssignmentContext) GetIdentifierValue() IIdentifierContext { return s.identifierValue } + +func (s *HintAssignmentContext) SetKey(v IIdentifierOrTextContext) { s.key = v } + +func (s *HintAssignmentContext) SetSkew(v ISkewHintContext) { s.skew = v } + +func (s *HintAssignmentContext) SetConstantValue(v IConstantContext) { s.constantValue = v } + +func (s *HintAssignmentContext) SetIdentifierValue(v IIdentifierContext) { s.identifierValue = v } + +func (s *HintAssignmentContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *HintAssignmentContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *HintAssignmentContext) SkewHint() ISkewHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISkewHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISkewHintContext) +} + +func (s *HintAssignmentContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *HintAssignmentContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *HintAssignmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HintAssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HintAssignmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterHintAssignment(s) + } +} + +func (s *HintAssignmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitHintAssignment(s) + } +} + +func (s *HintAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitHintAssignment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) HintAssignment() (localctx IHintAssignmentContext) { + localctx = NewHintAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, DorisParserRULE_hintAssignment) + var _la int + + p.SetState(5415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 770, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5403) + + var _x = p.IdentifierOrText() + + localctx.(*HintAssignmentContext).key = _x + } + p.SetState(5405) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 767, p.GetParserRuleContext()) == 1 { + { + p.SetState(5404) + + var _x = p.SkewHint() + + localctx.(*HintAssignmentContext).skew = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserEQ { + { + p.SetState(5407) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 768, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5408) + + var _x = p.Constant() + + localctx.(*HintAssignmentContext).constantValue = _x + } + + case 2: + { + p.SetState(5409) + + var _x = p.Identifier() + + localctx.(*HintAssignmentContext).identifierValue = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5414) + p.Constant() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdateAssignmentContext is an interface to support dynamic dispatch. +type IUpdateAssignmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCol returns the col rule contexts. + GetCol() IMultipartIdentifierContext + + // SetCol sets the col rule contexts. + SetCol(IMultipartIdentifierContext) + + // Getter signatures + EQ() antlr.TerminalNode + MultipartIdentifier() IMultipartIdentifierContext + Expression() IExpressionContext + DEFAULT() antlr.TerminalNode + + // IsUpdateAssignmentContext differentiates from other interfaces. + IsUpdateAssignmentContext() +} + +type UpdateAssignmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + col IMultipartIdentifierContext +} + +func NewEmptyUpdateAssignmentContext() *UpdateAssignmentContext { + var p = new(UpdateAssignmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_updateAssignment + return p +} + +func InitEmptyUpdateAssignmentContext(p *UpdateAssignmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_updateAssignment +} + +func (*UpdateAssignmentContext) IsUpdateAssignmentContext() {} + +func NewUpdateAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateAssignmentContext { + var p = new(UpdateAssignmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_updateAssignment + + return p +} + +func (s *UpdateAssignmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *UpdateAssignmentContext) GetCol() IMultipartIdentifierContext { return s.col } + +func (s *UpdateAssignmentContext) SetCol(v IMultipartIdentifierContext) { s.col = v } + +func (s *UpdateAssignmentContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *UpdateAssignmentContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *UpdateAssignmentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *UpdateAssignmentContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *UpdateAssignmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdateAssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UpdateAssignmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUpdateAssignment(s) + } +} + +func (s *UpdateAssignmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUpdateAssignment(s) + } +} + +func (s *UpdateAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUpdateAssignment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) UpdateAssignment() (localctx IUpdateAssignmentContext) { + localctx = NewUpdateAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, DorisParserRULE_updateAssignment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5417) + + var _x = p.MultipartIdentifier() + + localctx.(*UpdateAssignmentContext).col = _x + } + { + p.SetState(5418) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_PAREN, DorisParserLEFT_BRACKET, DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserADD, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBINARY, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCASE, DorisParserCAST, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATABASE, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXISTS, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserEXTRACT, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFALSE, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIF, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINTERVAL, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserKEY, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLEFT, DorisParserLESS, DorisParserLEVEL, DorisParserLIKE, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNOT, DorisParserNULL, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLACEHOLDER, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREGEXP, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRIGHT, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRIM, DorisParserTRUE, DorisParserTRUNCATE, DorisParserTRY_CAST, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserPLUS, DorisParserSUBTRACT, DorisParserASTERISK, DorisParserTILDE, DorisParserLOGICALNOT, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserATSIGN, DorisParserDOUBLEATSIGN, DorisParserSTRING_LITERAL, DorisParserVARBINARY_LITERAL, DorisParserINTEGER_VALUE, DorisParserEXPONENT_VALUE, DorisParserDECIMAL_VALUE, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(5419) + p.Expression() + } + + case DorisParserDEFAULT: + { + p.SetState(5420) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdateAssignmentSeqContext is an interface to support dynamic dispatch. +type IUpdateAssignmentSeqContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_updateAssignment returns the _updateAssignment rule contexts. + Get_updateAssignment() IUpdateAssignmentContext + + // Set_updateAssignment sets the _updateAssignment rule contexts. + Set_updateAssignment(IUpdateAssignmentContext) + + // GetAssignments returns the assignments rule context list. + GetAssignments() []IUpdateAssignmentContext + + // SetAssignments sets the assignments rule context list. + SetAssignments([]IUpdateAssignmentContext) + + // Getter signatures + AllUpdateAssignment() []IUpdateAssignmentContext + UpdateAssignment(i int) IUpdateAssignmentContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUpdateAssignmentSeqContext differentiates from other interfaces. + IsUpdateAssignmentSeqContext() +} + +type UpdateAssignmentSeqContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _updateAssignment IUpdateAssignmentContext + assignments []IUpdateAssignmentContext +} + +func NewEmptyUpdateAssignmentSeqContext() *UpdateAssignmentSeqContext { + var p = new(UpdateAssignmentSeqContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_updateAssignmentSeq + return p +} + +func InitEmptyUpdateAssignmentSeqContext(p *UpdateAssignmentSeqContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_updateAssignmentSeq +} + +func (*UpdateAssignmentSeqContext) IsUpdateAssignmentSeqContext() {} + +func NewUpdateAssignmentSeqContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateAssignmentSeqContext { + var p = new(UpdateAssignmentSeqContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_updateAssignmentSeq + + return p +} + +func (s *UpdateAssignmentSeqContext) GetParser() antlr.Parser { return s.parser } + +func (s *UpdateAssignmentSeqContext) Get_updateAssignment() IUpdateAssignmentContext { + return s._updateAssignment +} + +func (s *UpdateAssignmentSeqContext) Set_updateAssignment(v IUpdateAssignmentContext) { + s._updateAssignment = v +} + +func (s *UpdateAssignmentSeqContext) GetAssignments() []IUpdateAssignmentContext { + return s.assignments +} + +func (s *UpdateAssignmentSeqContext) SetAssignments(v []IUpdateAssignmentContext) { s.assignments = v } + +func (s *UpdateAssignmentSeqContext) AllUpdateAssignment() []IUpdateAssignmentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdateAssignmentContext); ok { + len++ + } + } + + tst := make([]IUpdateAssignmentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdateAssignmentContext); ok { + tst[i] = t.(IUpdateAssignmentContext) + i++ + } + } + + return tst +} + +func (s *UpdateAssignmentSeqContext) UpdateAssignment(i int) IUpdateAssignmentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdateAssignmentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdateAssignmentContext) +} + +func (s *UpdateAssignmentSeqContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *UpdateAssignmentSeqContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *UpdateAssignmentSeqContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdateAssignmentSeqContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UpdateAssignmentSeqContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUpdateAssignmentSeq(s) + } +} + +func (s *UpdateAssignmentSeqContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUpdateAssignmentSeq(s) + } +} + +func (s *UpdateAssignmentSeqContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUpdateAssignmentSeq(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) UpdateAssignmentSeq() (localctx IUpdateAssignmentSeqContext) { + localctx = NewUpdateAssignmentSeqContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, DorisParserRULE_updateAssignmentSeq) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5423) + + var _x = p.UpdateAssignment() + + localctx.(*UpdateAssignmentSeqContext)._updateAssignment = _x + } + localctx.(*UpdateAssignmentSeqContext).assignments = append(localctx.(*UpdateAssignmentSeqContext).assignments, localctx.(*UpdateAssignmentSeqContext)._updateAssignment) + p.SetState(5428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5424) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5425) + + var _x = p.UpdateAssignment() + + localctx.(*UpdateAssignmentSeqContext)._updateAssignment = _x + } + localctx.(*UpdateAssignmentSeqContext).assignments = append(localctx.(*UpdateAssignmentSeqContext).assignments, localctx.(*UpdateAssignmentSeqContext)._updateAssignment) + + p.SetState(5430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILateralViewContext is an interface to support dynamic dispatch. +type ILateralViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFunctionName returns the functionName rule contexts. + GetFunctionName() IIdentifierContext + + // GetTableName returns the tableName rule contexts. + GetTableName() IIdentifierContext + + // Get_identifier returns the _identifier rule contexts. + Get_identifier() IIdentifierContext + + // SetFunctionName sets the functionName rule contexts. + SetFunctionName(IIdentifierContext) + + // SetTableName sets the tableName rule contexts. + SetTableName(IIdentifierContext) + + // Set_identifier sets the _identifier rule contexts. + Set_identifier(IIdentifierContext) + + // GetColumnNames returns the columnNames rule context list. + GetColumnNames() []IIdentifierContext + + // SetColumnNames sets the columnNames rule context list. + SetColumnNames([]IIdentifierContext) + + // Getter signatures + LATERAL() antlr.TerminalNode + VIEW() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AS() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLateralViewContext differentiates from other interfaces. + IsLateralViewContext() +} + +type LateralViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + functionName IIdentifierContext + tableName IIdentifierContext + _identifier IIdentifierContext + columnNames []IIdentifierContext +} + +func NewEmptyLateralViewContext() *LateralViewContext { + var p = new(LateralViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lateralView + return p +} + +func InitEmptyLateralViewContext(p *LateralViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lateralView +} + +func (*LateralViewContext) IsLateralViewContext() {} + +func NewLateralViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LateralViewContext { + var p = new(LateralViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_lateralView + + return p +} + +func (s *LateralViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *LateralViewContext) GetFunctionName() IIdentifierContext { return s.functionName } + +func (s *LateralViewContext) GetTableName() IIdentifierContext { return s.tableName } + +func (s *LateralViewContext) Get_identifier() IIdentifierContext { return s._identifier } + +func (s *LateralViewContext) SetFunctionName(v IIdentifierContext) { s.functionName = v } + +func (s *LateralViewContext) SetTableName(v IIdentifierContext) { s.tableName = v } + +func (s *LateralViewContext) Set_identifier(v IIdentifierContext) { s._identifier = v } + +func (s *LateralViewContext) GetColumnNames() []IIdentifierContext { return s.columnNames } + +func (s *LateralViewContext) SetColumnNames(v []IIdentifierContext) { s.columnNames = v } + +func (s *LateralViewContext) LATERAL() antlr.TerminalNode { + return s.GetToken(DorisParserLATERAL, 0) +} + +func (s *LateralViewContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *LateralViewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *LateralViewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *LateralViewContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *LateralViewContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *LateralViewContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *LateralViewContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *LateralViewContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LateralViewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *LateralViewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *LateralViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LateralViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LateralViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLateralView(s) + } +} + +func (s *LateralViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLateralView(s) + } +} + +func (s *LateralViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLateralView(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) LateralView() (localctx ILateralViewContext) { + localctx = NewLateralViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, DorisParserRULE_lateralView) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5431) + p.Match(DorisParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5432) + p.Match(DorisParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5433) + + var _x = p.Identifier() + + localctx.(*LateralViewContext).functionName = _x + } + { + p.SetState(5434) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031699) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(5435) + p.Expression() + } + p.SetState(5440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5436) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5437) + p.Expression() + } + + p.SetState(5442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(5445) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5446) + + var _x = p.Identifier() + + localctx.(*LateralViewContext).tableName = _x + } + { + p.SetState(5447) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5448) + + var _x = p.Identifier() + + localctx.(*LateralViewContext)._identifier = _x + } + localctx.(*LateralViewContext).columnNames = append(localctx.(*LateralViewContext).columnNames, localctx.(*LateralViewContext)._identifier) + p.SetState(5453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 775, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5449) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5450) + + var _x = p.Identifier() + + localctx.(*LateralViewContext)._identifier = _x + } + localctx.(*LateralViewContext).columnNames = append(localctx.(*LateralViewContext).columnNames, localctx.(*LateralViewContext)._identifier) + + } + p.SetState(5455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 775, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueryOrganizationContext is an interface to support dynamic dispatch. +type IQueryOrganizationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SortClause() ISortClauseContext + LimitClause() ILimitClauseContext + + // IsQueryOrganizationContext differentiates from other interfaces. + IsQueryOrganizationContext() +} + +type QueryOrganizationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueryOrganizationContext() *QueryOrganizationContext { + var p = new(QueryOrganizationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_queryOrganization + return p +} + +func InitEmptyQueryOrganizationContext(p *QueryOrganizationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_queryOrganization +} + +func (*QueryOrganizationContext) IsQueryOrganizationContext() {} + +func NewQueryOrganizationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryOrganizationContext { + var p = new(QueryOrganizationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_queryOrganization + + return p +} + +func (s *QueryOrganizationContext) GetParser() antlr.Parser { return s.parser } + +func (s *QueryOrganizationContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *QueryOrganizationContext) LimitClause() ILimitClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitClauseContext) +} + +func (s *QueryOrganizationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QueryOrganizationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QueryOrganizationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQueryOrganization(s) + } +} + +func (s *QueryOrganizationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQueryOrganization(s) + } +} + +func (s *QueryOrganizationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQueryOrganization(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QueryOrganization() (localctx IQueryOrganizationContext) { + localctx = NewQueryOrganizationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, DorisParserRULE_queryOrganization) + p.EnterOuterAlt(localctx, 1) + p.SetState(5457) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 776, p.GetParserRuleContext()) == 1 { + { + p.SetState(5456) + p.SortClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5460) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 777, p.GetParserRuleContext()) == 1 { + { + p.SetState(5459) + p.LimitClause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISortClauseContext is an interface to support dynamic dispatch. +type ISortClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllSortItem() []ISortItemContext + SortItem(i int) ISortItemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSortClauseContext differentiates from other interfaces. + IsSortClauseContext() +} + +type SortClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySortClauseContext() *SortClauseContext { + var p = new(SortClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sortClause + return p +} + +func InitEmptySortClauseContext(p *SortClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sortClause +} + +func (*SortClauseContext) IsSortClauseContext() {} + +func NewSortClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseContext { + var p = new(SortClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_sortClause + + return p +} + +func (s *SortClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SortClauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(DorisParserORDER, 0) +} + +func (s *SortClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *SortClauseContext) AllSortItem() []ISortItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISortItemContext); ok { + len++ + } + } + + tst := make([]ISortItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISortItemContext); ok { + tst[i] = t.(ISortItemContext) + i++ + } + } + + return tst +} + +func (s *SortClauseContext) SortItem(i int) ISortItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISortItemContext) +} + +func (s *SortClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *SortClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *SortClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SortClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SortClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSortClause(s) + } +} + +func (s *SortClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSortClause(s) + } +} + +func (s *SortClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSortClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SortClause() (localctx ISortClauseContext) { + localctx = NewSortClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, DorisParserRULE_sortClause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5462) + p.Match(DorisParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5463) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5464) + p.SortItem() + } + p.SetState(5469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5465) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5466) + p.SortItem() + } + + } + p.SetState(5471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISortItemContext is an interface to support dynamic dispatch. +type ISortItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOrdering returns the ordering token. + GetOrdering() antlr.Token + + // SetOrdering sets the ordering token. + SetOrdering(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + NULLS() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsSortItemContext differentiates from other interfaces. + IsSortItemContext() +} + +type SortItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ordering antlr.Token +} + +func NewEmptySortItemContext() *SortItemContext { + var p = new(SortItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sortItem + return p +} + +func InitEmptySortItemContext(p *SortItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sortItem +} + +func (*SortItemContext) IsSortItemContext() {} + +func NewSortItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortItemContext { + var p = new(SortItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_sortItem + + return p +} + +func (s *SortItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *SortItemContext) GetOrdering() antlr.Token { return s.ordering } + +func (s *SortItemContext) SetOrdering(v antlr.Token) { s.ordering = v } + +func (s *SortItemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SortItemContext) NULLS() antlr.TerminalNode { + return s.GetToken(DorisParserNULLS, 0) +} + +func (s *SortItemContext) FIRST() antlr.TerminalNode { + return s.GetToken(DorisParserFIRST, 0) +} + +func (s *SortItemContext) LAST() antlr.TerminalNode { + return s.GetToken(DorisParserLAST, 0) +} + +func (s *SortItemContext) ASC() antlr.TerminalNode { + return s.GetToken(DorisParserASC, 0) +} + +func (s *SortItemContext) DESC() antlr.TerminalNode { + return s.GetToken(DorisParserDESC, 0) +} + +func (s *SortItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SortItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SortItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSortItem(s) + } +} + +func (s *SortItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSortItem(s) + } +} + +func (s *SortItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSortItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SortItem() (localctx ISortItemContext) { + localctx = NewSortItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, DorisParserRULE_sortItem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5472) + p.Expression() + } + p.SetState(5474) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 779, p.GetParserRuleContext()) == 1 { + { + p.SetState(5473) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SortItemContext).ordering = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserASC || _la == DorisParserDESC) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SortItemContext).ordering = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5478) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 780, p.GetParserRuleContext()) == 1 { + { + p.SetState(5476) + p.Match(DorisParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5477) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFIRST || _la == DorisParserLAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimitClauseContext is an interface to support dynamic dispatch. +type ILimitClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLimit returns the limit token. + GetLimit() antlr.Token + + // GetOffset returns the offset token. + GetOffset() antlr.Token + + // SetLimit sets the limit token. + SetLimit(antlr.Token) + + // SetOffset sets the offset token. + SetOffset(antlr.Token) + + // Getter signatures + LIMIT() antlr.TerminalNode + AllINTEGER_VALUE() []antlr.TerminalNode + INTEGER_VALUE(i int) antlr.TerminalNode + OFFSET() antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsLimitClauseContext differentiates from other interfaces. + IsLimitClauseContext() +} + +type LimitClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + limit antlr.Token + offset antlr.Token +} + +func NewEmptyLimitClauseContext() *LimitClauseContext { + var p = new(LimitClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_limitClause + return p +} + +func InitEmptyLimitClauseContext(p *LimitClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_limitClause +} + +func (*LimitClauseContext) IsLimitClauseContext() {} + +func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext { + var p = new(LimitClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_limitClause + + return p +} + +func (s *LimitClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *LimitClauseContext) GetLimit() antlr.Token { return s.limit } + +func (s *LimitClauseContext) GetOffset() antlr.Token { return s.offset } + +func (s *LimitClauseContext) SetLimit(v antlr.Token) { s.limit = v } + +func (s *LimitClauseContext) SetOffset(v antlr.Token) { s.offset = v } + +func (s *LimitClauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(DorisParserLIMIT, 0) +} + +func (s *LimitClauseContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *LimitClauseContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *LimitClauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(DorisParserOFFSET, 0) +} + +func (s *LimitClauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLimitClause(s) + } +} + +func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLimitClause(s) + } +} + +func (s *LimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLimitClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) LimitClause() (localctx ILimitClauseContext) { + localctx = NewLimitClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, DorisParserRULE_limitClause) + p.SetState(5490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 781, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5480) + p.Match(DorisParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5481) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*LimitClauseContext).limit = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5482) + p.Match(DorisParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5483) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*LimitClauseContext).limit = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5484) + p.Match(DorisParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5485) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*LimitClauseContext).offset = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5486) + p.Match(DorisParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5487) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*LimitClauseContext).offset = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5488) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5489) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*LimitClauseContext).limit = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionClauseContext is an interface to support dynamic dispatch. +type IPartitionClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + LEFT_BRACKET() antlr.TerminalNode + Identifier() IIdentifierContext + RIGHT_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartitionClauseContext differentiates from other interfaces. + IsPartitionClauseContext() +} + +type PartitionClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionClauseContext() *PartitionClauseContext { + var p = new(PartitionClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionClause + return p +} + +func InitEmptyPartitionClauseContext(p *PartitionClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionClause +} + +func (*PartitionClauseContext) IsPartitionClauseContext() {} + +func NewPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionClauseContext { + var p = new(PartitionClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionClause + + return p +} + +func (s *PartitionClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionClauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *PartitionClauseContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *PartitionClauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PartitionClauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PartitionClauseContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *PartitionClauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PartitionClauseContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *PartitionClauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PartitionClauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PartitionClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionClause(s) + } +} + +func (s *PartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionClause(s) + } +} + +func (s *PartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionClause() (localctx IPartitionClauseContext) { + localctx = NewPartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, DorisParserRULE_partitionClause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5492) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5493) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5498) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 782, p.GetParserRuleContext()) == 1 { + { + p.SetState(5494) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5495) + p.Identifier() + } + { + p.SetState(5496) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5500) + p.Expression() + } + p.SetState(5505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5501) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5502) + p.Expression() + } + + p.SetState(5507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoinTypeContext is an interface to support dynamic dispatch. +type IJoinTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INNER() antlr.TerminalNode + CROSS() antlr.TerminalNode + LEFT() antlr.TerminalNode + OUTER() antlr.TerminalNode + RIGHT() antlr.TerminalNode + FULL() antlr.TerminalNode + SEMI() antlr.TerminalNode + ANTI() antlr.TerminalNode + + // IsJoinTypeContext differentiates from other interfaces. + IsJoinTypeContext() +} + +type JoinTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoinTypeContext() *JoinTypeContext { + var p = new(JoinTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_joinType + return p +} + +func InitEmptyJoinTypeContext(p *JoinTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_joinType +} + +func (*JoinTypeContext) IsJoinTypeContext() {} + +func NewJoinTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinTypeContext { + var p = new(JoinTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_joinType + + return p +} + +func (s *JoinTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *JoinTypeContext) INNER() antlr.TerminalNode { + return s.GetToken(DorisParserINNER, 0) +} + +func (s *JoinTypeContext) CROSS() antlr.TerminalNode { + return s.GetToken(DorisParserCROSS, 0) +} + +func (s *JoinTypeContext) LEFT() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT, 0) +} + +func (s *JoinTypeContext) OUTER() antlr.TerminalNode { + return s.GetToken(DorisParserOUTER, 0) +} + +func (s *JoinTypeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT, 0) +} + +func (s *JoinTypeContext) FULL() antlr.TerminalNode { + return s.GetToken(DorisParserFULL, 0) +} + +func (s *JoinTypeContext) SEMI() antlr.TerminalNode { + return s.GetToken(DorisParserSEMI, 0) +} + +func (s *JoinTypeContext) ANTI() antlr.TerminalNode { + return s.GetToken(DorisParserANTI, 0) +} + +func (s *JoinTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JoinTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JoinTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterJoinType(s) + } +} + +func (s *JoinTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitJoinType(s) + } +} + +func (s *JoinTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitJoinType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) JoinType() (localctx IJoinTypeContext) { + localctx = NewJoinTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, DorisParserRULE_joinType) + var _la int + + p.SetState(5532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 788, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINNER { + { + p.SetState(5508) + p.Match(DorisParserINNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5511) + p.Match(DorisParserCROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5512) + p.Match(DorisParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserOUTER { + { + p.SetState(5513) + p.Match(DorisParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5516) + p.Match(DorisParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserOUTER { + { + p.SetState(5517) + p.Match(DorisParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5520) + p.Match(DorisParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserOUTER { + { + p.SetState(5521) + p.Match(DorisParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5524) + p.Match(DorisParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5525) + p.Match(DorisParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5526) + p.Match(DorisParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5527) + p.Match(DorisParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5528) + p.Match(DorisParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5529) + p.Match(DorisParserANTI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5530) + p.Match(DorisParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5531) + p.Match(DorisParserANTI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoinCriteriaContext is an interface to support dynamic dispatch. +type IJoinCriteriaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + BooleanExpression() IBooleanExpressionContext + USING() antlr.TerminalNode + IdentifierList() IIdentifierListContext + + // IsJoinCriteriaContext differentiates from other interfaces. + IsJoinCriteriaContext() +} + +type JoinCriteriaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoinCriteriaContext() *JoinCriteriaContext { + var p = new(JoinCriteriaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_joinCriteria + return p +} + +func InitEmptyJoinCriteriaContext(p *JoinCriteriaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_joinCriteria +} + +func (*JoinCriteriaContext) IsJoinCriteriaContext() {} + +func NewJoinCriteriaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinCriteriaContext { + var p = new(JoinCriteriaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_joinCriteria + + return p +} + +func (s *JoinCriteriaContext) GetParser() antlr.Parser { return s.parser } + +func (s *JoinCriteriaContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *JoinCriteriaContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *JoinCriteriaContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *JoinCriteriaContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *JoinCriteriaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JoinCriteriaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *JoinCriteriaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterJoinCriteria(s) + } +} + +func (s *JoinCriteriaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitJoinCriteria(s) + } +} + +func (s *JoinCriteriaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitJoinCriteria(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) JoinCriteria() (localctx IJoinCriteriaContext) { + localctx = NewJoinCriteriaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, DorisParserRULE_joinCriteria) + p.SetState(5538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserON: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5534) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5535) + p.booleanExpression(0) + } + + case DorisParserUSING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5536) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5537) + p.IdentifierList() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierListContext is an interface to support dynamic dispatch. +type IIdentifierListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + IdentifierSeq() IIdentifierSeqContext + RIGHT_PAREN() antlr.TerminalNode + + // IsIdentifierListContext differentiates from other interfaces. + IsIdentifierListContext() +} + +type IdentifierListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierListContext() *IdentifierListContext { + var p = new(IdentifierListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierList + return p +} + +func InitEmptyIdentifierListContext(p *IdentifierListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierList +} + +func (*IdentifierListContext) IsIdentifierListContext() {} + +func NewIdentifierListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierListContext { + var p = new(IdentifierListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identifierList + + return p +} + +func (s *IdentifierListContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *IdentifierListContext) IdentifierSeq() IIdentifierSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierSeqContext) +} + +func (s *IdentifierListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *IdentifierListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentifierList(s) + } +} + +func (s *IdentifierListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentifierList(s) + } +} + +func (s *IdentifierListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentifierList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentifierList() (localctx IIdentifierListContext) { + localctx = NewIdentifierListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, DorisParserRULE_identifierList) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5540) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5541) + p.IdentifierSeq() + } + { + p.SetState(5542) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierSeqContext is an interface to support dynamic dispatch. +type IIdentifierSeqContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_errorCapturingIdentifier returns the _errorCapturingIdentifier rule contexts. + Get_errorCapturingIdentifier() IErrorCapturingIdentifierContext + + // Set_errorCapturingIdentifier sets the _errorCapturingIdentifier rule contexts. + Set_errorCapturingIdentifier(IErrorCapturingIdentifierContext) + + // GetIdent returns the ident rule context list. + GetIdent() []IErrorCapturingIdentifierContext + + // SetIdent sets the ident rule context list. + SetIdent([]IErrorCapturingIdentifierContext) + + // Getter signatures + AllErrorCapturingIdentifier() []IErrorCapturingIdentifierContext + ErrorCapturingIdentifier(i int) IErrorCapturingIdentifierContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIdentifierSeqContext differentiates from other interfaces. + IsIdentifierSeqContext() +} + +type IdentifierSeqContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _errorCapturingIdentifier IErrorCapturingIdentifierContext + ident []IErrorCapturingIdentifierContext +} + +func NewEmptyIdentifierSeqContext() *IdentifierSeqContext { + var p = new(IdentifierSeqContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierSeq + return p +} + +func InitEmptyIdentifierSeqContext(p *IdentifierSeqContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifierSeq +} + +func (*IdentifierSeqContext) IsIdentifierSeqContext() {} + +func NewIdentifierSeqContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierSeqContext { + var p = new(IdentifierSeqContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identifierSeq + + return p +} + +func (s *IdentifierSeqContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierSeqContext) Get_errorCapturingIdentifier() IErrorCapturingIdentifierContext { + return s._errorCapturingIdentifier +} + +func (s *IdentifierSeqContext) Set_errorCapturingIdentifier(v IErrorCapturingIdentifierContext) { + s._errorCapturingIdentifier = v +} + +func (s *IdentifierSeqContext) GetIdent() []IErrorCapturingIdentifierContext { return s.ident } + +func (s *IdentifierSeqContext) SetIdent(v []IErrorCapturingIdentifierContext) { s.ident = v } + +func (s *IdentifierSeqContext) AllErrorCapturingIdentifier() []IErrorCapturingIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + len++ + } + } + + tst := make([]IErrorCapturingIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IErrorCapturingIdentifierContext); ok { + tst[i] = t.(IErrorCapturingIdentifierContext) + i++ + } + } + + return tst +} + +func (s *IdentifierSeqContext) ErrorCapturingIdentifier(i int) IErrorCapturingIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierContext) +} + +func (s *IdentifierSeqContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *IdentifierSeqContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *IdentifierSeqContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierSeqContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierSeqContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentifierSeq(s) + } +} + +func (s *IdentifierSeqContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentifierSeq(s) + } +} + +func (s *IdentifierSeqContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentifierSeq(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IdentifierSeq() (localctx IIdentifierSeqContext) { + localctx = NewIdentifierSeqContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, DorisParserRULE_identifierSeq) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5544) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*IdentifierSeqContext)._errorCapturingIdentifier = _x + } + localctx.(*IdentifierSeqContext).ident = append(localctx.(*IdentifierSeqContext).ident, localctx.(*IdentifierSeqContext)._errorCapturingIdentifier) + p.SetState(5549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5545) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5546) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*IdentifierSeqContext)._errorCapturingIdentifier = _x + } + localctx.(*IdentifierSeqContext).ident = append(localctx.(*IdentifierSeqContext).ident, localctx.(*IdentifierSeqContext)._errorCapturingIdentifier) + + p.SetState(5551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptScanParamsContext is an interface to support dynamic dispatch. +type IOptScanParamsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFuncName returns the funcName rule contexts. + GetFuncName() IIdentifierContext + + // GetMapParams returns the mapParams rule contexts. + GetMapParams() IPropertyItemListContext + + // GetListParams returns the listParams rule contexts. + GetListParams() IIdentifierSeqContext + + // SetFuncName sets the funcName rule contexts. + SetFuncName(IIdentifierContext) + + // SetMapParams sets the mapParams rule contexts. + SetMapParams(IPropertyItemListContext) + + // SetListParams sets the listParams rule contexts. + SetListParams(IIdentifierSeqContext) + + // Getter signatures + ATSIGN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Identifier() IIdentifierContext + PropertyItemList() IPropertyItemListContext + IdentifierSeq() IIdentifierSeqContext + + // IsOptScanParamsContext differentiates from other interfaces. + IsOptScanParamsContext() +} + +type OptScanParamsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + funcName IIdentifierContext + mapParams IPropertyItemListContext + listParams IIdentifierSeqContext +} + +func NewEmptyOptScanParamsContext() *OptScanParamsContext { + var p = new(OptScanParamsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optScanParams + return p +} + +func InitEmptyOptScanParamsContext(p *OptScanParamsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_optScanParams +} + +func (*OptScanParamsContext) IsOptScanParamsContext() {} + +func NewOptScanParamsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptScanParamsContext { + var p = new(OptScanParamsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_optScanParams + + return p +} + +func (s *OptScanParamsContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptScanParamsContext) GetFuncName() IIdentifierContext { return s.funcName } + +func (s *OptScanParamsContext) GetMapParams() IPropertyItemListContext { return s.mapParams } + +func (s *OptScanParamsContext) GetListParams() IIdentifierSeqContext { return s.listParams } + +func (s *OptScanParamsContext) SetFuncName(v IIdentifierContext) { s.funcName = v } + +func (s *OptScanParamsContext) SetMapParams(v IPropertyItemListContext) { s.mapParams = v } + +func (s *OptScanParamsContext) SetListParams(v IIdentifierSeqContext) { s.listParams = v } + +func (s *OptScanParamsContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *OptScanParamsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *OptScanParamsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *OptScanParamsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *OptScanParamsContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *OptScanParamsContext) IdentifierSeq() IIdentifierSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierSeqContext) +} + +func (s *OptScanParamsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptScanParamsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptScanParamsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterOptScanParams(s) + } +} + +func (s *OptScanParamsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitOptScanParams(s) + } +} + +func (s *OptScanParamsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitOptScanParams(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) OptScanParams() (localctx IOptScanParamsContext) { + localctx = NewOptScanParamsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, DorisParserRULE_optScanParams) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5552) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5553) + + var _x = p.Identifier() + + localctx.(*OptScanParamsContext).funcName = _x + } + { + p.SetState(5554) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5557) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 791, p.GetParserRuleContext()) == 1 { + { + p.SetState(5555) + + var _x = p.PropertyItemList() + + localctx.(*OptScanParamsContext).mapParams = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 791, p.GetParserRuleContext()) == 2 { + { + p.SetState(5556) + + var _x = p.IdentifierSeq() + + localctx.(*OptScanParamsContext).listParams = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5559) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationPrimaryContext is an interface to support dynamic dispatch. +type IRelationPrimaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsRelationPrimaryContext differentiates from other interfaces. + IsRelationPrimaryContext() +} + +type RelationPrimaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationPrimaryContext() *RelationPrimaryContext { + var p = new(RelationPrimaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relationPrimary + return p +} + +func InitEmptyRelationPrimaryContext(p *RelationPrimaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_relationPrimary +} + +func (*RelationPrimaryContext) IsRelationPrimaryContext() {} + +func NewRelationPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationPrimaryContext { + var p = new(RelationPrimaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_relationPrimary + + return p +} + +func (s *RelationPrimaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationPrimaryContext) CopyAll(ctx *RelationPrimaryContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *RelationPrimaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationPrimaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type TableValuedFunctionContext struct { + RelationPrimaryContext + tvfName IIdentifierContext + properties IPropertyItemListContext +} + +func NewTableValuedFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableValuedFunctionContext { + var p = new(TableValuedFunctionContext) + + InitEmptyRelationPrimaryContext(&p.RelationPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*RelationPrimaryContext)) + + return p +} + +func (s *TableValuedFunctionContext) GetTvfName() IIdentifierContext { return s.tvfName } + +func (s *TableValuedFunctionContext) GetProperties() IPropertyItemListContext { return s.properties } + +func (s *TableValuedFunctionContext) SetTvfName(v IIdentifierContext) { s.tvfName = v } + +func (s *TableValuedFunctionContext) SetProperties(v IPropertyItemListContext) { s.properties = v } + +func (s *TableValuedFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableValuedFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *TableValuedFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *TableValuedFunctionContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *TableValuedFunctionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *TableValuedFunctionContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *TableValuedFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTableValuedFunction(s) + } +} + +func (s *TableValuedFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTableValuedFunction(s) + } +} + +func (s *TableValuedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTableValuedFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type RelationListContext struct { + RelationPrimaryContext +} + +func NewRelationListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RelationListContext { + var p = new(RelationListContext) + + InitEmptyRelationPrimaryContext(&p.RelationPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*RelationPrimaryContext)) + + return p +} + +func (s *RelationListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *RelationListContext) Relations() IRelationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationsContext) +} + +func (s *RelationListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *RelationListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRelationList(s) + } +} + +func (s *RelationListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRelationList(s) + } +} + +func (s *RelationListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRelationList(s) + + default: + return t.VisitChildren(s) + } +} + +type AliasedQueryContext struct { + RelationPrimaryContext +} + +func NewAliasedQueryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AliasedQueryContext { + var p = new(AliasedQueryContext) + + InitEmptyRelationPrimaryContext(&p.RelationPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*RelationPrimaryContext)) + + return p +} + +func (s *AliasedQueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AliasedQueryContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AliasedQueryContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *AliasedQueryContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AliasedQueryContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *AliasedQueryContext) AllLateralView() []ILateralViewContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILateralViewContext); ok { + len++ + } + } + + tst := make([]ILateralViewContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILateralViewContext); ok { + tst[i] = t.(ILateralViewContext) + i++ + } + } + + return tst +} + +func (s *AliasedQueryContext) LateralView(i int) ILateralViewContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILateralViewContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILateralViewContext) +} + +func (s *AliasedQueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAliasedQuery(s) + } +} + +func (s *AliasedQueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAliasedQuery(s) + } +} + +func (s *AliasedQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAliasedQuery(s) + + default: + return t.VisitChildren(s) + } +} + +type TableNameContext struct { + RelationPrimaryContext +} + +func NewTableNameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableNameContext { + var p = new(TableNameContext) + + InitEmptyRelationPrimaryContext(&p.RelationPrimaryContext) + p.parser = parser + p.CopyAll(ctx.(*RelationPrimaryContext)) + + return p +} + +func (s *TableNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableNameContext) MultipartIdentifier() IMultipartIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultipartIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultipartIdentifierContext) +} + +func (s *TableNameContext) TableAlias() ITableAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableAliasContext) +} + +func (s *TableNameContext) OptScanParams() IOptScanParamsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptScanParamsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptScanParamsContext) +} + +func (s *TableNameContext) MaterializedViewName() IMaterializedViewNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewNameContext) +} + +func (s *TableNameContext) TableSnapshot() ITableSnapshotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableSnapshotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableSnapshotContext) +} + +func (s *TableNameContext) SpecifiedPartition() ISpecifiedPartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecifiedPartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpecifiedPartitionContext) +} + +func (s *TableNameContext) TabletList() ITabletListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITabletListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITabletListContext) +} + +func (s *TableNameContext) Sample() ISampleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISampleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISampleContext) +} + +func (s *TableNameContext) RelationHint() IRelationHintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationHintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationHintContext) +} + +func (s *TableNameContext) AllLateralView() []ILateralViewContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILateralViewContext); ok { + len++ + } + } + + tst := make([]ILateralViewContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILateralViewContext); ok { + tst[i] = t.(ILateralViewContext) + i++ + } + } + + return tst +} + +func (s *TableNameContext) LateralView(i int) ILateralViewContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILateralViewContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILateralViewContext) +} + +func (s *TableNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTableName(s) + } +} + +func (s *TableNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTableName(s) + } +} + +func (s *TableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTableName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RelationPrimary() (localctx IRelationPrimaryContext) { + localctx = NewRelationPrimaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, DorisParserRULE_relationPrimary) + var _la int + + var _alt int + + p.SetState(5612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 802, p.GetParserRuleContext()) { + case 1: + localctx = NewTableNameContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5561) + p.MultipartIdentifier() + } + p.SetState(5563) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) == 1 { + { + p.SetState(5562) + p.OptScanParams() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5566) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) == 1 { + { + p.SetState(5565) + p.MaterializedViewName() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5569) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 794, p.GetParserRuleContext()) == 1 { + { + p.SetState(5568) + p.TableSnapshot() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5572) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 795, p.GetParserRuleContext()) == 1 { + { + p.SetState(5571) + p.SpecifiedPartition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5575) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) == 1 { + { + p.SetState(5574) + p.TabletList() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5577) + p.TableAlias() + } + p.SetState(5579) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 797, p.GetParserRuleContext()) == 1 { + { + p.SetState(5578) + p.Sample() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 798, p.GetParserRuleContext()) == 1 { + { + p.SetState(5581) + p.RelationHint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 799, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5584) + p.LateralView() + } + + } + p.SetState(5589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 799, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + localctx = NewAliasedQueryContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5590) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5591) + p.Query() + } + { + p.SetState(5592) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5593) + p.TableAlias() + } + p.SetState(5597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5594) + p.LateralView() + } + + } + p.SetState(5599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 3: + localctx = NewTableValuedFunctionContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5600) + + var _x = p.Identifier() + + localctx.(*TableValuedFunctionContext).tvfName = _x + } + { + p.SetState(5601) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-7)) & ^0x3f) == 0 && ((int64(1)<<(_la-7))&-4071395127667384755) != 0) || ((int64((_la-71)) & ^0x3f) == 0 && ((int64(1)<<(_la-71))&-6386157293049745705) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485008317210093361) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-2666703833553702093) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439307733023) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605691481683905) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1183912064503058687) != 0) { + { + p.SetState(5602) + + var _x = p.PropertyItemList() + + localctx.(*TableValuedFunctionContext).properties = _x + } + + } + { + p.SetState(5605) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5606) + p.TableAlias() + } + + case 4: + localctx = NewRelationListContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5608) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5609) + p.Relations() + } + { + p.SetState(5610) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaterializedViewNameContext is an interface to support dynamic dispatch. +type IMaterializedViewNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndexName returns the indexName rule contexts. + GetIndexName() IIdentifierContext + + // SetIndexName sets the indexName rule contexts. + SetIndexName(IIdentifierContext) + + // Getter signatures + INDEX() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsMaterializedViewNameContext differentiates from other interfaces. + IsMaterializedViewNameContext() +} + +type MaterializedViewNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + indexName IIdentifierContext +} + +func NewEmptyMaterializedViewNameContext() *MaterializedViewNameContext { + var p = new(MaterializedViewNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_materializedViewName + return p +} + +func InitEmptyMaterializedViewNameContext(p *MaterializedViewNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_materializedViewName +} + +func (*MaterializedViewNameContext) IsMaterializedViewNameContext() {} + +func NewMaterializedViewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaterializedViewNameContext { + var p = new(MaterializedViewNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_materializedViewName + + return p +} + +func (s *MaterializedViewNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaterializedViewNameContext) GetIndexName() IIdentifierContext { return s.indexName } + +func (s *MaterializedViewNameContext) SetIndexName(v IIdentifierContext) { s.indexName = v } + +func (s *MaterializedViewNameContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *MaterializedViewNameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *MaterializedViewNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaterializedViewNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MaterializedViewNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMaterializedViewName(s) + } +} + +func (s *MaterializedViewNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMaterializedViewName(s) + } +} + +func (s *MaterializedViewNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMaterializedViewName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MaterializedViewName() (localctx IMaterializedViewNameContext) { + localctx = NewMaterializedViewNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, DorisParserRULE_materializedViewName) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5614) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5615) + + var _x = p.Identifier() + + localctx.(*MaterializedViewNameContext).indexName = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPropertyClauseContext is an interface to support dynamic dispatch. +type IPropertyClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFileProperties returns the fileProperties rule contexts. + GetFileProperties() IPropertyItemListContext + + // SetFileProperties sets the fileProperties rule contexts. + SetFileProperties(IPropertyItemListContext) + + // Getter signatures + PROPERTIES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + PropertyItemList() IPropertyItemListContext + + // IsPropertyClauseContext differentiates from other interfaces. + IsPropertyClauseContext() +} + +type PropertyClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fileProperties IPropertyItemListContext +} + +func NewEmptyPropertyClauseContext() *PropertyClauseContext { + var p = new(PropertyClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyClause + return p +} + +func InitEmptyPropertyClauseContext(p *PropertyClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyClause +} + +func (*PropertyClauseContext) IsPropertyClauseContext() {} + +func NewPropertyClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyClauseContext { + var p = new(PropertyClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_propertyClause + + return p +} + +func (s *PropertyClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyClauseContext) GetFileProperties() IPropertyItemListContext { return s.fileProperties } + +func (s *PropertyClauseContext) SetFileProperties(v IPropertyItemListContext) { s.fileProperties = v } + +func (s *PropertyClauseContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *PropertyClauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PropertyClauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PropertyClauseContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *PropertyClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPropertyClause(s) + } +} + +func (s *PropertyClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPropertyClause(s) + } +} + +func (s *PropertyClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPropertyClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PropertyClause() (localctx IPropertyClauseContext) { + localctx = NewPropertyClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, DorisParserRULE_propertyClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5617) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5618) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5619) + + var _x = p.PropertyItemList() + + localctx.(*PropertyClauseContext).fileProperties = _x + } + { + p.SetState(5620) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPropertyItemListContext is an interface to support dynamic dispatch. +type IPropertyItemListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_propertyItem returns the _propertyItem rule contexts. + Get_propertyItem() IPropertyItemContext + + // Set_propertyItem sets the _propertyItem rule contexts. + Set_propertyItem(IPropertyItemContext) + + // GetProperties returns the properties rule context list. + GetProperties() []IPropertyItemContext + + // SetProperties sets the properties rule context list. + SetProperties([]IPropertyItemContext) + + // Getter signatures + AllPropertyItem() []IPropertyItemContext + PropertyItem(i int) IPropertyItemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPropertyItemListContext differentiates from other interfaces. + IsPropertyItemListContext() +} + +type PropertyItemListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _propertyItem IPropertyItemContext + properties []IPropertyItemContext +} + +func NewEmptyPropertyItemListContext() *PropertyItemListContext { + var p = new(PropertyItemListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyItemList + return p +} + +func InitEmptyPropertyItemListContext(p *PropertyItemListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyItemList +} + +func (*PropertyItemListContext) IsPropertyItemListContext() {} + +func NewPropertyItemListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyItemListContext { + var p = new(PropertyItemListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_propertyItemList + + return p +} + +func (s *PropertyItemListContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyItemListContext) Get_propertyItem() IPropertyItemContext { return s._propertyItem } + +func (s *PropertyItemListContext) Set_propertyItem(v IPropertyItemContext) { s._propertyItem = v } + +func (s *PropertyItemListContext) GetProperties() []IPropertyItemContext { return s.properties } + +func (s *PropertyItemListContext) SetProperties(v []IPropertyItemContext) { s.properties = v } + +func (s *PropertyItemListContext) AllPropertyItem() []IPropertyItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPropertyItemContext); ok { + len++ + } + } + + tst := make([]IPropertyItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPropertyItemContext); ok { + tst[i] = t.(IPropertyItemContext) + i++ + } + } + + return tst +} + +func (s *PropertyItemListContext) PropertyItem(i int) IPropertyItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemContext) +} + +func (s *PropertyItemListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PropertyItemListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PropertyItemListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyItemListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyItemListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPropertyItemList(s) + } +} + +func (s *PropertyItemListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPropertyItemList(s) + } +} + +func (s *PropertyItemListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPropertyItemList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PropertyItemList() (localctx IPropertyItemListContext) { + localctx = NewPropertyItemListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, DorisParserRULE_propertyItemList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5622) + + var _x = p.PropertyItem() + + localctx.(*PropertyItemListContext)._propertyItem = _x + } + localctx.(*PropertyItemListContext).properties = append(localctx.(*PropertyItemListContext).properties, localctx.(*PropertyItemListContext)._propertyItem) + p.SetState(5627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5623) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5624) + + var _x = p.PropertyItem() + + localctx.(*PropertyItemListContext)._propertyItem = _x + } + localctx.(*PropertyItemListContext).properties = append(localctx.(*PropertyItemListContext).properties, localctx.(*PropertyItemListContext)._propertyItem) + + p.SetState(5629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPropertyItemContext is an interface to support dynamic dispatch. +type IPropertyItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey returns the key rule contexts. + GetKey() IPropertyKeyContext + + // GetValue returns the value rule contexts. + GetValue() IPropertyValueContext + + // SetKey sets the key rule contexts. + SetKey(IPropertyKeyContext) + + // SetValue sets the value rule contexts. + SetValue(IPropertyValueContext) + + // Getter signatures + EQ() antlr.TerminalNode + PropertyKey() IPropertyKeyContext + PropertyValue() IPropertyValueContext + + // IsPropertyItemContext differentiates from other interfaces. + IsPropertyItemContext() +} + +type PropertyItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key IPropertyKeyContext + value IPropertyValueContext +} + +func NewEmptyPropertyItemContext() *PropertyItemContext { + var p = new(PropertyItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyItem + return p +} + +func InitEmptyPropertyItemContext(p *PropertyItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyItem +} + +func (*PropertyItemContext) IsPropertyItemContext() {} + +func NewPropertyItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyItemContext { + var p = new(PropertyItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_propertyItem + + return p +} + +func (s *PropertyItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyItemContext) GetKey() IPropertyKeyContext { return s.key } + +func (s *PropertyItemContext) GetValue() IPropertyValueContext { return s.value } + +func (s *PropertyItemContext) SetKey(v IPropertyKeyContext) { s.key = v } + +func (s *PropertyItemContext) SetValue(v IPropertyValueContext) { s.value = v } + +func (s *PropertyItemContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *PropertyItemContext) PropertyKey() IPropertyKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyKeyContext) +} + +func (s *PropertyItemContext) PropertyValue() IPropertyValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyValueContext) +} + +func (s *PropertyItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPropertyItem(s) + } +} + +func (s *PropertyItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPropertyItem(s) + } +} + +func (s *PropertyItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPropertyItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PropertyItem() (localctx IPropertyItemContext) { + localctx = NewPropertyItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, DorisParserRULE_propertyItem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5630) + + var _x = p.PropertyKey() + + localctx.(*PropertyItemContext).key = _x + } + { + p.SetState(5631) + p.Match(DorisParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5632) + + var _x = p.PropertyValue() + + localctx.(*PropertyItemContext).value = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPropertyKeyContext is an interface to support dynamic dispatch. +type IPropertyKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Constant() IConstantContext + + // IsPropertyKeyContext differentiates from other interfaces. + IsPropertyKeyContext() +} + +type PropertyKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPropertyKeyContext() *PropertyKeyContext { + var p = new(PropertyKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyKey + return p +} + +func InitEmptyPropertyKeyContext(p *PropertyKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyKey +} + +func (*PropertyKeyContext) IsPropertyKeyContext() {} + +func NewPropertyKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyKeyContext { + var p = new(PropertyKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_propertyKey + + return p +} + +func (s *PropertyKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyKeyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PropertyKeyContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *PropertyKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPropertyKey(s) + } +} + +func (s *PropertyKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPropertyKey(s) + } +} + +func (s *PropertyKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPropertyKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PropertyKey() (localctx IPropertyKeyContext) { + localctx = NewPropertyKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, DorisParserRULE_propertyKey) + p.SetState(5636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 804, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5634) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5635) + p.Constant() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPropertyValueContext is an interface to support dynamic dispatch. +type IPropertyValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Constant() IConstantContext + + // IsPropertyValueContext differentiates from other interfaces. + IsPropertyValueContext() +} + +type PropertyValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPropertyValueContext() *PropertyValueContext { + var p = new(PropertyValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyValue + return p +} + +func InitEmptyPropertyValueContext(p *PropertyValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_propertyValue +} + +func (*PropertyValueContext) IsPropertyValueContext() {} + +func NewPropertyValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyValueContext { + var p = new(PropertyValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_propertyValue + + return p +} + +func (s *PropertyValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *PropertyValueContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *PropertyValueContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *PropertyValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PropertyValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PropertyValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPropertyValue(s) + } +} + +func (s *PropertyValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPropertyValue(s) + } +} + +func (s *PropertyValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPropertyValue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PropertyValue() (localctx IPropertyValueContext) { + localctx = NewPropertyValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, DorisParserRULE_propertyValue) + p.SetState(5640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5638) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5639) + p.Constant() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableAliasContext is an interface to support dynamic dispatch. +type ITableAliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StrictIdentifier() IStrictIdentifierContext + AS() antlr.TerminalNode + IdentifierList() IIdentifierListContext + + // IsTableAliasContext differentiates from other interfaces. + IsTableAliasContext() +} + +type TableAliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableAliasContext() *TableAliasContext { + var p = new(TableAliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tableAlias + return p +} + +func InitEmptyTableAliasContext(p *TableAliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tableAlias +} + +func (*TableAliasContext) IsTableAliasContext() {} + +func NewTableAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableAliasContext { + var p = new(TableAliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_tableAlias + + return p +} + +func (s *TableAliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableAliasContext) StrictIdentifier() IStrictIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStrictIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStrictIdentifierContext) +} + +func (s *TableAliasContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *TableAliasContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *TableAliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableAliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTableAlias(s) + } +} + +func (s *TableAliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTableAlias(s) + } +} + +func (s *TableAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTableAlias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TableAlias() (localctx ITableAliasContext) { + localctx = NewTableAliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, DorisParserRULE_tableAlias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5649) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 808, p.GetParserRuleContext()) == 1 { + p.SetState(5643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(5642) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5645) + p.StrictIdentifier() + } + p.SetState(5647) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 807, p.GetParserRuleContext()) == 1 { + { + p.SetState(5646) + p.IdentifierList() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultipartIdentifierContext is an interface to support dynamic dispatch. +type IMultipartIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_errorCapturingIdentifier returns the _errorCapturingIdentifier rule contexts. + Get_errorCapturingIdentifier() IErrorCapturingIdentifierContext + + // Set_errorCapturingIdentifier sets the _errorCapturingIdentifier rule contexts. + Set_errorCapturingIdentifier(IErrorCapturingIdentifierContext) + + // GetParts returns the parts rule context list. + GetParts() []IErrorCapturingIdentifierContext + + // SetParts sets the parts rule context list. + SetParts([]IErrorCapturingIdentifierContext) + + // Getter signatures + AllErrorCapturingIdentifier() []IErrorCapturingIdentifierContext + ErrorCapturingIdentifier(i int) IErrorCapturingIdentifierContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsMultipartIdentifierContext differentiates from other interfaces. + IsMultipartIdentifierContext() +} + +type MultipartIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _errorCapturingIdentifier IErrorCapturingIdentifierContext + parts []IErrorCapturingIdentifierContext +} + +func NewEmptyMultipartIdentifierContext() *MultipartIdentifierContext { + var p = new(MultipartIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_multipartIdentifier + return p +} + +func InitEmptyMultipartIdentifierContext(p *MultipartIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_multipartIdentifier +} + +func (*MultipartIdentifierContext) IsMultipartIdentifierContext() {} + +func NewMultipartIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultipartIdentifierContext { + var p = new(MultipartIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_multipartIdentifier + + return p +} + +func (s *MultipartIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *MultipartIdentifierContext) Get_errorCapturingIdentifier() IErrorCapturingIdentifierContext { + return s._errorCapturingIdentifier +} + +func (s *MultipartIdentifierContext) Set_errorCapturingIdentifier(v IErrorCapturingIdentifierContext) { + s._errorCapturingIdentifier = v +} + +func (s *MultipartIdentifierContext) GetParts() []IErrorCapturingIdentifierContext { return s.parts } + +func (s *MultipartIdentifierContext) SetParts(v []IErrorCapturingIdentifierContext) { s.parts = v } + +func (s *MultipartIdentifierContext) AllErrorCapturingIdentifier() []IErrorCapturingIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + len++ + } + } + + tst := make([]IErrorCapturingIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IErrorCapturingIdentifierContext); ok { + tst[i] = t.(IErrorCapturingIdentifierContext) + i++ + } + } + + return tst +} + +func (s *MultipartIdentifierContext) ErrorCapturingIdentifier(i int) IErrorCapturingIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierContext) +} + +func (s *MultipartIdentifierContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(DorisParserDOT) +} + +func (s *MultipartIdentifierContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(DorisParserDOT, i) +} + +func (s *MultipartIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MultipartIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MultipartIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMultipartIdentifier(s) + } +} + +func (s *MultipartIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMultipartIdentifier(s) + } +} + +func (s *MultipartIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMultipartIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) MultipartIdentifier() (localctx IMultipartIdentifierContext) { + localctx = NewMultipartIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, DorisParserRULE_multipartIdentifier) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5651) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*MultipartIdentifierContext)._errorCapturingIdentifier = _x + } + localctx.(*MultipartIdentifierContext).parts = append(localctx.(*MultipartIdentifierContext).parts, localctx.(*MultipartIdentifierContext)._errorCapturingIdentifier) + p.SetState(5656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 809, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5652) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5653) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*MultipartIdentifierContext)._errorCapturingIdentifier = _x + } + localctx.(*MultipartIdentifierContext).parts = append(localctx.(*MultipartIdentifierContext).parts, localctx.(*MultipartIdentifierContext)._errorCapturingIdentifier) + + } + p.SetState(5658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 809, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpleColumnDefsContext is an interface to support dynamic dispatch. +type ISimpleColumnDefsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_simpleColumnDef returns the _simpleColumnDef rule contexts. + Get_simpleColumnDef() ISimpleColumnDefContext + + // Set_simpleColumnDef sets the _simpleColumnDef rule contexts. + Set_simpleColumnDef(ISimpleColumnDefContext) + + // GetCols returns the cols rule context list. + GetCols() []ISimpleColumnDefContext + + // SetCols sets the cols rule context list. + SetCols([]ISimpleColumnDefContext) + + // Getter signatures + AllSimpleColumnDef() []ISimpleColumnDefContext + SimpleColumnDef(i int) ISimpleColumnDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSimpleColumnDefsContext differentiates from other interfaces. + IsSimpleColumnDefsContext() +} + +type SimpleColumnDefsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _simpleColumnDef ISimpleColumnDefContext + cols []ISimpleColumnDefContext +} + +func NewEmptySimpleColumnDefsContext() *SimpleColumnDefsContext { + var p = new(SimpleColumnDefsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_simpleColumnDefs + return p +} + +func InitEmptySimpleColumnDefsContext(p *SimpleColumnDefsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_simpleColumnDefs +} + +func (*SimpleColumnDefsContext) IsSimpleColumnDefsContext() {} + +func NewSimpleColumnDefsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleColumnDefsContext { + var p = new(SimpleColumnDefsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_simpleColumnDefs + + return p +} + +func (s *SimpleColumnDefsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleColumnDefsContext) Get_simpleColumnDef() ISimpleColumnDefContext { + return s._simpleColumnDef +} + +func (s *SimpleColumnDefsContext) Set_simpleColumnDef(v ISimpleColumnDefContext) { + s._simpleColumnDef = v +} + +func (s *SimpleColumnDefsContext) GetCols() []ISimpleColumnDefContext { return s.cols } + +func (s *SimpleColumnDefsContext) SetCols(v []ISimpleColumnDefContext) { s.cols = v } + +func (s *SimpleColumnDefsContext) AllSimpleColumnDef() []ISimpleColumnDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimpleColumnDefContext); ok { + len++ + } + } + + tst := make([]ISimpleColumnDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimpleColumnDefContext); ok { + tst[i] = t.(ISimpleColumnDefContext) + i++ + } + } + + return tst +} + +func (s *SimpleColumnDefsContext) SimpleColumnDef(i int) ISimpleColumnDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpleColumnDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimpleColumnDefContext) +} + +func (s *SimpleColumnDefsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *SimpleColumnDefsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *SimpleColumnDefsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleColumnDefsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleColumnDefsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSimpleColumnDefs(s) + } +} + +func (s *SimpleColumnDefsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSimpleColumnDefs(s) + } +} + +func (s *SimpleColumnDefsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSimpleColumnDefs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SimpleColumnDefs() (localctx ISimpleColumnDefsContext) { + localctx = NewSimpleColumnDefsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, DorisParserRULE_simpleColumnDefs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5659) + + var _x = p.SimpleColumnDef() + + localctx.(*SimpleColumnDefsContext)._simpleColumnDef = _x + } + localctx.(*SimpleColumnDefsContext).cols = append(localctx.(*SimpleColumnDefsContext).cols, localctx.(*SimpleColumnDefsContext)._simpleColumnDef) + p.SetState(5664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5660) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5661) + + var _x = p.SimpleColumnDef() + + localctx.(*SimpleColumnDefsContext)._simpleColumnDef = _x + } + localctx.(*SimpleColumnDefsContext).cols = append(localctx.(*SimpleColumnDefsContext).cols, localctx.(*SimpleColumnDefsContext)._simpleColumnDef) + + p.SetState(5666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpleColumnDefContext is an interface to support dynamic dispatch. +type ISimpleColumnDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetComment returns the comment token. + GetComment() antlr.Token + + // SetComment sets the comment token. + SetComment(antlr.Token) + + // GetColName returns the colName rule contexts. + GetColName() IIdentifierContext + + // SetColName sets the colName rule contexts. + SetColName(IIdentifierContext) + + // Getter signatures + Identifier() IIdentifierContext + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsSimpleColumnDefContext differentiates from other interfaces. + IsSimpleColumnDefContext() +} + +type SimpleColumnDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + colName IIdentifierContext + comment antlr.Token +} + +func NewEmptySimpleColumnDefContext() *SimpleColumnDefContext { + var p = new(SimpleColumnDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_simpleColumnDef + return p +} + +func InitEmptySimpleColumnDefContext(p *SimpleColumnDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_simpleColumnDef +} + +func (*SimpleColumnDefContext) IsSimpleColumnDefContext() {} + +func NewSimpleColumnDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleColumnDefContext { + var p = new(SimpleColumnDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_simpleColumnDef + + return p +} + +func (s *SimpleColumnDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpleColumnDefContext) GetComment() antlr.Token { return s.comment } + +func (s *SimpleColumnDefContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *SimpleColumnDefContext) GetColName() IIdentifierContext { return s.colName } + +func (s *SimpleColumnDefContext) SetColName(v IIdentifierContext) { s.colName = v } + +func (s *SimpleColumnDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SimpleColumnDefContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *SimpleColumnDefContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *SimpleColumnDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleColumnDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpleColumnDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSimpleColumnDef(s) + } +} + +func (s *SimpleColumnDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSimpleColumnDef(s) + } +} + +func (s *SimpleColumnDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSimpleColumnDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SimpleColumnDef() (localctx ISimpleColumnDefContext) { + localctx = NewSimpleColumnDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, DorisParserRULE_simpleColumnDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5667) + + var _x = p.Identifier() + + localctx.(*SimpleColumnDefContext).colName = _x + } + p.SetState(5670) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(5668) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5669) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*SimpleColumnDefContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnDefsContext is an interface to support dynamic dispatch. +type IColumnDefsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_columnDef returns the _columnDef rule contexts. + Get_columnDef() IColumnDefContext + + // Set_columnDef sets the _columnDef rule contexts. + Set_columnDef(IColumnDefContext) + + // GetCols returns the cols rule context list. + GetCols() []IColumnDefContext + + // SetCols sets the cols rule context list. + SetCols([]IColumnDefContext) + + // Getter signatures + AllColumnDef() []IColumnDefContext + ColumnDef(i int) IColumnDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumnDefsContext differentiates from other interfaces. + IsColumnDefsContext() +} + +type ColumnDefsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _columnDef IColumnDefContext + cols []IColumnDefContext +} + +func NewEmptyColumnDefsContext() *ColumnDefsContext { + var p = new(ColumnDefsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnDefs + return p +} + +func InitEmptyColumnDefsContext(p *ColumnDefsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnDefs +} + +func (*ColumnDefsContext) IsColumnDefsContext() {} + +func NewColumnDefsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefsContext { + var p = new(ColumnDefsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_columnDefs + + return p +} + +func (s *ColumnDefsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnDefsContext) Get_columnDef() IColumnDefContext { return s._columnDef } + +func (s *ColumnDefsContext) Set_columnDef(v IColumnDefContext) { s._columnDef = v } + +func (s *ColumnDefsContext) GetCols() []IColumnDefContext { return s.cols } + +func (s *ColumnDefsContext) SetCols(v []IColumnDefContext) { s.cols = v } + +func (s *ColumnDefsContext) AllColumnDef() []IColumnDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnDefContext); ok { + len++ + } + } + + tst := make([]IColumnDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnDefContext); ok { + tst[i] = t.(IColumnDefContext) + i++ + } + } + + return tst +} + +func (s *ColumnDefsContext) ColumnDef(i int) IColumnDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefContext) +} + +func (s *ColumnDefsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ColumnDefsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ColumnDefsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDefsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnDefsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColumnDefs(s) + } +} + +func (s *ColumnDefsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColumnDefs(s) + } +} + +func (s *ColumnDefsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColumnDefs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ColumnDefs() (localctx IColumnDefsContext) { + localctx = NewColumnDefsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, DorisParserRULE_columnDefs) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5672) + + var _x = p.ColumnDef() + + localctx.(*ColumnDefsContext)._columnDef = _x + } + localctx.(*ColumnDefsContext).cols = append(localctx.(*ColumnDefsContext).cols, localctx.(*ColumnDefsContext)._columnDef) + p.SetState(5677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5673) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5674) + + var _x = p.ColumnDef() + + localctx.(*ColumnDefsContext)._columnDef = _x + } + localctx.(*ColumnDefsContext).cols = append(localctx.(*ColumnDefsContext).cols, localctx.(*ColumnDefsContext)._columnDef) + + } + p.SetState(5679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnDefContext is an interface to support dynamic dispatch. +type IColumnDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNullable returns the nullable token. + GetNullable() antlr.Token + + // GetNullValue returns the nullValue token. + GetNullValue() antlr.Token + + // GetStringValue returns the stringValue token. + GetStringValue() antlr.Token + + // GetDefaultTimestamp returns the defaultTimestamp token. + GetDefaultTimestamp() antlr.Token + + // GetComment returns the comment token. + GetComment() antlr.Token + + // SetNullable sets the nullable token. + SetNullable(antlr.Token) + + // SetNullValue sets the nullValue token. + SetNullValue(antlr.Token) + + // SetStringValue sets the stringValue token. + SetStringValue(antlr.Token) + + // SetDefaultTimestamp sets the defaultTimestamp token. + SetDefaultTimestamp(antlr.Token) + + // SetComment sets the comment token. + SetComment(antlr.Token) + + // GetColName returns the colName rule contexts. + GetColName() IIdentifierContext + + // GetType_ returns the type_ rule contexts. + GetType_() IDataTypeContext + + // GetAggType returns the aggType rule contexts. + GetAggType() IAggTypeDefContext + + // GetGeneratedExpr returns the generatedExpr rule contexts. + GetGeneratedExpr() IExpressionContext + + // GetAutoIncInitValue returns the autoIncInitValue rule contexts. + GetAutoIncInitValue() INumberContext + + // GetDefaultValuePrecision returns the defaultValuePrecision rule contexts. + GetDefaultValuePrecision() INumberContext + + // GetOnUpdateValuePrecision returns the onUpdateValuePrecision rule contexts. + GetOnUpdateValuePrecision() INumberContext + + // SetColName sets the colName rule contexts. + SetColName(IIdentifierContext) + + // SetType_ sets the type_ rule contexts. + SetType_(IDataTypeContext) + + // SetAggType sets the aggType rule contexts. + SetAggType(IAggTypeDefContext) + + // SetGeneratedExpr sets the generatedExpr rule contexts. + SetGeneratedExpr(IExpressionContext) + + // SetAutoIncInitValue sets the autoIncInitValue rule contexts. + SetAutoIncInitValue(INumberContext) + + // SetDefaultValuePrecision sets the defaultValuePrecision rule contexts. + SetDefaultValuePrecision(INumberContext) + + // SetOnUpdateValuePrecision sets the onUpdateValuePrecision rule contexts. + SetOnUpdateValuePrecision(INumberContext) + + // Getter signatures + Identifier() IIdentifierContext + DataType() IDataTypeContext + KEY() antlr.TerminalNode + AS() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AUTO_INCREMENT() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ON() antlr.TerminalNode + UPDATE() antlr.TerminalNode + AllCURRENT_TIMESTAMP() []antlr.TerminalNode + CURRENT_TIMESTAMP(i int) antlr.TerminalNode + COMMENT() antlr.TerminalNode + AggTypeDef() IAggTypeDefContext + Expression() IExpressionContext + AllNULL() []antlr.TerminalNode + NULL(i int) antlr.TerminalNode + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + DECIMAL_VALUE() antlr.TerminalNode + PI() antlr.TerminalNode + E() antlr.TerminalNode + BITMAP_EMPTY() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + GENERATED() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + NOT() antlr.TerminalNode + AllNumber() []INumberContext + Number(i int) INumberContext + SUBTRACT() antlr.TerminalNode + + // IsColumnDefContext differentiates from other interfaces. + IsColumnDefContext() +} + +type ColumnDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + colName IIdentifierContext + type_ IDataTypeContext + aggType IAggTypeDefContext + generatedExpr IExpressionContext + nullable antlr.Token + autoIncInitValue INumberContext + nullValue antlr.Token + stringValue antlr.Token + defaultTimestamp antlr.Token + defaultValuePrecision INumberContext + onUpdateValuePrecision INumberContext + comment antlr.Token +} + +func NewEmptyColumnDefContext() *ColumnDefContext { + var p = new(ColumnDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnDef + return p +} + +func InitEmptyColumnDefContext(p *ColumnDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_columnDef +} + +func (*ColumnDefContext) IsColumnDefContext() {} + +func NewColumnDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefContext { + var p = new(ColumnDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_columnDef + + return p +} + +func (s *ColumnDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnDefContext) GetNullable() antlr.Token { return s.nullable } + +func (s *ColumnDefContext) GetNullValue() antlr.Token { return s.nullValue } + +func (s *ColumnDefContext) GetStringValue() antlr.Token { return s.stringValue } + +func (s *ColumnDefContext) GetDefaultTimestamp() antlr.Token { return s.defaultTimestamp } + +func (s *ColumnDefContext) GetComment() antlr.Token { return s.comment } + +func (s *ColumnDefContext) SetNullable(v antlr.Token) { s.nullable = v } + +func (s *ColumnDefContext) SetNullValue(v antlr.Token) { s.nullValue = v } + +func (s *ColumnDefContext) SetStringValue(v antlr.Token) { s.stringValue = v } + +func (s *ColumnDefContext) SetDefaultTimestamp(v antlr.Token) { s.defaultTimestamp = v } + +func (s *ColumnDefContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *ColumnDefContext) GetColName() IIdentifierContext { return s.colName } + +func (s *ColumnDefContext) GetType_() IDataTypeContext { return s.type_ } + +func (s *ColumnDefContext) GetAggType() IAggTypeDefContext { return s.aggType } + +func (s *ColumnDefContext) GetGeneratedExpr() IExpressionContext { return s.generatedExpr } + +func (s *ColumnDefContext) GetAutoIncInitValue() INumberContext { return s.autoIncInitValue } + +func (s *ColumnDefContext) GetDefaultValuePrecision() INumberContext { return s.defaultValuePrecision } + +func (s *ColumnDefContext) GetOnUpdateValuePrecision() INumberContext { + return s.onUpdateValuePrecision +} + +func (s *ColumnDefContext) SetColName(v IIdentifierContext) { s.colName = v } + +func (s *ColumnDefContext) SetType_(v IDataTypeContext) { s.type_ = v } + +func (s *ColumnDefContext) SetAggType(v IAggTypeDefContext) { s.aggType = v } + +func (s *ColumnDefContext) SetGeneratedExpr(v IExpressionContext) { s.generatedExpr = v } + +func (s *ColumnDefContext) SetAutoIncInitValue(v INumberContext) { s.autoIncInitValue = v } + +func (s *ColumnDefContext) SetDefaultValuePrecision(v INumberContext) { s.defaultValuePrecision = v } + +func (s *ColumnDefContext) SetOnUpdateValuePrecision(v INumberContext) { s.onUpdateValuePrecision = v } + +func (s *ColumnDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ColumnDefContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ColumnDefContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *ColumnDefContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *ColumnDefContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserLEFT_PAREN) +} + +func (s *ColumnDefContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, i) +} + +func (s *ColumnDefContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(DorisParserRIGHT_PAREN) +} + +func (s *ColumnDefContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, i) +} + +func (s *ColumnDefContext) AUTO_INCREMENT() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO_INCREMENT, 0) +} + +func (s *ColumnDefContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *ColumnDefContext) ON() antlr.TerminalNode { + return s.GetToken(DorisParserON, 0) +} + +func (s *ColumnDefContext) UPDATE() antlr.TerminalNode { + return s.GetToken(DorisParserUPDATE, 0) +} + +func (s *ColumnDefContext) AllCURRENT_TIMESTAMP() []antlr.TerminalNode { + return s.GetTokens(DorisParserCURRENT_TIMESTAMP) +} + +func (s *ColumnDefContext) CURRENT_TIMESTAMP(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_TIMESTAMP, i) +} + +func (s *ColumnDefContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *ColumnDefContext) AggTypeDef() IAggTypeDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggTypeDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggTypeDefContext) +} + +func (s *ColumnDefContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ColumnDefContext) AllNULL() []antlr.TerminalNode { + return s.GetTokens(DorisParserNULL) +} + +func (s *ColumnDefContext) NULL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserNULL, i) +} + +func (s *ColumnDefContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(DorisParserSTRING_LITERAL) +} + +func (s *ColumnDefContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, i) +} + +func (s *ColumnDefContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *ColumnDefContext) DECIMAL_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMAL_VALUE, 0) +} + +func (s *ColumnDefContext) PI() antlr.TerminalNode { + return s.GetToken(DorisParserPI, 0) +} + +func (s *ColumnDefContext) E() antlr.TerminalNode { + return s.GetToken(DorisParserE, 0) +} + +func (s *ColumnDefContext) BITMAP_EMPTY() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP_EMPTY, 0) +} + +func (s *ColumnDefContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_DATE, 0) +} + +func (s *ColumnDefContext) GENERATED() antlr.TerminalNode { + return s.GetToken(DorisParserGENERATED, 0) +} + +func (s *ColumnDefContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(DorisParserALWAYS, 0) +} + +func (s *ColumnDefContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *ColumnDefContext) AllNumber() []INumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumberContext); ok { + len++ + } + } + + tst := make([]INumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumberContext); ok { + tst[i] = t.(INumberContext) + i++ + } + } + + return tst +} + +func (s *ColumnDefContext) Number(i int) INumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumberContext) +} + +func (s *ColumnDefContext) SUBTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, 0) +} + +func (s *ColumnDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColumnDef(s) + } +} + +func (s *ColumnDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColumnDef(s) + } +} + +func (s *ColumnDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColumnDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ColumnDef() (localctx IColumnDefContext) { + localctx = NewColumnDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, DorisParserRULE_columnDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5680) + + var _x = p.Identifier() + + localctx.(*ColumnDefContext).colName = _x + } + { + p.SetState(5681) + + var _x = p.DataType() + + localctx.(*ColumnDefContext).type_ = _x + } + p.SetState(5683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserKEY { + { + p.SetState(5682) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBITMAP_UNION || _la == DorisParserGENERIC || _la == DorisParserHLL_UNION || _la == DorisParserMAX || _la == DorisParserMIN || ((int64((_la-378)) & ^0x3f) == 0 && ((int64(1)<<(_la-378))&6291457) != 0) || _la == DorisParserSUM { + { + p.SetState(5685) + + var _x = p.AggTypeDef() + + localctx.(*ColumnDefContext).aggType = _x + } + + } + p.SetState(5697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS || _la == DorisParserGENERATED { + p.SetState(5690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserGENERATED { + { + p.SetState(5688) + p.Match(DorisParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5689) + p.Match(DorisParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5692) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5693) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5694) + + var _x = p.Expression() + + localctx.(*ColumnDefContext).generatedExpr = _x + } + { + p.SetState(5695) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT || _la == DorisParserNULL { + p.SetState(5700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(5699) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5702) + + var _m = p.Match(DorisParserNULL) + + localctx.(*ColumnDefContext).nullable = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAUTO_INCREMENT { + { + p.SetState(5705) + p.Match(DorisParserAUTO_INCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5706) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5707) + + var _x = p.Number() + + localctx.(*ColumnDefContext).autoIncInitValue = _x + } + { + p.SetState(5708) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(5738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDEFAULT { + { + p.SetState(5714) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 824, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5715) + + var _m = p.Match(DorisParserNULL) + + localctx.(*ColumnDefContext).nullValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSUBTRACT { + { + p.SetState(5716) + p.Match(DorisParserSUBTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5719) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.SetState(5721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSUBTRACT { + { + p.SetState(5720) + p.Match(DorisParserSUBTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5723) + p.Match(DorisParserDECIMAL_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5724) + p.Match(DorisParserPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5725) + p.Match(DorisParserE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(5726) + p.Match(DorisParserBITMAP_EMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(5727) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ColumnDefContext).stringValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(5728) + p.Match(DorisParserCURRENT_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + { + p.SetState(5729) + + var _m = p.Match(DorisParserCURRENT_TIMESTAMP) + + localctx.(*ColumnDefContext).defaultTimestamp = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5730) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5731) + + var _x = p.Number() + + localctx.(*ColumnDefContext).defaultValuePrecision = _x + } + { + p.SetState(5732) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserON { + { + p.SetState(5740) + p.Match(DorisParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5741) + p.Match(DorisParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5742) + p.Match(DorisParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5743) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5744) + + var _x = p.Number() + + localctx.(*ColumnDefContext).onUpdateValuePrecision = _x + } + { + p.SetState(5745) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(5753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(5751) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5752) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*ColumnDefContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexDefsContext is an interface to support dynamic dispatch. +type IIndexDefsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_indexDef returns the _indexDef rule contexts. + Get_indexDef() IIndexDefContext + + // Set_indexDef sets the _indexDef rule contexts. + Set_indexDef(IIndexDefContext) + + // GetIndexes returns the indexes rule context list. + GetIndexes() []IIndexDefContext + + // SetIndexes sets the indexes rule context list. + SetIndexes([]IIndexDefContext) + + // Getter signatures + AllIndexDef() []IIndexDefContext + IndexDef(i int) IIndexDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIndexDefsContext differentiates from other interfaces. + IsIndexDefsContext() +} + +type IndexDefsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _indexDef IIndexDefContext + indexes []IIndexDefContext +} + +func NewEmptyIndexDefsContext() *IndexDefsContext { + var p = new(IndexDefsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_indexDefs + return p +} + +func InitEmptyIndexDefsContext(p *IndexDefsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_indexDefs +} + +func (*IndexDefsContext) IsIndexDefsContext() {} + +func NewIndexDefsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexDefsContext { + var p = new(IndexDefsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_indexDefs + + return p +} + +func (s *IndexDefsContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexDefsContext) Get_indexDef() IIndexDefContext { return s._indexDef } + +func (s *IndexDefsContext) Set_indexDef(v IIndexDefContext) { s._indexDef = v } + +func (s *IndexDefsContext) GetIndexes() []IIndexDefContext { return s.indexes } + +func (s *IndexDefsContext) SetIndexes(v []IIndexDefContext) { s.indexes = v } + +func (s *IndexDefsContext) AllIndexDef() []IIndexDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndexDefContext); ok { + len++ + } + } + + tst := make([]IIndexDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndexDefContext); ok { + tst[i] = t.(IIndexDefContext) + i++ + } + } + + return tst +} + +func (s *IndexDefsContext) IndexDef(i int) IIndexDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndexDefContext) +} + +func (s *IndexDefsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *IndexDefsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *IndexDefsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexDefsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexDefsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIndexDefs(s) + } +} + +func (s *IndexDefsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIndexDefs(s) + } +} + +func (s *IndexDefsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIndexDefs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IndexDefs() (localctx IIndexDefsContext) { + localctx = NewIndexDefsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, DorisParserRULE_indexDefs) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5755) + + var _x = p.IndexDef() + + localctx.(*IndexDefsContext)._indexDef = _x + } + localctx.(*IndexDefsContext).indexes = append(localctx.(*IndexDefsContext).indexes, localctx.(*IndexDefsContext)._indexDef) + p.SetState(5760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5756) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5757) + + var _x = p.IndexDef() + + localctx.(*IndexDefsContext)._indexDef = _x + } + localctx.(*IndexDefsContext).indexes = append(localctx.(*IndexDefsContext).indexes, localctx.(*IndexDefsContext)._indexDef) + + } + p.SetState(5762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexDefContext is an interface to support dynamic dispatch. +type IIndexDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIfNotExists returns the ifNotExists token. + GetIfNotExists() antlr.Token + + // GetIndexType returns the indexType token. + GetIndexType() antlr.Token + + // GetComment returns the comment token. + GetComment() antlr.Token + + // SetIfNotExists sets the ifNotExists token. + SetIfNotExists(antlr.Token) + + // SetIndexType sets the indexType token. + SetIndexType(antlr.Token) + + // SetComment sets the comment token. + SetComment(antlr.Token) + + // GetIndexName returns the indexName rule contexts. + GetIndexName() IIdentifierContext + + // GetCols returns the cols rule contexts. + GetCols() IIdentifierListContext + + // GetProperties returns the properties rule contexts. + GetProperties() IPropertyItemListContext + + // SetIndexName sets the indexName rule contexts. + SetIndexName(IIdentifierContext) + + // SetCols sets the cols rule contexts. + SetCols(IIdentifierListContext) + + // SetProperties sets the properties rule contexts. + SetProperties(IPropertyItemListContext) + + // Getter signatures + INDEX() antlr.TerminalNode + Identifier() IIdentifierContext + IdentifierList() IIdentifierListContext + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + USING() antlr.TerminalNode + PROPERTIES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + COMMENT() antlr.TerminalNode + IF() antlr.TerminalNode + PropertyItemList() IPropertyItemListContext + STRING_LITERAL() antlr.TerminalNode + BITMAP() antlr.TerminalNode + INVERTED() antlr.TerminalNode + NGRAM_BF() antlr.TerminalNode + ANN() antlr.TerminalNode + + // IsIndexDefContext differentiates from other interfaces. + IsIndexDefContext() +} + +type IndexDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ifNotExists antlr.Token + indexName IIdentifierContext + cols IIdentifierListContext + indexType antlr.Token + properties IPropertyItemListContext + comment antlr.Token +} + +func NewEmptyIndexDefContext() *IndexDefContext { + var p = new(IndexDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_indexDef + return p +} + +func InitEmptyIndexDefContext(p *IndexDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_indexDef +} + +func (*IndexDefContext) IsIndexDefContext() {} + +func NewIndexDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexDefContext { + var p = new(IndexDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_indexDef + + return p +} + +func (s *IndexDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexDefContext) GetIfNotExists() antlr.Token { return s.ifNotExists } + +func (s *IndexDefContext) GetIndexType() antlr.Token { return s.indexType } + +func (s *IndexDefContext) GetComment() antlr.Token { return s.comment } + +func (s *IndexDefContext) SetIfNotExists(v antlr.Token) { s.ifNotExists = v } + +func (s *IndexDefContext) SetIndexType(v antlr.Token) { s.indexType = v } + +func (s *IndexDefContext) SetComment(v antlr.Token) { s.comment = v } + +func (s *IndexDefContext) GetIndexName() IIdentifierContext { return s.indexName } + +func (s *IndexDefContext) GetCols() IIdentifierListContext { return s.cols } + +func (s *IndexDefContext) GetProperties() IPropertyItemListContext { return s.properties } + +func (s *IndexDefContext) SetIndexName(v IIdentifierContext) { s.indexName = v } + +func (s *IndexDefContext) SetCols(v IIdentifierListContext) { s.cols = v } + +func (s *IndexDefContext) SetProperties(v IPropertyItemListContext) { s.properties = v } + +func (s *IndexDefContext) INDEX() antlr.TerminalNode { + return s.GetToken(DorisParserINDEX, 0) +} + +func (s *IndexDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *IndexDefContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *IndexDefContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *IndexDefContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *IndexDefContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *IndexDefContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *IndexDefContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *IndexDefContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *IndexDefContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *IndexDefContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *IndexDefContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *IndexDefContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *IndexDefContext) BITMAP() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP, 0) +} + +func (s *IndexDefContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *IndexDefContext) NGRAM_BF() antlr.TerminalNode { + return s.GetToken(DorisParserNGRAM_BF, 0) +} + +func (s *IndexDefContext) ANN() antlr.TerminalNode { + return s.GetToken(DorisParserANN, 0) +} + +func (s *IndexDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIndexDef(s) + } +} + +func (s *IndexDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIndexDef(s) + } +} + +func (s *IndexDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIndexDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) IndexDef() (localctx IIndexDefContext) { + localctx = NewIndexDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, DorisParserRULE_indexDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5763) + p.Match(DorisParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(5764) + + var _m = p.Match(DorisParserIF) + + localctx.(*IndexDefContext).ifNotExists = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5765) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5766) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5769) + + var _x = p.Identifier() + + localctx.(*IndexDefContext).indexName = _x + } + { + p.SetState(5770) + + var _x = p.IdentifierList() + + localctx.(*IndexDefContext).cols = _x + } + p.SetState(5773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserUSING { + { + p.SetState(5771) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5772) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*IndexDefContext).indexType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBITMAP || _la == DorisParserINVERTED || _la == DorisParserNGRAM_BF || _la == DorisParserANN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*IndexDefContext).indexType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(5775) + p.Match(DorisParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5776) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5777) + + var _x = p.PropertyItemList() + + localctx.(*IndexDefContext).properties = _x + } + { + p.SetState(5778) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(5782) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5783) + + var _m = p.Match(DorisParserSTRING_LITERAL) + + localctx.(*IndexDefContext).comment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionsDefContext is an interface to support dynamic dispatch. +type IPartitionsDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_partitionDef returns the _partitionDef rule contexts. + Get_partitionDef() IPartitionDefContext + + // Set_partitionDef sets the _partitionDef rule contexts. + Set_partitionDef(IPartitionDefContext) + + // GetPartitions returns the partitions rule context list. + GetPartitions() []IPartitionDefContext + + // SetPartitions sets the partitions rule context list. + SetPartitions([]IPartitionDefContext) + + // Getter signatures + AllPartitionDef() []IPartitionDefContext + PartitionDef(i int) IPartitionDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartitionsDefContext differentiates from other interfaces. + IsPartitionsDefContext() +} + +type PartitionsDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _partitionDef IPartitionDefContext + partitions []IPartitionDefContext +} + +func NewEmptyPartitionsDefContext() *PartitionsDefContext { + var p = new(PartitionsDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionsDef + return p +} + +func InitEmptyPartitionsDefContext(p *PartitionsDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionsDef +} + +func (*PartitionsDefContext) IsPartitionsDefContext() {} + +func NewPartitionsDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionsDefContext { + var p = new(PartitionsDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionsDef + + return p +} + +func (s *PartitionsDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionsDefContext) Get_partitionDef() IPartitionDefContext { return s._partitionDef } + +func (s *PartitionsDefContext) Set_partitionDef(v IPartitionDefContext) { s._partitionDef = v } + +func (s *PartitionsDefContext) GetPartitions() []IPartitionDefContext { return s.partitions } + +func (s *PartitionsDefContext) SetPartitions(v []IPartitionDefContext) { s.partitions = v } + +func (s *PartitionsDefContext) AllPartitionDef() []IPartitionDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionDefContext); ok { + len++ + } + } + + tst := make([]IPartitionDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionDefContext); ok { + tst[i] = t.(IPartitionDefContext) + i++ + } + } + + return tst +} + +func (s *PartitionsDefContext) PartitionDef(i int) IPartitionDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionDefContext) +} + +func (s *PartitionsDefContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PartitionsDefContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PartitionsDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionsDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionsDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionsDef(s) + } +} + +func (s *PartitionsDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionsDef(s) + } +} + +func (s *PartitionsDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionsDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionsDef() (localctx IPartitionsDefContext) { + localctx = NewPartitionsDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, DorisParserRULE_partitionsDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5786) + + var _x = p.PartitionDef() + + localctx.(*PartitionsDefContext)._partitionDef = _x + } + localctx.(*PartitionsDefContext).partitions = append(localctx.(*PartitionsDefContext).partitions, localctx.(*PartitionsDefContext)._partitionDef) + p.SetState(5791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5787) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5788) + + var _x = p.PartitionDef() + + localctx.(*PartitionsDefContext)._partitionDef = _x + } + localctx.(*PartitionsDefContext).partitions = append(localctx.(*PartitionsDefContext).partitions, localctx.(*PartitionsDefContext)._partitionDef) + + p.SetState(5793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionDefContext is an interface to support dynamic dispatch. +type IPartitionDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartitionProperties returns the partitionProperties rule contexts. + GetPartitionProperties() IPropertyItemListContext + + // SetPartitionProperties sets the partitionProperties rule contexts. + SetPartitionProperties(IPropertyItemListContext) + + // Getter signatures + LessThanPartitionDef() ILessThanPartitionDefContext + FixedPartitionDef() IFixedPartitionDefContext + StepPartitionDef() IStepPartitionDefContext + InPartitionDef() IInPartitionDefContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + PropertyItemList() IPropertyItemListContext + + // IsPartitionDefContext differentiates from other interfaces. + IsPartitionDefContext() +} + +type PartitionDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitionProperties IPropertyItemListContext +} + +func NewEmptyPartitionDefContext() *PartitionDefContext { + var p = new(PartitionDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionDef + return p +} + +func InitEmptyPartitionDefContext(p *PartitionDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionDef +} + +func (*PartitionDefContext) IsPartitionDefContext() {} + +func NewPartitionDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionDefContext { + var p = new(PartitionDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionDef + + return p +} + +func (s *PartitionDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionDefContext) GetPartitionProperties() IPropertyItemListContext { + return s.partitionProperties +} + +func (s *PartitionDefContext) SetPartitionProperties(v IPropertyItemListContext) { + s.partitionProperties = v +} + +func (s *PartitionDefContext) LessThanPartitionDef() ILessThanPartitionDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILessThanPartitionDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILessThanPartitionDefContext) +} + +func (s *PartitionDefContext) FixedPartitionDef() IFixedPartitionDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFixedPartitionDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFixedPartitionDefContext) +} + +func (s *PartitionDefContext) StepPartitionDef() IStepPartitionDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStepPartitionDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStepPartitionDefContext) +} + +func (s *PartitionDefContext) InPartitionDef() IInPartitionDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInPartitionDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInPartitionDefContext) +} + +func (s *PartitionDefContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PartitionDefContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PartitionDefContext) PropertyItemList() IPropertyItemListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyItemListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyItemListContext) +} + +func (s *PartitionDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionDef(s) + } +} + +func (s *PartitionDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionDef(s) + } +} + +func (s *PartitionDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionDef() (localctx IPartitionDefContext) { + localctx = NewPartitionDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, DorisParserRULE_partitionDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 835, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5794) + p.LessThanPartitionDef() + } + + case 2: + { + p.SetState(5795) + p.FixedPartitionDef() + } + + case 3: + { + p.SetState(5796) + p.StepPartitionDef() + } + + case 4: + { + p.SetState(5797) + p.InPartitionDef() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(5800) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5801) + + var _x = p.PropertyItemList() + + localctx.(*PartitionDefContext).partitionProperties = _x + } + { + p.SetState(5802) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILessThanPartitionDefContext is an interface to support dynamic dispatch. +type ILessThanPartitionDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartitionName returns the partitionName rule contexts. + GetPartitionName() IIdentifierContext + + // SetPartitionName sets the partitionName rule contexts. + SetPartitionName(IIdentifierContext) + + // Getter signatures + PARTITION() antlr.TerminalNode + VALUES() antlr.TerminalNode + LESS() antlr.TerminalNode + THAN() antlr.TerminalNode + Identifier() IIdentifierContext + MAXVALUE() antlr.TerminalNode + PartitionValueList() IPartitionValueListContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsLessThanPartitionDefContext differentiates from other interfaces. + IsLessThanPartitionDefContext() +} + +type LessThanPartitionDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitionName IIdentifierContext +} + +func NewEmptyLessThanPartitionDefContext() *LessThanPartitionDefContext { + var p = new(LessThanPartitionDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lessThanPartitionDef + return p +} + +func InitEmptyLessThanPartitionDefContext(p *LessThanPartitionDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lessThanPartitionDef +} + +func (*LessThanPartitionDefContext) IsLessThanPartitionDefContext() {} + +func NewLessThanPartitionDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LessThanPartitionDefContext { + var p = new(LessThanPartitionDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_lessThanPartitionDef + + return p +} + +func (s *LessThanPartitionDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *LessThanPartitionDefContext) GetPartitionName() IIdentifierContext { return s.partitionName } + +func (s *LessThanPartitionDefContext) SetPartitionName(v IIdentifierContext) { s.partitionName = v } + +func (s *LessThanPartitionDefContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *LessThanPartitionDefContext) VALUES() antlr.TerminalNode { + return s.GetToken(DorisParserVALUES, 0) +} + +func (s *LessThanPartitionDefContext) LESS() antlr.TerminalNode { + return s.GetToken(DorisParserLESS, 0) +} + +func (s *LessThanPartitionDefContext) THAN() antlr.TerminalNode { + return s.GetToken(DorisParserTHAN, 0) +} + +func (s *LessThanPartitionDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *LessThanPartitionDefContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(DorisParserMAXVALUE, 0) +} + +func (s *LessThanPartitionDefContext) PartitionValueList() IPartitionValueListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionValueListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionValueListContext) +} + +func (s *LessThanPartitionDefContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *LessThanPartitionDefContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *LessThanPartitionDefContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *LessThanPartitionDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LessThanPartitionDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LessThanPartitionDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLessThanPartitionDef(s) + } +} + +func (s *LessThanPartitionDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLessThanPartitionDef(s) + } +} + +func (s *LessThanPartitionDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLessThanPartitionDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) LessThanPartitionDef() (localctx ILessThanPartitionDefContext) { + localctx = NewLessThanPartitionDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, DorisParserRULE_lessThanPartitionDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5806) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(5807) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5808) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5809) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5812) + + var _x = p.Identifier() + + localctx.(*LessThanPartitionDefContext).partitionName = _x + } + { + p.SetState(5813) + p.Match(DorisParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5814) + p.Match(DorisParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5815) + p.Match(DorisParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserMAXVALUE: + { + p.SetState(5816) + p.Match(DorisParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserLEFT_PAREN: + { + p.SetState(5817) + p.PartitionValueList() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFixedPartitionDefContext is an interface to support dynamic dispatch. +type IFixedPartitionDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartitionName returns the partitionName rule contexts. + GetPartitionName() IIdentifierContext + + // GetLower returns the lower rule contexts. + GetLower() IPartitionValueListContext + + // GetUpper returns the upper rule contexts. + GetUpper() IPartitionValueListContext + + // SetPartitionName sets the partitionName rule contexts. + SetPartitionName(IIdentifierContext) + + // SetLower sets the lower rule contexts. + SetLower(IPartitionValueListContext) + + // SetUpper sets the upper rule contexts. + SetUpper(IPartitionValueListContext) + + // Getter signatures + PARTITION() antlr.TerminalNode + VALUES() antlr.TerminalNode + LEFT_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Identifier() IIdentifierContext + AllPartitionValueList() []IPartitionValueListContext + PartitionValueList(i int) IPartitionValueListContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsFixedPartitionDefContext differentiates from other interfaces. + IsFixedPartitionDefContext() +} + +type FixedPartitionDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitionName IIdentifierContext + lower IPartitionValueListContext + upper IPartitionValueListContext +} + +func NewEmptyFixedPartitionDefContext() *FixedPartitionDefContext { + var p = new(FixedPartitionDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_fixedPartitionDef + return p +} + +func InitEmptyFixedPartitionDefContext(p *FixedPartitionDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_fixedPartitionDef +} + +func (*FixedPartitionDefContext) IsFixedPartitionDefContext() {} + +func NewFixedPartitionDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FixedPartitionDefContext { + var p = new(FixedPartitionDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_fixedPartitionDef + + return p +} + +func (s *FixedPartitionDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *FixedPartitionDefContext) GetPartitionName() IIdentifierContext { return s.partitionName } + +func (s *FixedPartitionDefContext) GetLower() IPartitionValueListContext { return s.lower } + +func (s *FixedPartitionDefContext) GetUpper() IPartitionValueListContext { return s.upper } + +func (s *FixedPartitionDefContext) SetPartitionName(v IIdentifierContext) { s.partitionName = v } + +func (s *FixedPartitionDefContext) SetLower(v IPartitionValueListContext) { s.lower = v } + +func (s *FixedPartitionDefContext) SetUpper(v IPartitionValueListContext) { s.upper = v } + +func (s *FixedPartitionDefContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *FixedPartitionDefContext) VALUES() antlr.TerminalNode { + return s.GetToken(DorisParserVALUES, 0) +} + +func (s *FixedPartitionDefContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *FixedPartitionDefContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *FixedPartitionDefContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *FixedPartitionDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *FixedPartitionDefContext) AllPartitionValueList() []IPartitionValueListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionValueListContext); ok { + len++ + } + } + + tst := make([]IPartitionValueListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionValueListContext); ok { + tst[i] = t.(IPartitionValueListContext) + i++ + } + } + + return tst +} + +func (s *FixedPartitionDefContext) PartitionValueList(i int) IPartitionValueListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionValueListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionValueListContext) +} + +func (s *FixedPartitionDefContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *FixedPartitionDefContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *FixedPartitionDefContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *FixedPartitionDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FixedPartitionDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FixedPartitionDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFixedPartitionDef(s) + } +} + +func (s *FixedPartitionDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFixedPartitionDef(s) + } +} + +func (s *FixedPartitionDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFixedPartitionDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FixedPartitionDef() (localctx IFixedPartitionDefContext) { + localctx = NewFixedPartitionDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, DorisParserRULE_fixedPartitionDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5820) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(5821) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5822) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5823) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5826) + + var _x = p.Identifier() + + localctx.(*FixedPartitionDefContext).partitionName = _x + } + { + p.SetState(5827) + p.Match(DorisParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5828) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5829) + + var _x = p.PartitionValueList() + + localctx.(*FixedPartitionDefContext).lower = _x + } + { + p.SetState(5830) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5831) + + var _x = p.PartitionValueList() + + localctx.(*FixedPartitionDefContext).upper = _x + } + { + p.SetState(5832) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStepPartitionDefContext is an interface to support dynamic dispatch. +type IStepPartitionDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUnitsAmount returns the unitsAmount token. + GetUnitsAmount() antlr.Token + + // SetUnitsAmount sets the unitsAmount token. + SetUnitsAmount(antlr.Token) + + // GetFrom returns the from rule contexts. + GetFrom() IPartitionValueListContext + + // GetTo returns the to rule contexts. + GetTo() IPartitionValueListContext + + // GetUnit returns the unit rule contexts. + GetUnit() IUnitIdentifierContext + + // SetFrom sets the from rule contexts. + SetFrom(IPartitionValueListContext) + + // SetTo sets the to rule contexts. + SetTo(IPartitionValueListContext) + + // SetUnit sets the unit rule contexts. + SetUnit(IUnitIdentifierContext) + + // Getter signatures + FROM() antlr.TerminalNode + TO() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + AllPartitionValueList() []IPartitionValueListContext + PartitionValueList(i int) IPartitionValueListContext + INTEGER_VALUE() antlr.TerminalNode + UnitIdentifier() IUnitIdentifierContext + + // IsStepPartitionDefContext differentiates from other interfaces. + IsStepPartitionDefContext() +} + +type StepPartitionDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + from IPartitionValueListContext + to IPartitionValueListContext + unitsAmount antlr.Token + unit IUnitIdentifierContext +} + +func NewEmptyStepPartitionDefContext() *StepPartitionDefContext { + var p = new(StepPartitionDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_stepPartitionDef + return p +} + +func InitEmptyStepPartitionDefContext(p *StepPartitionDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_stepPartitionDef +} + +func (*StepPartitionDefContext) IsStepPartitionDefContext() {} + +func NewStepPartitionDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StepPartitionDefContext { + var p = new(StepPartitionDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_stepPartitionDef + + return p +} + +func (s *StepPartitionDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *StepPartitionDefContext) GetUnitsAmount() antlr.Token { return s.unitsAmount } + +func (s *StepPartitionDefContext) SetUnitsAmount(v antlr.Token) { s.unitsAmount = v } + +func (s *StepPartitionDefContext) GetFrom() IPartitionValueListContext { return s.from } + +func (s *StepPartitionDefContext) GetTo() IPartitionValueListContext { return s.to } + +func (s *StepPartitionDefContext) GetUnit() IUnitIdentifierContext { return s.unit } + +func (s *StepPartitionDefContext) SetFrom(v IPartitionValueListContext) { s.from = v } + +func (s *StepPartitionDefContext) SetTo(v IPartitionValueListContext) { s.to = v } + +func (s *StepPartitionDefContext) SetUnit(v IUnitIdentifierContext) { s.unit = v } + +func (s *StepPartitionDefContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *StepPartitionDefContext) TO() antlr.TerminalNode { + return s.GetToken(DorisParserTO, 0) +} + +func (s *StepPartitionDefContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(DorisParserINTERVAL, 0) +} + +func (s *StepPartitionDefContext) AllPartitionValueList() []IPartitionValueListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionValueListContext); ok { + len++ + } + } + + tst := make([]IPartitionValueListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionValueListContext); ok { + tst[i] = t.(IPartitionValueListContext) + i++ + } + } + + return tst +} + +func (s *StepPartitionDefContext) PartitionValueList(i int) IPartitionValueListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionValueListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionValueListContext) +} + +func (s *StepPartitionDefContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *StepPartitionDefContext) UnitIdentifier() IUnitIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnitIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnitIdentifierContext) +} + +func (s *StepPartitionDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StepPartitionDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StepPartitionDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStepPartitionDef(s) + } +} + +func (s *StepPartitionDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStepPartitionDef(s) + } +} + +func (s *StepPartitionDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStepPartitionDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) StepPartitionDef() (localctx IStepPartitionDefContext) { + localctx = NewStepPartitionDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, DorisParserRULE_stepPartitionDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5834) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5835) + + var _x = p.PartitionValueList() + + localctx.(*StepPartitionDefContext).from = _x + } + { + p.SetState(5836) + p.Match(DorisParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5837) + + var _x = p.PartitionValueList() + + localctx.(*StepPartitionDefContext).to = _x + } + { + p.SetState(5838) + p.Match(DorisParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5839) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*StepPartitionDefContext).unitsAmount = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-123)) & ^0x3f) == 0 && ((int64(1)<<(_la-123))&11) != 0) || _la == DorisParserHOUR || ((int64((_la-308)) & ^0x3f) == 0 && ((int64(1)<<(_la-308))&21) != 0) || _la == DorisParserQUARTER || _la == DorisParserSECOND || _la == DorisParserWEEK || _la == DorisParserYEAR { + { + p.SetState(5840) + + var _x = p.UnitIdentifier() + + localctx.(*StepPartitionDefContext).unit = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInPartitionDefContext is an interface to support dynamic dispatch. +type IInPartitionDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartitionName returns the partitionName rule contexts. + GetPartitionName() IIdentifierContext + + // Get_partitionValueList returns the _partitionValueList rule contexts. + Get_partitionValueList() IPartitionValueListContext + + // GetConstants returns the constants rule contexts. + GetConstants() IPartitionValueListContext + + // SetPartitionName sets the partitionName rule contexts. + SetPartitionName(IIdentifierContext) + + // Set_partitionValueList sets the _partitionValueList rule contexts. + Set_partitionValueList(IPartitionValueListContext) + + // SetConstants sets the constants rule contexts. + SetConstants(IPartitionValueListContext) + + // GetPartitionValueLists returns the partitionValueLists rule context list. + GetPartitionValueLists() []IPartitionValueListContext + + // SetPartitionValueLists sets the partitionValueLists rule context list. + SetPartitionValueLists([]IPartitionValueListContext) + + // Getter signatures + PARTITION() antlr.TerminalNode + Identifier() IIdentifierContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + VALUES() antlr.TerminalNode + IN() antlr.TerminalNode + AllPartitionValueList() []IPartitionValueListContext + PartitionValueList(i int) IPartitionValueListContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInPartitionDefContext differentiates from other interfaces. + IsInPartitionDefContext() +} + +type InPartitionDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partitionName IIdentifierContext + _partitionValueList IPartitionValueListContext + partitionValueLists []IPartitionValueListContext + constants IPartitionValueListContext +} + +func NewEmptyInPartitionDefContext() *InPartitionDefContext { + var p = new(InPartitionDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_inPartitionDef + return p +} + +func InitEmptyInPartitionDefContext(p *InPartitionDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_inPartitionDef +} + +func (*InPartitionDefContext) IsInPartitionDefContext() {} + +func NewInPartitionDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InPartitionDefContext { + var p = new(InPartitionDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_inPartitionDef + + return p +} + +func (s *InPartitionDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *InPartitionDefContext) GetPartitionName() IIdentifierContext { return s.partitionName } + +func (s *InPartitionDefContext) Get_partitionValueList() IPartitionValueListContext { + return s._partitionValueList +} + +func (s *InPartitionDefContext) GetConstants() IPartitionValueListContext { return s.constants } + +func (s *InPartitionDefContext) SetPartitionName(v IIdentifierContext) { s.partitionName = v } + +func (s *InPartitionDefContext) Set_partitionValueList(v IPartitionValueListContext) { + s._partitionValueList = v +} + +func (s *InPartitionDefContext) SetConstants(v IPartitionValueListContext) { s.constants = v } + +func (s *InPartitionDefContext) GetPartitionValueLists() []IPartitionValueListContext { + return s.partitionValueLists +} + +func (s *InPartitionDefContext) SetPartitionValueLists(v []IPartitionValueListContext) { + s.partitionValueLists = v +} + +func (s *InPartitionDefContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *InPartitionDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *InPartitionDefContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *InPartitionDefContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *InPartitionDefContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *InPartitionDefContext) VALUES() antlr.TerminalNode { + return s.GetToken(DorisParserVALUES, 0) +} + +func (s *InPartitionDefContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *InPartitionDefContext) AllPartitionValueList() []IPartitionValueListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionValueListContext); ok { + len++ + } + } + + tst := make([]IPartitionValueListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionValueListContext); ok { + tst[i] = t.(IPartitionValueListContext) + i++ + } + } + + return tst +} + +func (s *InPartitionDefContext) PartitionValueList(i int) IPartitionValueListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionValueListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionValueListContext) +} + +func (s *InPartitionDefContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *InPartitionDefContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *InPartitionDefContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *InPartitionDefContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *InPartitionDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InPartitionDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InPartitionDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterInPartitionDef(s) + } +} + +func (s *InPartitionDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitInPartitionDef(s) + } +} + +func (s *InPartitionDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitInPartitionDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) InPartitionDef() (localctx IInPartitionDefContext) { + localctx = NewInPartitionDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, DorisParserRULE_inPartitionDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5843) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserIF { + { + p.SetState(5844) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5845) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5846) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5849) + + var _x = p.Identifier() + + localctx.(*InPartitionDefContext).partitionName = _x + } + p.SetState(5868) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 845, p.GetParserRuleContext()) == 1 { + p.SetState(5852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserVALUES { + { + p.SetState(5850) + p.Match(DorisParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5851) + p.Match(DorisParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 844, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5854) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5855) + + var _x = p.PartitionValueList() + + localctx.(*InPartitionDefContext)._partitionValueList = _x + } + localctx.(*InPartitionDefContext).partitionValueLists = append(localctx.(*InPartitionDefContext).partitionValueLists, localctx.(*InPartitionDefContext)._partitionValueList) + p.SetState(5860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5856) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5857) + + var _x = p.PartitionValueList() + + localctx.(*InPartitionDefContext)._partitionValueList = _x + } + localctx.(*InPartitionDefContext).partitionValueLists = append(localctx.(*InPartitionDefContext).partitionValueLists, localctx.(*InPartitionDefContext)._partitionValueList) + + p.SetState(5862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5863) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5865) + + var _x = p.PartitionValueList() + + localctx.(*InPartitionDefContext).constants = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionValueListContext is an interface to support dynamic dispatch. +type IPartitionValueListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_partitionValueDef returns the _partitionValueDef rule contexts. + Get_partitionValueDef() IPartitionValueDefContext + + // Set_partitionValueDef sets the _partitionValueDef rule contexts. + Set_partitionValueDef(IPartitionValueDefContext) + + // GetValues returns the values rule context list. + GetValues() []IPartitionValueDefContext + + // SetValues sets the values rule context list. + SetValues([]IPartitionValueDefContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllPartitionValueDef() []IPartitionValueDefContext + PartitionValueDef(i int) IPartitionValueDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartitionValueListContext differentiates from other interfaces. + IsPartitionValueListContext() +} + +type PartitionValueListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _partitionValueDef IPartitionValueDefContext + values []IPartitionValueDefContext +} + +func NewEmptyPartitionValueListContext() *PartitionValueListContext { + var p = new(PartitionValueListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionValueList + return p +} + +func InitEmptyPartitionValueListContext(p *PartitionValueListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionValueList +} + +func (*PartitionValueListContext) IsPartitionValueListContext() {} + +func NewPartitionValueListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionValueListContext { + var p = new(PartitionValueListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionValueList + + return p +} + +func (s *PartitionValueListContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionValueListContext) Get_partitionValueDef() IPartitionValueDefContext { + return s._partitionValueDef +} + +func (s *PartitionValueListContext) Set_partitionValueDef(v IPartitionValueDefContext) { + s._partitionValueDef = v +} + +func (s *PartitionValueListContext) GetValues() []IPartitionValueDefContext { return s.values } + +func (s *PartitionValueListContext) SetValues(v []IPartitionValueDefContext) { s.values = v } + +func (s *PartitionValueListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PartitionValueListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PartitionValueListContext) AllPartitionValueDef() []IPartitionValueDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionValueDefContext); ok { + len++ + } + } + + tst := make([]IPartitionValueDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionValueDefContext); ok { + tst[i] = t.(IPartitionValueDefContext) + i++ + } + } + + return tst +} + +func (s *PartitionValueListContext) PartitionValueDef(i int) IPartitionValueDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionValueDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionValueDefContext) +} + +func (s *PartitionValueListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PartitionValueListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PartitionValueListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionValueListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionValueListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionValueList(s) + } +} + +func (s *PartitionValueListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionValueList(s) + } +} + +func (s *PartitionValueListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionValueList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionValueList() (localctx IPartitionValueListContext) { + localctx = NewPartitionValueListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, DorisParserRULE_partitionValueList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5870) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5871) + + var _x = p.PartitionValueDef() + + localctx.(*PartitionValueListContext)._partitionValueDef = _x + } + localctx.(*PartitionValueListContext).values = append(localctx.(*PartitionValueListContext).values, localctx.(*PartitionValueListContext)._partitionValueDef) + p.SetState(5876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5872) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5873) + + var _x = p.PartitionValueDef() + + localctx.(*PartitionValueListContext)._partitionValueDef = _x + } + localctx.(*PartitionValueListContext).values = append(localctx.(*PartitionValueListContext).values, localctx.(*PartitionValueListContext)._partitionValueDef) + + p.SetState(5878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5879) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionValueDefContext is an interface to support dynamic dispatch. +type IPartitionValueDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTEGER_VALUE() antlr.TerminalNode + SUBTRACT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + NULL() antlr.TerminalNode + + // IsPartitionValueDefContext differentiates from other interfaces. + IsPartitionValueDefContext() +} + +type PartitionValueDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionValueDefContext() *PartitionValueDefContext { + var p = new(PartitionValueDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionValueDef + return p +} + +func InitEmptyPartitionValueDefContext(p *PartitionValueDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_partitionValueDef +} + +func (*PartitionValueDefContext) IsPartitionValueDefContext() {} + +func NewPartitionValueDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionValueDefContext { + var p = new(PartitionValueDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_partitionValueDef + + return p +} + +func (s *PartitionValueDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionValueDefContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *PartitionValueDefContext) SUBTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, 0) +} + +func (s *PartitionValueDefContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *PartitionValueDefContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(DorisParserMAXVALUE, 0) +} + +func (s *PartitionValueDefContext) NULL() antlr.TerminalNode { + return s.GetToken(DorisParserNULL, 0) +} + +func (s *PartitionValueDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionValueDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionValueDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPartitionValueDef(s) + } +} + +func (s *PartitionValueDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPartitionValueDef(s) + } +} + +func (s *PartitionValueDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPartitionValueDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PartitionValueDef() (localctx IPartitionValueDefContext) { + localctx = NewPartitionValueDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, DorisParserRULE_partitionValueDef) + var _la int + + p.SetState(5888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserSUBTRACT, DorisParserINTEGER_VALUE: + p.EnterOuterAlt(localctx, 1) + p.SetState(5882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSUBTRACT { + { + p.SetState(5881) + p.Match(DorisParserSUBTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5884) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5885) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserMAXVALUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5886) + p.Match(DorisParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserNULL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5887) + p.Match(DorisParserNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollupDefsContext is an interface to support dynamic dispatch. +type IRollupDefsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_rollupDef returns the _rollupDef rule contexts. + Get_rollupDef() IRollupDefContext + + // Set_rollupDef sets the _rollupDef rule contexts. + Set_rollupDef(IRollupDefContext) + + // GetRollups returns the rollups rule context list. + GetRollups() []IRollupDefContext + + // SetRollups sets the rollups rule context list. + SetRollups([]IRollupDefContext) + + // Getter signatures + AllRollupDef() []IRollupDefContext + RollupDef(i int) IRollupDefContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRollupDefsContext differentiates from other interfaces. + IsRollupDefsContext() +} + +type RollupDefsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _rollupDef IRollupDefContext + rollups []IRollupDefContext +} + +func NewEmptyRollupDefsContext() *RollupDefsContext { + var p = new(RollupDefsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rollupDefs + return p +} + +func InitEmptyRollupDefsContext(p *RollupDefsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rollupDefs +} + +func (*RollupDefsContext) IsRollupDefsContext() {} + +func NewRollupDefsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollupDefsContext { + var p = new(RollupDefsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_rollupDefs + + return p +} + +func (s *RollupDefsContext) GetParser() antlr.Parser { return s.parser } + +func (s *RollupDefsContext) Get_rollupDef() IRollupDefContext { return s._rollupDef } + +func (s *RollupDefsContext) Set_rollupDef(v IRollupDefContext) { s._rollupDef = v } + +func (s *RollupDefsContext) GetRollups() []IRollupDefContext { return s.rollups } + +func (s *RollupDefsContext) SetRollups(v []IRollupDefContext) { s.rollups = v } + +func (s *RollupDefsContext) AllRollupDef() []IRollupDefContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRollupDefContext); ok { + len++ + } + } + + tst := make([]IRollupDefContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRollupDefContext); ok { + tst[i] = t.(IRollupDefContext) + i++ + } + } + + return tst +} + +func (s *RollupDefsContext) RollupDef(i int) IRollupDefContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollupDefContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRollupDefContext) +} + +func (s *RollupDefsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *RollupDefsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *RollupDefsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RollupDefsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RollupDefsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRollupDefs(s) + } +} + +func (s *RollupDefsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRollupDefs(s) + } +} + +func (s *RollupDefsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRollupDefs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RollupDefs() (localctx IRollupDefsContext) { + localctx = NewRollupDefsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, DorisParserRULE_rollupDefs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5890) + + var _x = p.RollupDef() + + localctx.(*RollupDefsContext)._rollupDef = _x + } + localctx.(*RollupDefsContext).rollups = append(localctx.(*RollupDefsContext).rollups, localctx.(*RollupDefsContext)._rollupDef) + p.SetState(5895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5891) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5892) + + var _x = p.RollupDef() + + localctx.(*RollupDefsContext)._rollupDef = _x + } + localctx.(*RollupDefsContext).rollups = append(localctx.(*RollupDefsContext).rollups, localctx.(*RollupDefsContext)._rollupDef) + + p.SetState(5897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollupDefContext is an interface to support dynamic dispatch. +type IRollupDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRollupName returns the rollupName rule contexts. + GetRollupName() IIdentifierContext + + // GetRollupCols returns the rollupCols rule contexts. + GetRollupCols() IIdentifierListContext + + // GetDupKeys returns the dupKeys rule contexts. + GetDupKeys() IIdentifierListContext + + // GetProperties returns the properties rule contexts. + GetProperties() IPropertyClauseContext + + // SetRollupName sets the rollupName rule contexts. + SetRollupName(IIdentifierContext) + + // SetRollupCols sets the rollupCols rule contexts. + SetRollupCols(IIdentifierListContext) + + // SetDupKeys sets the dupKeys rule contexts. + SetDupKeys(IIdentifierListContext) + + // SetProperties sets the properties rule contexts. + SetProperties(IPropertyClauseContext) + + // Getter signatures + Identifier() IIdentifierContext + AllIdentifierList() []IIdentifierListContext + IdentifierList(i int) IIdentifierListContext + DUPLICATE() antlr.TerminalNode + KEY() antlr.TerminalNode + PropertyClause() IPropertyClauseContext + + // IsRollupDefContext differentiates from other interfaces. + IsRollupDefContext() +} + +type RollupDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rollupName IIdentifierContext + rollupCols IIdentifierListContext + dupKeys IIdentifierListContext + properties IPropertyClauseContext +} + +func NewEmptyRollupDefContext() *RollupDefContext { + var p = new(RollupDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rollupDef + return p +} + +func InitEmptyRollupDefContext(p *RollupDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rollupDef +} + +func (*RollupDefContext) IsRollupDefContext() {} + +func NewRollupDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollupDefContext { + var p = new(RollupDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_rollupDef + + return p +} + +func (s *RollupDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *RollupDefContext) GetRollupName() IIdentifierContext { return s.rollupName } + +func (s *RollupDefContext) GetRollupCols() IIdentifierListContext { return s.rollupCols } + +func (s *RollupDefContext) GetDupKeys() IIdentifierListContext { return s.dupKeys } + +func (s *RollupDefContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *RollupDefContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } + +func (s *RollupDefContext) SetRollupCols(v IIdentifierListContext) { s.rollupCols = v } + +func (s *RollupDefContext) SetDupKeys(v IIdentifierListContext) { s.dupKeys = v } + +func (s *RollupDefContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *RollupDefContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RollupDefContext) AllIdentifierList() []IIdentifierListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierListContext); ok { + len++ + } + } + + tst := make([]IIdentifierListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierListContext); ok { + tst[i] = t.(IIdentifierListContext) + i++ + } + } + + return tst +} + +func (s *RollupDefContext) IdentifierList(i int) IIdentifierListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *RollupDefContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(DorisParserDUPLICATE, 0) +} + +func (s *RollupDefContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *RollupDefContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *RollupDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RollupDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RollupDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRollupDef(s) + } +} + +func (s *RollupDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRollupDef(s) + } +} + +func (s *RollupDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRollupDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RollupDef() (localctx IRollupDefContext) { + localctx = NewRollupDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, DorisParserRULE_rollupDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5898) + + var _x = p.Identifier() + + localctx.(*RollupDefContext).rollupName = _x + } + { + p.SetState(5899) + + var _x = p.IdentifierList() + + localctx.(*RollupDefContext).rollupCols = _x + } + p.SetState(5903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserDUPLICATE { + { + p.SetState(5900) + p.Match(DorisParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5901) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5902) + + var _x = p.IdentifierList() + + localctx.(*RollupDefContext).dupKeys = _x + } + + } + p.SetState(5906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPROPERTIES { + { + p.SetState(5905) + + var _x = p.PropertyClause() + + localctx.(*RollupDefContext).properties = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggTypeDefContext is an interface to support dynamic dispatch. +type IAggTypeDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAX() antlr.TerminalNode + MIN() antlr.TerminalNode + SUM() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REPLACE_IF_NOT_NULL() antlr.TerminalNode + HLL_UNION() antlr.TerminalNode + BITMAP_UNION() antlr.TerminalNode + QUANTILE_UNION() antlr.TerminalNode + GENERIC() antlr.TerminalNode + + // IsAggTypeDefContext differentiates from other interfaces. + IsAggTypeDefContext() +} + +type AggTypeDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggTypeDefContext() *AggTypeDefContext { + var p = new(AggTypeDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_aggTypeDef + return p +} + +func InitEmptyAggTypeDefContext(p *AggTypeDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_aggTypeDef +} + +func (*AggTypeDefContext) IsAggTypeDefContext() {} + +func NewAggTypeDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggTypeDefContext { + var p = new(AggTypeDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_aggTypeDef + + return p +} + +func (s *AggTypeDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *AggTypeDefContext) MAX() antlr.TerminalNode { + return s.GetToken(DorisParserMAX, 0) +} + +func (s *AggTypeDefContext) MIN() antlr.TerminalNode { + return s.GetToken(DorisParserMIN, 0) +} + +func (s *AggTypeDefContext) SUM() antlr.TerminalNode { + return s.GetToken(DorisParserSUM, 0) +} + +func (s *AggTypeDefContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *AggTypeDefContext) REPLACE_IF_NOT_NULL() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE_IF_NOT_NULL, 0) +} + +func (s *AggTypeDefContext) HLL_UNION() antlr.TerminalNode { + return s.GetToken(DorisParserHLL_UNION, 0) +} + +func (s *AggTypeDefContext) BITMAP_UNION() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP_UNION, 0) +} + +func (s *AggTypeDefContext) QUANTILE_UNION() antlr.TerminalNode { + return s.GetToken(DorisParserQUANTILE_UNION, 0) +} + +func (s *AggTypeDefContext) GENERIC() antlr.TerminalNode { + return s.GetToken(DorisParserGENERIC, 0) +} + +func (s *AggTypeDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AggTypeDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AggTypeDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAggTypeDef(s) + } +} + +func (s *AggTypeDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAggTypeDef(s) + } +} + +func (s *AggTypeDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAggTypeDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) AggTypeDef() (localctx IAggTypeDefContext) { + localctx = NewAggTypeDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, DorisParserRULE_aggTypeDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5908) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBITMAP_UNION || _la == DorisParserGENERIC || _la == DorisParserHLL_UNION || _la == DorisParserMAX || _la == DorisParserMIN || ((int64((_la-378)) & ^0x3f) == 0 && ((int64(1)<<(_la-378))&6291457) != 0) || _la == DorisParserSUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITabletListContext is an interface to support dynamic dispatch. +type ITabletListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_INTEGER_VALUE returns the _INTEGER_VALUE token. + Get_INTEGER_VALUE() antlr.Token + + // Set_INTEGER_VALUE sets the _INTEGER_VALUE token. + Set_INTEGER_VALUE(antlr.Token) + + // GetTabletIdList returns the tabletIdList token list. + GetTabletIdList() []antlr.Token + + // SetTabletIdList sets the tabletIdList token list. + SetTabletIdList([]antlr.Token) + + // Getter signatures + TABLET() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllINTEGER_VALUE() []antlr.TerminalNode + INTEGER_VALUE(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTabletListContext differentiates from other interfaces. + IsTabletListContext() +} + +type TabletListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _INTEGER_VALUE antlr.Token + tabletIdList []antlr.Token +} + +func NewEmptyTabletListContext() *TabletListContext { + var p = new(TabletListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tabletList + return p +} + +func InitEmptyTabletListContext(p *TabletListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tabletList +} + +func (*TabletListContext) IsTabletListContext() {} + +func NewTabletListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TabletListContext { + var p = new(TabletListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_tabletList + + return p +} + +func (s *TabletListContext) GetParser() antlr.Parser { return s.parser } + +func (s *TabletListContext) Get_INTEGER_VALUE() antlr.Token { return s._INTEGER_VALUE } + +func (s *TabletListContext) Set_INTEGER_VALUE(v antlr.Token) { s._INTEGER_VALUE = v } + +func (s *TabletListContext) GetTabletIdList() []antlr.Token { return s.tabletIdList } + +func (s *TabletListContext) SetTabletIdList(v []antlr.Token) { s.tabletIdList = v } + +func (s *TabletListContext) TABLET() antlr.TerminalNode { + return s.GetToken(DorisParserTABLET, 0) +} + +func (s *TabletListContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *TabletListContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *TabletListContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *TabletListContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *TabletListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *TabletListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *TabletListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TabletListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TabletListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTabletList(s) + } +} + +func (s *TabletListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTabletList(s) + } +} + +func (s *TabletListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTabletList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TabletList() (localctx ITabletListContext) { + localctx = NewTabletListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, DorisParserRULE_tabletList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5910) + p.Match(DorisParserTABLET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5911) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5912) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*TabletListContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*TabletListContext).tabletIdList = append(localctx.(*TabletListContext).tabletIdList, localctx.(*TabletListContext)._INTEGER_VALUE) + p.SetState(5917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(5913) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5914) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*TabletListContext)._INTEGER_VALUE = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + localctx.(*TabletListContext).tabletIdList = append(localctx.(*TabletListContext).tabletIdList, localctx.(*TabletListContext)._INTEGER_VALUE) + + p.SetState(5919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5920) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInlineTableContext is an interface to support dynamic dispatch. +type IInlineTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + AllRowConstructor() []IRowConstructorContext + RowConstructor(i int) IRowConstructorContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInlineTableContext differentiates from other interfaces. + IsInlineTableContext() +} + +type InlineTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInlineTableContext() *InlineTableContext { + var p = new(InlineTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_inlineTable + return p +} + +func InitEmptyInlineTableContext(p *InlineTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_inlineTable +} + +func (*InlineTableContext) IsInlineTableContext() {} + +func NewInlineTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InlineTableContext { + var p = new(InlineTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_inlineTable + + return p +} + +func (s *InlineTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *InlineTableContext) VALUES() antlr.TerminalNode { + return s.GetToken(DorisParserVALUES, 0) +} + +func (s *InlineTableContext) AllRowConstructor() []IRowConstructorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRowConstructorContext); ok { + len++ + } + } + + tst := make([]IRowConstructorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRowConstructorContext); ok { + tst[i] = t.(IRowConstructorContext) + i++ + } + } + + return tst +} + +func (s *InlineTableContext) RowConstructor(i int) IRowConstructorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowConstructorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRowConstructorContext) +} + +func (s *InlineTableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *InlineTableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *InlineTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InlineTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InlineTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterInlineTable(s) + } +} + +func (s *InlineTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitInlineTable(s) + } +} + +func (s *InlineTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitInlineTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) InlineTable() (localctx IInlineTableContext) { + localctx = NewInlineTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, DorisParserRULE_inlineTable) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5922) + p.Match(DorisParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5923) + p.RowConstructor() + } + p.SetState(5928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 853, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5924) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5925) + p.RowConstructor() + } + + } + p.SetState(5930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 853, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INamedExpressionContext is an interface to support dynamic dispatch. +type INamedExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + IdentifierOrText() IIdentifierOrTextContext + AS() antlr.TerminalNode + + // IsNamedExpressionContext differentiates from other interfaces. + IsNamedExpressionContext() +} + +type NamedExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNamedExpressionContext() *NamedExpressionContext { + var p = new(NamedExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_namedExpression + return p +} + +func InitEmptyNamedExpressionContext(p *NamedExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_namedExpression +} + +func (*NamedExpressionContext) IsNamedExpressionContext() {} + +func NewNamedExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedExpressionContext { + var p = new(NamedExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_namedExpression + + return p +} + +func (s *NamedExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *NamedExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NamedExpressionContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *NamedExpressionContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *NamedExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NamedExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NamedExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterNamedExpression(s) + } +} + +func (s *NamedExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitNamedExpression(s) + } +} + +func (s *NamedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitNamedExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) NamedExpression() (localctx INamedExpressionContext) { + localctx = NewNamedExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, DorisParserRULE_namedExpression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5931) + p.Expression() + } + p.SetState(5936) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 855, p.GetParserRuleContext()) == 1 { + p.SetState(5933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserAS { + { + p.SetState(5932) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + { + p.SetState(5935) + p.IdentifierOrText() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INamedExpressionSeqContext is an interface to support dynamic dispatch. +type INamedExpressionSeqContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllNamedExpression() []INamedExpressionContext + NamedExpression(i int) INamedExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsNamedExpressionSeqContext differentiates from other interfaces. + IsNamedExpressionSeqContext() +} + +type NamedExpressionSeqContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNamedExpressionSeqContext() *NamedExpressionSeqContext { + var p = new(NamedExpressionSeqContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_namedExpressionSeq + return p +} + +func InitEmptyNamedExpressionSeqContext(p *NamedExpressionSeqContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_namedExpressionSeq +} + +func (*NamedExpressionSeqContext) IsNamedExpressionSeqContext() {} + +func NewNamedExpressionSeqContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedExpressionSeqContext { + var p = new(NamedExpressionSeqContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_namedExpressionSeq + + return p +} + +func (s *NamedExpressionSeqContext) GetParser() antlr.Parser { return s.parser } + +func (s *NamedExpressionSeqContext) AllNamedExpression() []INamedExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INamedExpressionContext); ok { + len++ + } + } + + tst := make([]INamedExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INamedExpressionContext); ok { + tst[i] = t.(INamedExpressionContext) + i++ + } + } + + return tst +} + +func (s *NamedExpressionSeqContext) NamedExpression(i int) INamedExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamedExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INamedExpressionContext) +} + +func (s *NamedExpressionSeqContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *NamedExpressionSeqContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *NamedExpressionSeqContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NamedExpressionSeqContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NamedExpressionSeqContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterNamedExpressionSeq(s) + } +} + +func (s *NamedExpressionSeqContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitNamedExpressionSeq(s) + } +} + +func (s *NamedExpressionSeqContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitNamedExpressionSeq(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) NamedExpressionSeq() (localctx INamedExpressionSeqContext) { + localctx = NewNamedExpressionSeqContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, DorisParserRULE_namedExpressionSeq) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5938) + p.NamedExpression() + } + p.SetState(5943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 856, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5939) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5940) + p.NamedExpression() + } + + } + p.SetState(5945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 856, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BooleanExpression() IBooleanExpressionContext + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Expression() (localctx IExpressionContext) { + localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, DorisParserRULE_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5946) + p.booleanExpression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFuncExpressionContext is an interface to support dynamic dispatch. +type IFuncExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + LambdaExpression() ILambdaExpressionContext + + // IsFuncExpressionContext differentiates from other interfaces. + IsFuncExpressionContext() +} + +type FuncExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFuncExpressionContext() *FuncExpressionContext { + var p = new(FuncExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_funcExpression + return p +} + +func InitEmptyFuncExpressionContext(p *FuncExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_funcExpression +} + +func (*FuncExpressionContext) IsFuncExpressionContext() {} + +func NewFuncExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FuncExpressionContext { + var p = new(FuncExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_funcExpression + + return p +} + +func (s *FuncExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *FuncExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FuncExpressionContext) LambdaExpression() ILambdaExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILambdaExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILambdaExpressionContext) +} + +func (s *FuncExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FuncExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FuncExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFuncExpression(s) + } +} + +func (s *FuncExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFuncExpression(s) + } +} + +func (s *FuncExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFuncExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FuncExpression() (localctx IFuncExpressionContext) { + localctx = NewFuncExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, DorisParserRULE_funcExpression) + p.SetState(5950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 857, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5948) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5949) + p.LambdaExpression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILambdaExpressionContext is an interface to support dynamic dispatch. +type ILambdaExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_errorCapturingIdentifier returns the _errorCapturingIdentifier rule contexts. + Get_errorCapturingIdentifier() IErrorCapturingIdentifierContext + + // GetBody returns the body rule contexts. + GetBody() IBooleanExpressionContext + + // Set_errorCapturingIdentifier sets the _errorCapturingIdentifier rule contexts. + Set_errorCapturingIdentifier(IErrorCapturingIdentifierContext) + + // SetBody sets the body rule contexts. + SetBody(IBooleanExpressionContext) + + // GetArgs returns the args rule context list. + GetArgs() []IErrorCapturingIdentifierContext + + // SetArgs sets the args rule context list. + SetArgs([]IErrorCapturingIdentifierContext) + + // Getter signatures + ARROW() antlr.TerminalNode + AllErrorCapturingIdentifier() []IErrorCapturingIdentifierContext + ErrorCapturingIdentifier(i int) IErrorCapturingIdentifierContext + BooleanExpression() IBooleanExpressionContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLambdaExpressionContext differentiates from other interfaces. + IsLambdaExpressionContext() +} + +type LambdaExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _errorCapturingIdentifier IErrorCapturingIdentifierContext + args []IErrorCapturingIdentifierContext + body IBooleanExpressionContext +} + +func NewEmptyLambdaExpressionContext() *LambdaExpressionContext { + var p = new(LambdaExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lambdaExpression + return p +} + +func InitEmptyLambdaExpressionContext(p *LambdaExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_lambdaExpression +} + +func (*LambdaExpressionContext) IsLambdaExpressionContext() {} + +func NewLambdaExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LambdaExpressionContext { + var p = new(LambdaExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_lambdaExpression + + return p +} + +func (s *LambdaExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *LambdaExpressionContext) Get_errorCapturingIdentifier() IErrorCapturingIdentifierContext { + return s._errorCapturingIdentifier +} + +func (s *LambdaExpressionContext) GetBody() IBooleanExpressionContext { return s.body } + +func (s *LambdaExpressionContext) Set_errorCapturingIdentifier(v IErrorCapturingIdentifierContext) { + s._errorCapturingIdentifier = v +} + +func (s *LambdaExpressionContext) SetBody(v IBooleanExpressionContext) { s.body = v } + +func (s *LambdaExpressionContext) GetArgs() []IErrorCapturingIdentifierContext { return s.args } + +func (s *LambdaExpressionContext) SetArgs(v []IErrorCapturingIdentifierContext) { s.args = v } + +func (s *LambdaExpressionContext) ARROW() antlr.TerminalNode { + return s.GetToken(DorisParserARROW, 0) +} + +func (s *LambdaExpressionContext) AllErrorCapturingIdentifier() []IErrorCapturingIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + len++ + } + } + + tst := make([]IErrorCapturingIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IErrorCapturingIdentifierContext); ok { + tst[i] = t.(IErrorCapturingIdentifierContext) + i++ + } + } + + return tst +} + +func (s *LambdaExpressionContext) ErrorCapturingIdentifier(i int) IErrorCapturingIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierContext) +} + +func (s *LambdaExpressionContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *LambdaExpressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *LambdaExpressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *LambdaExpressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *LambdaExpressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *LambdaExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LambdaExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LambdaExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLambdaExpression(s) + } +} + +func (s *LambdaExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLambdaExpression(s) + } +} + +func (s *LambdaExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLambdaExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) LambdaExpression() (localctx ILambdaExpressionContext) { + localctx = NewLambdaExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, DorisParserRULE_lambdaExpression) + var _la int + + p.SetState(5968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5952) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*LambdaExpressionContext)._errorCapturingIdentifier = _x + } + localctx.(*LambdaExpressionContext).args = append(localctx.(*LambdaExpressionContext).args, localctx.(*LambdaExpressionContext)._errorCapturingIdentifier) + { + p.SetState(5953) + p.Match(DorisParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5954) + + var _x = p.booleanExpression(0) + + localctx.(*LambdaExpressionContext).body = _x + } + + case DorisParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5956) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5957) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*LambdaExpressionContext)._errorCapturingIdentifier = _x + } + localctx.(*LambdaExpressionContext).args = append(localctx.(*LambdaExpressionContext).args, localctx.(*LambdaExpressionContext)._errorCapturingIdentifier) + p.SetState(5960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == DorisParserCOMMA { + { + p.SetState(5958) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5959) + + var _x = p.ErrorCapturingIdentifier() + + localctx.(*LambdaExpressionContext)._errorCapturingIdentifier = _x + } + localctx.(*LambdaExpressionContext).args = append(localctx.(*LambdaExpressionContext).args, localctx.(*LambdaExpressionContext)._errorCapturingIdentifier) + + p.SetState(5962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5964) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5965) + p.Match(DorisParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5966) + + var _x = p.booleanExpression(0) + + localctx.(*LambdaExpressionContext).body = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBooleanExpressionContext is an interface to support dynamic dispatch. +type IBooleanExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsBooleanExpressionContext differentiates from other interfaces. + IsBooleanExpressionContext() +} + +type BooleanExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBooleanExpressionContext() *BooleanExpressionContext { + var p = new(BooleanExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_booleanExpression + return p +} + +func InitEmptyBooleanExpressionContext(p *BooleanExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_booleanExpression +} + +func (*BooleanExpressionContext) IsBooleanExpressionContext() {} + +func NewBooleanExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanExpressionContext { + var p = new(BooleanExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_booleanExpression + + return p +} + +func (s *BooleanExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *BooleanExpressionContext) CopyAll(ctx *BooleanExpressionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *BooleanExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BooleanExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ExistContext struct { + BooleanExpressionContext +} + +func NewExistContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistContext { + var p = new(ExistContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *ExistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExistContext) EXISTS() antlr.TerminalNode { + return s.GetToken(DorisParserEXISTS, 0) +} + +func (s *ExistContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ExistContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *ExistContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ExistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExist(s) + } +} + +func (s *ExistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExist(s) + } +} + +func (s *ExistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExist(s) + + default: + return t.VisitChildren(s) + } +} + +type LogicalNotContext struct { + BooleanExpressionContext +} + +func NewLogicalNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalNotContext { + var p = new(LogicalNotContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *LogicalNotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LogicalNotContext) LOGICALNOT() antlr.TerminalNode { + return s.GetToken(DorisParserLOGICALNOT, 0) +} + +func (s *LogicalNotContext) BooleanExpression() IBooleanExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *LogicalNotContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *LogicalNotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLogicalNot(s) + } +} + +func (s *LogicalNotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLogicalNot(s) + } +} + +func (s *LogicalNotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLogicalNot(s) + + default: + return t.VisitChildren(s) + } +} + +type PredicatedContext struct { + BooleanExpressionContext +} + +func NewPredicatedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PredicatedContext { + var p = new(PredicatedContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *PredicatedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PredicatedContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *PredicatedContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *PredicatedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPredicated(s) + } +} + +func (s *PredicatedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPredicated(s) + } +} + +func (s *PredicatedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPredicated(s) + + default: + return t.VisitChildren(s) + } +} + +type IsnullContext struct { + BooleanExpressionContext +} + +func NewIsnullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsnullContext { + var p = new(IsnullContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *IsnullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IsnullContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *IsnullContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *IsnullContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *IsnullContext) ISNULL() antlr.TerminalNode { + return s.GetToken(DorisParserISNULL, 0) +} + +func (s *IsnullContext) IS_NULL_PRED() antlr.TerminalNode { + return s.GetToken(DorisParserIS_NULL_PRED, 0) +} + +func (s *IsnullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIsnull(s) + } +} + +func (s *IsnullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIsnull(s) + } +} + +func (s *IsnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIsnull(s) + + default: + return t.VisitChildren(s) + } +} + +type Is_not_null_predContext struct { + BooleanExpressionContext +} + +func NewIs_not_null_predContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Is_not_null_predContext { + var p = new(Is_not_null_predContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *Is_not_null_predContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Is_not_null_predContext) IS_NOT_NULL_PRED() antlr.TerminalNode { + return s.GetToken(DorisParserIS_NOT_NULL_PRED, 0) +} + +func (s *Is_not_null_predContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *Is_not_null_predContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *Is_not_null_predContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *Is_not_null_predContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIs_not_null_pred(s) + } +} + +func (s *Is_not_null_predContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIs_not_null_pred(s) + } +} + +func (s *Is_not_null_predContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIs_not_null_pred(s) + + default: + return t.VisitChildren(s) + } +} + +type LogicalBinaryContext struct { + BooleanExpressionContext + left IBooleanExpressionContext + operator antlr.Token + right IBooleanExpressionContext +} + +func NewLogicalBinaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalBinaryContext { + var p = new(LogicalBinaryContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *LogicalBinaryContext) GetOperator() antlr.Token { return s.operator } + +func (s *LogicalBinaryContext) SetOperator(v antlr.Token) { s.operator = v } + +func (s *LogicalBinaryContext) GetLeft() IBooleanExpressionContext { return s.left } + +func (s *LogicalBinaryContext) GetRight() IBooleanExpressionContext { return s.right } + +func (s *LogicalBinaryContext) SetLeft(v IBooleanExpressionContext) { s.left = v } + +func (s *LogicalBinaryContext) SetRight(v IBooleanExpressionContext) { s.right = v } + +func (s *LogicalBinaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LogicalBinaryContext) AllBooleanExpression() []IBooleanExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBooleanExpressionContext); ok { + len++ + } + } + + tst := make([]IBooleanExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBooleanExpressionContext); ok { + tst[i] = t.(IBooleanExpressionContext) + i++ + } + } + + return tst +} + +func (s *LogicalBinaryContext) BooleanExpression(i int) IBooleanExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *LogicalBinaryContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *LogicalBinaryContext) LOGICALAND() antlr.TerminalNode { + return s.GetToken(DorisParserLOGICALAND, 0) +} + +func (s *LogicalBinaryContext) XOR() antlr.TerminalNode { + return s.GetToken(DorisParserXOR, 0) +} + +func (s *LogicalBinaryContext) OR() antlr.TerminalNode { + return s.GetToken(DorisParserOR, 0) +} + +func (s *LogicalBinaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLogicalBinary(s) + } +} + +func (s *LogicalBinaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLogicalBinary(s) + } +} + +func (s *LogicalBinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLogicalBinary(s) + + default: + return t.VisitChildren(s) + } +} + +type DoublePipesContext struct { + BooleanExpressionContext + left IBooleanExpressionContext + operator antlr.Token + right IBooleanExpressionContext +} + +func NewDoublePipesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoublePipesContext { + var p = new(DoublePipesContext) + + InitEmptyBooleanExpressionContext(&p.BooleanExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*BooleanExpressionContext)) + + return p +} + +func (s *DoublePipesContext) GetOperator() antlr.Token { return s.operator } + +func (s *DoublePipesContext) SetOperator(v antlr.Token) { s.operator = v } + +func (s *DoublePipesContext) GetLeft() IBooleanExpressionContext { return s.left } + +func (s *DoublePipesContext) GetRight() IBooleanExpressionContext { return s.right } + +func (s *DoublePipesContext) SetLeft(v IBooleanExpressionContext) { s.left = v } + +func (s *DoublePipesContext) SetRight(v IBooleanExpressionContext) { s.right = v } + +func (s *DoublePipesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DoublePipesContext) AllBooleanExpression() []IBooleanExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBooleanExpressionContext); ok { + len++ + } + } + + tst := make([]IBooleanExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBooleanExpressionContext); ok { + tst[i] = t.(IBooleanExpressionContext) + i++ + } + } + + return tst +} + +func (s *DoublePipesContext) BooleanExpression(i int) IBooleanExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBooleanExpressionContext) +} + +func (s *DoublePipesContext) DOUBLEPIPES() antlr.TerminalNode { + return s.GetToken(DorisParserDOUBLEPIPES, 0) +} + +func (s *DoublePipesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDoublePipes(s) + } +} + +func (s *DoublePipesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDoublePipes(s) + } +} + +func (s *DoublePipesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDoublePipes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) BooleanExpression() (localctx IBooleanExpressionContext) { + return p.booleanExpression(0) +} + +func (p *DorisParser) booleanExpression(_p int) (localctx IBooleanExpressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewBooleanExpressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IBooleanExpressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 388 + p.EnterRecursionRule(localctx, 388, DorisParserRULE_booleanExpression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 861, p.GetParserRuleContext()) { + case 1: + localctx = NewLogicalNotContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(5971) + p.Match(DorisParserLOGICALNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5972) + p.booleanExpression(10) + } + + case 2: + localctx = NewExistContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(5973) + p.Match(DorisParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5974) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5975) + p.Query() + } + { + p.SetState(5976) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewIsnullContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(5978) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserIS_NULL_PRED || _la == DorisParserISNULL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5979) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5980) + p.valueExpression(0) + } + { + p.SetState(5981) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewIs_not_null_predContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(5983) + p.Match(DorisParserIS_NOT_NULL_PRED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5984) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5985) + p.valueExpression(0) + } + { + p.SetState(5986) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewPredicatedContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(5988) + p.valueExpression(0) + } + p.SetState(5990) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 860, p.GetParserRuleContext()) == 1 { + { + p.SetState(5989) + p.Predicate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + localctx = NewLogicalNotContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(5992) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5993) + p.booleanExpression(5) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 863, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 862, p.GetParserRuleContext()) { + case 1: + localctx = NewLogicalBinaryContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) + localctx.(*LogicalBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_booleanExpression) + p.SetState(5996) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(5997) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*LogicalBinaryContext).operator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserAND || _la == DorisParserLOGICALAND) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*LogicalBinaryContext).operator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5998) + + var _x = p.booleanExpression(5) + + localctx.(*LogicalBinaryContext).right = _x + } + + case 2: + localctx = NewLogicalBinaryContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) + localctx.(*LogicalBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_booleanExpression) + p.SetState(5999) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(6000) + + var _m = p.Match(DorisParserXOR) + + localctx.(*LogicalBinaryContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6001) + + var _x = p.booleanExpression(4) + + localctx.(*LogicalBinaryContext).right = _x + } + + case 3: + localctx = NewLogicalBinaryContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) + localctx.(*LogicalBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_booleanExpression) + p.SetState(6002) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6003) + + var _m = p.Match(DorisParserOR) + + localctx.(*LogicalBinaryContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6004) + + var _x = p.booleanExpression(3) + + localctx.(*LogicalBinaryContext).right = _x + } + + case 4: + localctx = NewDoublePipesContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) + localctx.(*DoublePipesContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_booleanExpression) + p.SetState(6005) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6006) + + var _m = p.Match(DorisParserDOUBLEPIPES) + + localctx.(*DoublePipesContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6007) + + var _x = p.booleanExpression(2) + + localctx.(*DoublePipesContext).right = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 863, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowConstructorContext is an interface to support dynamic dispatch. +type IRowConstructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllRowConstructorItem() []IRowConstructorItemContext + RowConstructorItem(i int) IRowConstructorItemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRowConstructorContext differentiates from other interfaces. + IsRowConstructorContext() +} + +type RowConstructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowConstructorContext() *RowConstructorContext { + var p = new(RowConstructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rowConstructor + return p +} + +func InitEmptyRowConstructorContext(p *RowConstructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rowConstructor +} + +func (*RowConstructorContext) IsRowConstructorContext() {} + +func NewRowConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowConstructorContext { + var p = new(RowConstructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_rowConstructor + + return p +} + +func (s *RowConstructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowConstructorContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *RowConstructorContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *RowConstructorContext) AllRowConstructorItem() []IRowConstructorItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRowConstructorItemContext); ok { + len++ + } + } + + tst := make([]IRowConstructorItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRowConstructorItemContext); ok { + tst[i] = t.(IRowConstructorItemContext) + i++ + } + } + + return tst +} + +func (s *RowConstructorContext) RowConstructorItem(i int) IRowConstructorItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowConstructorItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRowConstructorItemContext) +} + +func (s *RowConstructorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *RowConstructorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *RowConstructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowConstructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowConstructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRowConstructor(s) + } +} + +func (s *RowConstructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRowConstructor(s) + } +} + +func (s *RowConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRowConstructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RowConstructor() (localctx IRowConstructorContext) { + localctx = NewRowConstructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, DorisParserRULE_rowConstructor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6013) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031707) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(6014) + p.RowConstructorItem() + } + p.SetState(6019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6015) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6016) + p.RowConstructorItem() + } + + p.SetState(6021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6024) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowConstructorItemContext is an interface to support dynamic dispatch. +type IRowConstructorItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + DEFAULT() antlr.TerminalNode + NamedExpression() INamedExpressionContext + + // IsRowConstructorItemContext differentiates from other interfaces. + IsRowConstructorItemContext() +} + +type RowConstructorItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowConstructorItemContext() *RowConstructorItemContext { + var p = new(RowConstructorItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rowConstructorItem + return p +} + +func InitEmptyRowConstructorItemContext(p *RowConstructorItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_rowConstructorItem +} + +func (*RowConstructorItemContext) IsRowConstructorItemContext() {} + +func NewRowConstructorItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowConstructorItemContext { + var p = new(RowConstructorItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_rowConstructorItem + + return p +} + +func (s *RowConstructorItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowConstructorItemContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *RowConstructorItemContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *RowConstructorItemContext) NamedExpression() INamedExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamedExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamedExpressionContext) +} + +func (s *RowConstructorItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowConstructorItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowConstructorItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRowConstructorItem(s) + } +} + +func (s *RowConstructorItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRowConstructorItem(s) + } +} + +func (s *RowConstructorItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRowConstructorItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) RowConstructorItem() (localctx IRowConstructorItemContext) { + localctx = NewRowConstructorItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, DorisParserRULE_rowConstructorItem) + p.SetState(6029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 866, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6026) + p.Constant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6027) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6028) + p.NamedExpression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPredicateContext is an interface to support dynamic dispatch. +type IPredicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKind returns the kind token. + GetKind() antlr.Token + + // SetKind sets the kind token. + SetKind(antlr.Token) + + // GetLower returns the lower rule contexts. + GetLower() IValueExpressionContext + + // GetUpper returns the upper rule contexts. + GetUpper() IValueExpressionContext + + // GetPattern returns the pattern rule contexts. + GetPattern() IValueExpressionContext + + // GetEscape returns the escape rule contexts. + GetEscape() IValueExpressionContext + + // SetLower sets the lower rule contexts. + SetLower(IValueExpressionContext) + + // SetUpper sets the upper rule contexts. + SetUpper(IValueExpressionContext) + + // SetPattern sets the pattern rule contexts. + SetPattern(IValueExpressionContext) + + // SetEscape sets the escape rule contexts. + SetEscape(IValueExpressionContext) + + // Getter signatures + AND() antlr.TerminalNode + BETWEEN() antlr.TerminalNode + AllValueExpression() []IValueExpressionContext + ValueExpression(i int) IValueExpressionContext + NOT() antlr.TerminalNode + REGEXP() antlr.TerminalNode + RLIKE() antlr.TerminalNode + LIKE() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + MATCH() antlr.TerminalNode + MATCH_ANY() antlr.TerminalNode + MATCH_ALL() antlr.TerminalNode + MATCH_PHRASE() antlr.TerminalNode + MATCH_PHRASE_PREFIX() antlr.TerminalNode + MATCH_REGEXP() antlr.TerminalNode + MATCH_PHRASE_EDGE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Query() IQueryContext + RIGHT_PAREN() antlr.TerminalNode + IN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + IS() antlr.TerminalNode + NULL() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + + // IsPredicateContext differentiates from other interfaces. + IsPredicateContext() +} + +type PredicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + kind antlr.Token + lower IValueExpressionContext + upper IValueExpressionContext + pattern IValueExpressionContext + escape IValueExpressionContext +} + +func NewEmptyPredicateContext() *PredicateContext { + var p = new(PredicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_predicate + return p +} + +func InitEmptyPredicateContext(p *PredicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_predicate +} + +func (*PredicateContext) IsPredicateContext() {} + +func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext { + var p = new(PredicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_predicate + + return p +} + +func (s *PredicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *PredicateContext) GetKind() antlr.Token { return s.kind } + +func (s *PredicateContext) SetKind(v antlr.Token) { s.kind = v } + +func (s *PredicateContext) GetLower() IValueExpressionContext { return s.lower } + +func (s *PredicateContext) GetUpper() IValueExpressionContext { return s.upper } + +func (s *PredicateContext) GetPattern() IValueExpressionContext { return s.pattern } + +func (s *PredicateContext) GetEscape() IValueExpressionContext { return s.escape } + +func (s *PredicateContext) SetLower(v IValueExpressionContext) { s.lower = v } + +func (s *PredicateContext) SetUpper(v IValueExpressionContext) { s.upper = v } + +func (s *PredicateContext) SetPattern(v IValueExpressionContext) { s.pattern = v } + +func (s *PredicateContext) SetEscape(v IValueExpressionContext) { s.escape = v } + +func (s *PredicateContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *PredicateContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(DorisParserBETWEEN, 0) +} + +func (s *PredicateContext) AllValueExpression() []IValueExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValueExpressionContext); ok { + len++ + } + } + + tst := make([]IValueExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValueExpressionContext); ok { + tst[i] = t.(IValueExpressionContext) + i++ + } + } + + return tst +} + +func (s *PredicateContext) ValueExpression(i int) IValueExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *PredicateContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *PredicateContext) REGEXP() antlr.TerminalNode { + return s.GetToken(DorisParserREGEXP, 0) +} + +func (s *PredicateContext) RLIKE() antlr.TerminalNode { + return s.GetToken(DorisParserRLIKE, 0) +} + +func (s *PredicateContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *PredicateContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(DorisParserESCAPE, 0) +} + +func (s *PredicateContext) MATCH() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH, 0) +} + +func (s *PredicateContext) MATCH_ANY() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_ANY, 0) +} + +func (s *PredicateContext) MATCH_ALL() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_ALL, 0) +} + +func (s *PredicateContext) MATCH_PHRASE() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_PHRASE, 0) +} + +func (s *PredicateContext) MATCH_PHRASE_PREFIX() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_PHRASE_PREFIX, 0) +} + +func (s *PredicateContext) MATCH_REGEXP() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_REGEXP, 0) +} + +func (s *PredicateContext) MATCH_PHRASE_EDGE() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_PHRASE_EDGE, 0) +} + +func (s *PredicateContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PredicateContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *PredicateContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PredicateContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *PredicateContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PredicateContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PredicateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PredicateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PredicateContext) IS() antlr.TerminalNode { + return s.GetToken(DorisParserIS, 0) +} + +func (s *PredicateContext) NULL() antlr.TerminalNode { + return s.GetToken(DorisParserNULL, 0) +} + +func (s *PredicateContext) TRUE() antlr.TerminalNode { + return s.GetToken(DorisParserTRUE, 0) +} + +func (s *PredicateContext) FALSE() antlr.TerminalNode { + return s.GetToken(DorisParserFALSE, 0) +} + +func (s *PredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPredicate(s) + } +} + +func (s *PredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPredicate(s) + } +} + +func (s *PredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPredicate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Predicate() (localctx IPredicateContext) { + localctx = NewPredicateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, DorisParserRULE_predicate) + var _la int + + p.SetState(6091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 877, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(6032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6031) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6034) + + var _m = p.Match(DorisParserBETWEEN) + + localctx.(*PredicateContext).kind = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6035) + + var _x = p.valueExpression(0) + + localctx.(*PredicateContext).lower = _x + } + { + p.SetState(6036) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6037) + + var _x = p.valueExpression(0) + + localctx.(*PredicateContext).upper = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(6040) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6039) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6042) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PredicateContext).kind = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserREGEXP || _la == DorisParserRLIKE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PredicateContext).kind = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6043) + + var _x = p.valueExpression(0) + + localctx.(*PredicateContext).pattern = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(6045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6044) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6047) + + var _m = p.Match(DorisParserLIKE) + + localctx.(*PredicateContext).kind = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6048) + + var _x = p.valueExpression(0) + + localctx.(*PredicateContext).pattern = _x + } + p.SetState(6051) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 870, p.GetParserRuleContext()) == 1 { + { + p.SetState(6049) + p.Match(DorisParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6050) + + var _x = p.valueExpression(0) + + localctx.(*PredicateContext).escape = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + p.SetState(6054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6053) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6056) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PredicateContext).kind = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-288)) & ^0x3f) == 0 && ((int64(1)<<(_la-288))&973) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PredicateContext).kind = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6057) + + var _x = p.valueExpression(0) + + localctx.(*PredicateContext).pattern = _x + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(6059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6058) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6061) + + var _m = p.Match(DorisParserIN) + + localctx.(*PredicateContext).kind = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6062) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6063) + p.Query() + } + { + p.SetState(6064) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + p.SetState(6067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6066) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6069) + + var _m = p.Match(DorisParserIN) + + localctx.(*PredicateContext).kind = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6070) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6071) + p.Expression() + } + p.SetState(6076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6072) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6073) + p.Expression() + } + + p.SetState(6078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6079) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6081) + p.Match(DorisParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6083) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6082) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6085) + + var _m = p.Match(DorisParserNULL) + + localctx.(*PredicateContext).kind = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6086) + p.Match(DorisParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6087) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6090) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PredicateContext).kind = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFALSE || _la == DorisParserTRUE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PredicateContext).kind = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValueExpressionContext is an interface to support dynamic dispatch. +type IValueExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsValueExpressionContext differentiates from other interfaces. + IsValueExpressionContext() +} + +type ValueExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValueExpressionContext() *ValueExpressionContext { + var p = new(ValueExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_valueExpression + return p +} + +func InitEmptyValueExpressionContext(p *ValueExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_valueExpression +} + +func (*ValueExpressionContext) IsValueExpressionContext() {} + +func NewValueExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueExpressionContext { + var p = new(ValueExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_valueExpression + + return p +} + +func (s *ValueExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ValueExpressionContext) CopyAll(ctx *ValueExpressionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ValueExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValueExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ValueExpressionDefaultContext struct { + ValueExpressionContext +} + +func NewValueExpressionDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ValueExpressionDefaultContext { + var p = new(ValueExpressionDefaultContext) + + InitEmptyValueExpressionContext(&p.ValueExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ValueExpressionContext)) + + return p +} + +func (s *ValueExpressionDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValueExpressionDefaultContext) PrimaryExpression() IPrimaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryExpressionContext) +} + +func (s *ValueExpressionDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterValueExpressionDefault(s) + } +} + +func (s *ValueExpressionDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitValueExpressionDefault(s) + } +} + +func (s *ValueExpressionDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitValueExpressionDefault(s) + + default: + return t.VisitChildren(s) + } +} + +type ComparisonContext struct { + ValueExpressionContext + left IValueExpressionContext + right IValueExpressionContext +} + +func NewComparisonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComparisonContext { + var p = new(ComparisonContext) + + InitEmptyValueExpressionContext(&p.ValueExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ValueExpressionContext)) + + return p +} + +func (s *ComparisonContext) GetLeft() IValueExpressionContext { return s.left } + +func (s *ComparisonContext) GetRight() IValueExpressionContext { return s.right } + +func (s *ComparisonContext) SetLeft(v IValueExpressionContext) { s.left = v } + +func (s *ComparisonContext) SetRight(v IValueExpressionContext) { s.right = v } + +func (s *ComparisonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComparisonContext) ComparisonOperator() IComparisonOperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparisonOperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparisonOperatorContext) +} + +func (s *ComparisonContext) AllValueExpression() []IValueExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValueExpressionContext); ok { + len++ + } + } + + tst := make([]IValueExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValueExpressionContext); ok { + tst[i] = t.(IValueExpressionContext) + i++ + } + } + + return tst +} + +func (s *ComparisonContext) ValueExpression(i int) IValueExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ComparisonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterComparison(s) + } +} + +func (s *ComparisonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitComparison(s) + } +} + +func (s *ComparisonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitComparison(s) + + default: + return t.VisitChildren(s) + } +} + +type ArithmeticBinaryContext struct { + ValueExpressionContext + left IValueExpressionContext + operator antlr.Token + right IValueExpressionContext +} + +func NewArithmeticBinaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArithmeticBinaryContext { + var p = new(ArithmeticBinaryContext) + + InitEmptyValueExpressionContext(&p.ValueExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ValueExpressionContext)) + + return p +} + +func (s *ArithmeticBinaryContext) GetOperator() antlr.Token { return s.operator } + +func (s *ArithmeticBinaryContext) SetOperator(v antlr.Token) { s.operator = v } + +func (s *ArithmeticBinaryContext) GetLeft() IValueExpressionContext { return s.left } + +func (s *ArithmeticBinaryContext) GetRight() IValueExpressionContext { return s.right } + +func (s *ArithmeticBinaryContext) SetLeft(v IValueExpressionContext) { s.left = v } + +func (s *ArithmeticBinaryContext) SetRight(v IValueExpressionContext) { s.right = v } + +func (s *ArithmeticBinaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ArithmeticBinaryContext) AllValueExpression() []IValueExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValueExpressionContext); ok { + len++ + } + } + + tst := make([]IValueExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValueExpressionContext); ok { + tst[i] = t.(IValueExpressionContext) + i++ + } + } + + return tst +} + +func (s *ArithmeticBinaryContext) ValueExpression(i int) IValueExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ArithmeticBinaryContext) HAT() antlr.TerminalNode { + return s.GetToken(DorisParserHAT, 0) +} + +func (s *ArithmeticBinaryContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *ArithmeticBinaryContext) SLASH() antlr.TerminalNode { + return s.GetToken(DorisParserSLASH, 0) +} + +func (s *ArithmeticBinaryContext) MOD() antlr.TerminalNode { + return s.GetToken(DorisParserMOD, 0) +} + +func (s *ArithmeticBinaryContext) DIV() antlr.TerminalNode { + return s.GetToken(DorisParserDIV, 0) +} + +func (s *ArithmeticBinaryContext) PLUS() antlr.TerminalNode { + return s.GetToken(DorisParserPLUS, 0) +} + +func (s *ArithmeticBinaryContext) SUBTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, 0) +} + +func (s *ArithmeticBinaryContext) AMPERSAND() antlr.TerminalNode { + return s.GetToken(DorisParserAMPERSAND, 0) +} + +func (s *ArithmeticBinaryContext) PIPE() antlr.TerminalNode { + return s.GetToken(DorisParserPIPE, 0) +} + +func (s *ArithmeticBinaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterArithmeticBinary(s) + } +} + +func (s *ArithmeticBinaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitArithmeticBinary(s) + } +} + +func (s *ArithmeticBinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitArithmeticBinary(s) + + default: + return t.VisitChildren(s) + } +} + +type ArithmeticUnaryContext struct { + ValueExpressionContext + operator antlr.Token +} + +func NewArithmeticUnaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArithmeticUnaryContext { + var p = new(ArithmeticUnaryContext) + + InitEmptyValueExpressionContext(&p.ValueExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*ValueExpressionContext)) + + return p +} + +func (s *ArithmeticUnaryContext) GetOperator() antlr.Token { return s.operator } + +func (s *ArithmeticUnaryContext) SetOperator(v antlr.Token) { s.operator = v } + +func (s *ArithmeticUnaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ArithmeticUnaryContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ArithmeticUnaryContext) SUBTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, 0) +} + +func (s *ArithmeticUnaryContext) PLUS() antlr.TerminalNode { + return s.GetToken(DorisParserPLUS, 0) +} + +func (s *ArithmeticUnaryContext) TILDE() antlr.TerminalNode { + return s.GetToken(DorisParserTILDE, 0) +} + +func (s *ArithmeticUnaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterArithmeticUnary(s) + } +} + +func (s *ArithmeticUnaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitArithmeticUnary(s) + } +} + +func (s *ArithmeticUnaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitArithmeticUnary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ValueExpression() (localctx IValueExpressionContext) { + return p.valueExpression(0) +} + +func (p *DorisParser) valueExpression(_p int) (localctx IValueExpressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewValueExpressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IValueExpressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 396 + p.EnterRecursionRule(localctx, 396, DorisParserRULE_valueExpression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 878, p.GetParserRuleContext()) { + case 1: + localctx = NewValueExpressionDefaultContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(6094) + p.primaryExpression(0) + } + + case 2: + localctx = NewArithmeticUnaryContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6095) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ArithmeticUnaryContext).operator = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-550)) & ^0x3f) == 0 && ((int64(1)<<(_la-550))&35) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ArithmeticUnaryContext).operator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6096) + p.valueExpression(7) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 880, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 879, p.GetParserRuleContext()) { + case 1: + localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) + localctx.(*ArithmeticBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_valueExpression) + p.SetState(6099) + + if !(p.Precpred(p.GetParserRuleContext(), 6)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) + goto errorExit + } + { + p.SetState(6100) + + var _m = p.Match(DorisParserHAT) + + localctx.(*ArithmeticBinaryContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6101) + + var _x = p.valueExpression(7) + + localctx.(*ArithmeticBinaryContext).right = _x + } + + case 2: + localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) + localctx.(*ArithmeticBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_valueExpression) + p.SetState(6102) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(6103) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ArithmeticBinaryContext).operator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDIV || ((int64((_la-552)) & ^0x3f) == 0 && ((int64(1)<<(_la-552))&7) != 0)) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ArithmeticBinaryContext).operator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6104) + + var _x = p.valueExpression(6) + + localctx.(*ArithmeticBinaryContext).right = _x + } + + case 3: + localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) + localctx.(*ArithmeticBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_valueExpression) + p.SetState(6105) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(6106) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ArithmeticBinaryContext).operator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserPLUS || _la == DorisParserSUBTRACT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ArithmeticBinaryContext).operator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6107) + + var _x = p.valueExpression(5) + + localctx.(*ArithmeticBinaryContext).right = _x + } + + case 4: + localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) + localctx.(*ArithmeticBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_valueExpression) + p.SetState(6108) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(6109) + + var _m = p.Match(DorisParserAMPERSAND) + + localctx.(*ArithmeticBinaryContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6110) + + var _x = p.valueExpression(4) + + localctx.(*ArithmeticBinaryContext).right = _x + } + + case 5: + localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) + localctx.(*ArithmeticBinaryContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_valueExpression) + p.SetState(6111) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(6112) + + var _m = p.Match(DorisParserPIPE) + + localctx.(*ArithmeticBinaryContext).operator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6113) + + var _x = p.valueExpression(3) + + localctx.(*ArithmeticBinaryContext).right = _x + } + + case 6: + localctx = NewComparisonContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) + localctx.(*ComparisonContext).left = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_valueExpression) + p.SetState(6114) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6115) + p.ComparisonOperator() + } + { + p.SetState(6116) + + var _x = p.valueExpression(2) + + localctx.(*ComparisonContext).right = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 880, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimaryExpressionContext is an interface to support dynamic dispatch. +type IPrimaryExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsPrimaryExpressionContext differentiates from other interfaces. + IsPrimaryExpressionContext() +} + +type PrimaryExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext { + var p = new(PrimaryExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_primaryExpression + return p +} + +func InitEmptyPrimaryExpressionContext(p *PrimaryExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_primaryExpression +} + +func (*PrimaryExpressionContext) IsPrimaryExpressionContext() {} + +func NewPrimaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryExpressionContext { + var p = new(PrimaryExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_primaryExpression + + return p +} + +func (s *PrimaryExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimaryExpressionContext) CopyAll(ctx *PrimaryExpressionContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *PrimaryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DereferenceContext struct { + PrimaryExpressionContext + base IPrimaryExpressionContext + fieldName IIdentifierContext +} + +func NewDereferenceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DereferenceContext { + var p = new(DereferenceContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *DereferenceContext) GetBase() IPrimaryExpressionContext { return s.base } + +func (s *DereferenceContext) GetFieldName() IIdentifierContext { return s.fieldName } + +func (s *DereferenceContext) SetBase(v IPrimaryExpressionContext) { s.base = v } + +func (s *DereferenceContext) SetFieldName(v IIdentifierContext) { s.fieldName = v } + +func (s *DereferenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DereferenceContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *DereferenceContext) PrimaryExpression() IPrimaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryExpressionContext) +} + +func (s *DereferenceContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *DereferenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDereference(s) + } +} + +func (s *DereferenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDereference(s) + } +} + +func (s *DereferenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDereference(s) + + default: + return t.VisitChildren(s) + } +} + +type CurrentDateContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewCurrentDateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentDateContext { + var p = new(CurrentDateContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CurrentDateContext) GetName() antlr.Token { return s.name } + +func (s *CurrentDateContext) SetName(v antlr.Token) { s.name = v } + +func (s *CurrentDateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentDateContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_DATE, 0) +} + +func (s *CurrentDateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCurrentDate(s) + } +} + +func (s *CurrentDateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCurrentDate(s) + } +} + +func (s *CurrentDateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCurrentDate(s) + + default: + return t.VisitChildren(s) + } +} + +type SubstringContext struct { + PrimaryExpressionContext +} + +func NewSubstringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubstringContext { + var p = new(SubstringContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *SubstringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubstringContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SubstringContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SubstringContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SubstringContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *SubstringContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SubstringContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(DorisParserSUBSTR, 0) +} + +func (s *SubstringContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(DorisParserSUBSTRING, 0) +} + +func (s *SubstringContext) MID() antlr.TerminalNode { + return s.GetToken(DorisParserMID, 0) +} + +func (s *SubstringContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *SubstringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSubstring(s) + } +} + +func (s *SubstringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSubstring(s) + } +} + +func (s *SubstringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSubstring(s) + + default: + return t.VisitChildren(s) + } +} + +type CastContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewCastContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CastContext { + var p = new(CastContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CastContext) GetName() antlr.Token { return s.name } + +func (s *CastContext) SetName(v antlr.Token) { s.name = v } + +func (s *CastContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CastContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CastContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CastContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *CastContext) CastDataType() ICastDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICastDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICastDataTypeContext) +} + +func (s *CastContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CastContext) CAST() antlr.TerminalNode { + return s.GetToken(DorisParserCAST, 0) +} + +func (s *CastContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCast(s) + } +} + +func (s *CastContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCast(s) + } +} + +func (s *CastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCast(s) + + default: + return t.VisitChildren(s) + } +} + +type ParenthesizedExpressionContext struct { + PrimaryExpressionContext +} + +func NewParenthesizedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesizedExpressionContext { + var p = new(ParenthesizedExpressionContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ParenthesizedExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParenthesizedExpressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ParenthesizedExpressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ParenthesizedExpressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ParenthesizedExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterParenthesizedExpression(s) + } +} + +func (s *ParenthesizedExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitParenthesizedExpression(s) + } +} + +func (s *ParenthesizedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitParenthesizedExpression(s) + + default: + return t.VisitChildren(s) + } +} + +type TrimContext struct { + PrimaryExpressionContext +} + +func NewTrimContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TrimContext { + var p = new(TrimContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *TrimContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TrimContext) TRIM() antlr.TerminalNode { + return s.GetToken(DorisParserTRIM, 0) +} + +func (s *TrimContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *TrimContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *TrimContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TrimContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TrimContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *TrimContext) BOTH() antlr.TerminalNode { + return s.GetToken(DorisParserBOTH, 0) +} + +func (s *TrimContext) LEADING() antlr.TerminalNode { + return s.GetToken(DorisParserLEADING, 0) +} + +func (s *TrimContext) TRAILING() antlr.TerminalNode { + return s.GetToken(DorisParserTRAILING, 0) +} + +func (s *TrimContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTrim(s) + } +} + +func (s *TrimContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTrim(s) + } +} + +func (s *TrimContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTrim(s) + + default: + return t.VisitChildren(s) + } +} + +type UserVariableContext struct { + PrimaryExpressionContext +} + +func NewUserVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UserVariableContext { + var p = new(UserVariableContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *UserVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserVariableContext) ATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserATSIGN, 0) +} + +func (s *UserVariableContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *UserVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUserVariable(s) + } +} + +func (s *UserVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUserVariable(s) + } +} + +func (s *UserVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUserVariable(s) + + default: + return t.VisitChildren(s) + } +} + +type ElementAtContext struct { + PrimaryExpressionContext + value IPrimaryExpressionContext + index IValueExpressionContext +} + +func NewElementAtContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ElementAtContext { + var p = new(ElementAtContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ElementAtContext) GetValue() IPrimaryExpressionContext { return s.value } + +func (s *ElementAtContext) GetIndex() IValueExpressionContext { return s.index } + +func (s *ElementAtContext) SetValue(v IPrimaryExpressionContext) { s.value = v } + +func (s *ElementAtContext) SetIndex(v IValueExpressionContext) { s.index = v } + +func (s *ElementAtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ElementAtContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *ElementAtContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *ElementAtContext) PrimaryExpression() IPrimaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryExpressionContext) +} + +func (s *ElementAtContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ElementAtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterElementAt(s) + } +} + +func (s *ElementAtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitElementAt(s) + } +} + +func (s *ElementAtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitElementAt(s) + + default: + return t.VisitChildren(s) + } +} + +type LocalTimestampContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewLocalTimestampContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LocalTimestampContext { + var p = new(LocalTimestampContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *LocalTimestampContext) GetName() antlr.Token { return s.name } + +func (s *LocalTimestampContext) SetName(v antlr.Token) { s.name = v } + +func (s *LocalTimestampContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LocalTimestampContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserLOCALTIMESTAMP, 0) +} + +func (s *LocalTimestampContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLocalTimestamp(s) + } +} + +func (s *LocalTimestampContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLocalTimestamp(s) + } +} + +func (s *LocalTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLocalTimestamp(s) + + default: + return t.VisitChildren(s) + } +} + +type CharFunctionContext struct { + PrimaryExpressionContext + _expression IExpressionContext + arguments []IExpressionContext + charSet IIdentifierOrTextContext +} + +func NewCharFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CharFunctionContext { + var p = new(CharFunctionContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CharFunctionContext) Get_expression() IExpressionContext { return s._expression } + +func (s *CharFunctionContext) GetCharSet() IIdentifierOrTextContext { return s.charSet } + +func (s *CharFunctionContext) Set_expression(v IExpressionContext) { s._expression = v } + +func (s *CharFunctionContext) SetCharSet(v IIdentifierOrTextContext) { s.charSet = v } + +func (s *CharFunctionContext) GetArguments() []IExpressionContext { return s.arguments } + +func (s *CharFunctionContext) SetArguments(v []IExpressionContext) { s.arguments = v } + +func (s *CharFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CharFunctionContext) CHAR() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR, 0) +} + +func (s *CharFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *CharFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *CharFunctionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CharFunctionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CharFunctionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *CharFunctionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *CharFunctionContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *CharFunctionContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *CharFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCharFunction(s) + } +} + +func (s *CharFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCharFunction(s) + } +} + +func (s *CharFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCharFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type IntervalLiteralContext struct { + PrimaryExpressionContext +} + +func NewIntervalLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntervalLiteralContext { + var p = new(IntervalLiteralContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *IntervalLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalLiteralContext) Interval() IIntervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIntervalContext) +} + +func (s *IntervalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIntervalLiteral(s) + } +} + +func (s *IntervalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIntervalLiteral(s) + } +} + +func (s *IntervalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIntervalLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type GroupConcatContext struct { + PrimaryExpressionContext + argument IExpressionContext + sep IExpressionContext +} + +func NewGroupConcatContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GroupConcatContext { + var p = new(GroupConcatContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *GroupConcatContext) GetArgument() IExpressionContext { return s.argument } + +func (s *GroupConcatContext) GetSep() IExpressionContext { return s.sep } + +func (s *GroupConcatContext) SetArgument(v IExpressionContext) { s.argument = v } + +func (s *GroupConcatContext) SetSep(v IExpressionContext) { s.sep = v } + +func (s *GroupConcatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GroupConcatContext) GROUP_CONCAT() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP_CONCAT, 0) +} + +func (s *GroupConcatContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *GroupConcatContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *GroupConcatContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *GroupConcatContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *GroupConcatContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *GroupConcatContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *GroupConcatContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *GroupConcatContext) ORDER() antlr.TerminalNode { + return s.GetToken(DorisParserORDER, 0) +} + +func (s *GroupConcatContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *GroupConcatContext) AllSortItem() []ISortItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISortItemContext); ok { + len++ + } + } + + tst := make([]ISortItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISortItemContext); ok { + tst[i] = t.(ISortItemContext) + i++ + } + } + + return tst +} + +func (s *GroupConcatContext) SortItem(i int) ISortItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISortItemContext) +} + +func (s *GroupConcatContext) SEPARATOR() antlr.TerminalNode { + return s.GetToken(DorisParserSEPARATOR, 0) +} + +func (s *GroupConcatContext) OVER() antlr.TerminalNode { + return s.GetToken(DorisParserOVER, 0) +} + +func (s *GroupConcatContext) WindowSpec() IWindowSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowSpecContext) +} + +func (s *GroupConcatContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(DorisParserDISTINCT, 0) +} + +func (s *GroupConcatContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *GroupConcatContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *GroupConcatContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *GroupConcatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGroupConcat(s) + } +} + +func (s *GroupConcatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGroupConcat(s) + } +} + +func (s *GroupConcatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGroupConcat(s) + + default: + return t.VisitChildren(s) + } +} + +type SimpleCaseContext struct { + PrimaryExpressionContext + value IExpressionContext + elseExpression IExpressionContext +} + +func NewSimpleCaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleCaseContext { + var p = new(SimpleCaseContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *SimpleCaseContext) GetValue() IExpressionContext { return s.value } + +func (s *SimpleCaseContext) GetElseExpression() IExpressionContext { return s.elseExpression } + +func (s *SimpleCaseContext) SetValue(v IExpressionContext) { s.value = v } + +func (s *SimpleCaseContext) SetElseExpression(v IExpressionContext) { s.elseExpression = v } + +func (s *SimpleCaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpleCaseContext) CASE() antlr.TerminalNode { + return s.GetToken(DorisParserCASE, 0) +} + +func (s *SimpleCaseContext) END() antlr.TerminalNode { + return s.GetToken(DorisParserEND, 0) +} + +func (s *SimpleCaseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SimpleCaseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SimpleCaseContext) AllWhenClause() []IWhenClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWhenClauseContext); ok { + len++ + } + } + + tst := make([]IWhenClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWhenClauseContext); ok { + tst[i] = t.(IWhenClauseContext) + i++ + } + } + + return tst +} + +func (s *SimpleCaseContext) WhenClause(i int) IWhenClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWhenClauseContext) +} + +func (s *SimpleCaseContext) ELSE() antlr.TerminalNode { + return s.GetToken(DorisParserELSE, 0) +} + +func (s *SimpleCaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSimpleCase(s) + } +} + +func (s *SimpleCaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSimpleCase(s) + } +} + +func (s *SimpleCaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSimpleCase(s) + + default: + return t.VisitChildren(s) + } +} + +type ColumnReferenceContext struct { + PrimaryExpressionContext +} + +func NewColumnReferenceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ColumnReferenceContext { + var p = new(ColumnReferenceContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ColumnReferenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnReferenceContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ColumnReferenceContext) BINARY() antlr.TerminalNode { + return s.GetToken(DorisParserBINARY, 0) +} + +func (s *ColumnReferenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterColumnReference(s) + } +} + +func (s *ColumnReferenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitColumnReference(s) + } +} + +func (s *ColumnReferenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitColumnReference(s) + + default: + return t.VisitChildren(s) + } +} + +type StarContext struct { + PrimaryExpressionContext +} + +func NewStarContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StarContext { + var p = new(StarContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *StarContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StarContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *StarContext) AllExceptOrReplace() []IExceptOrReplaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExceptOrReplaceContext); ok { + len++ + } + } + + tst := make([]IExceptOrReplaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExceptOrReplaceContext); ok { + tst[i] = t.(IExceptOrReplaceContext) + i++ + } + } + + return tst +} + +func (s *StarContext) ExceptOrReplace(i int) IExceptOrReplaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExceptOrReplaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExceptOrReplaceContext) +} + +func (s *StarContext) QualifiedName() IQualifiedNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualifiedNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualifiedNameContext) +} + +func (s *StarContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *StarContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStar(s) + } +} + +func (s *StarContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStar(s) + } +} + +func (s *StarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStar(s) + + default: + return t.VisitChildren(s) + } +} + +type GetFormatFunctionContext struct { + PrimaryExpressionContext +} + +func NewGetFormatFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GetFormatFunctionContext { + var p = new(GetFormatFunctionContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *GetFormatFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GetFormatFunctionContext) GET_FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserGET_FORMAT, 0) +} + +func (s *GetFormatFunctionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *GetFormatFunctionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *GetFormatFunctionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *GetFormatFunctionContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *GetFormatFunctionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *GetFormatFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterGetFormatFunction(s) + } +} + +func (s *GetFormatFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitGetFormatFunction(s) + } +} + +func (s *GetFormatFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitGetFormatFunction(s) + + default: + return t.VisitChildren(s) + } +} + +type SessionUserContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewSessionUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SessionUserContext { + var p = new(SessionUserContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *SessionUserContext) GetName() antlr.Token { return s.name } + +func (s *SessionUserContext) SetName(v antlr.Token) { s.name = v } + +func (s *SessionUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SessionUserContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(DorisParserSESSION_USER, 0) +} + +func (s *SessionUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSessionUser(s) + } +} + +func (s *SessionUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSessionUser(s) + } +} + +func (s *SessionUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSessionUser(s) + + default: + return t.VisitChildren(s) + } +} + +type ConvertTypeContext struct { + PrimaryExpressionContext + argument IExpressionContext +} + +func NewConvertTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConvertTypeContext { + var p = new(ConvertTypeContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ConvertTypeContext) GetArgument() IExpressionContext { return s.argument } + +func (s *ConvertTypeContext) SetArgument(v IExpressionContext) { s.argument = v } + +func (s *ConvertTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConvertTypeContext) CONVERT() antlr.TerminalNode { + return s.GetToken(DorisParserCONVERT, 0) +} + +func (s *ConvertTypeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ConvertTypeContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *ConvertTypeContext) CastDataType() ICastDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICastDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICastDataTypeContext) +} + +func (s *ConvertTypeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ConvertTypeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ConvertTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterConvertType(s) + } +} + +func (s *ConvertTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitConvertType(s) + } +} + +func (s *ConvertTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitConvertType(s) + + default: + return t.VisitChildren(s) + } +} + +type ConvertCharSetContext struct { + PrimaryExpressionContext + argument IExpressionContext + charSet IIdentifierOrTextContext +} + +func NewConvertCharSetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConvertCharSetContext { + var p = new(ConvertCharSetContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ConvertCharSetContext) GetArgument() IExpressionContext { return s.argument } + +func (s *ConvertCharSetContext) GetCharSet() IIdentifierOrTextContext { return s.charSet } + +func (s *ConvertCharSetContext) SetArgument(v IExpressionContext) { s.argument = v } + +func (s *ConvertCharSetContext) SetCharSet(v IIdentifierOrTextContext) { s.charSet = v } + +func (s *ConvertCharSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConvertCharSetContext) CONVERT() antlr.TerminalNode { + return s.GetToken(DorisParserCONVERT, 0) +} + +func (s *ConvertCharSetContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ConvertCharSetContext) USING() antlr.TerminalNode { + return s.GetToken(DorisParserUSING, 0) +} + +func (s *ConvertCharSetContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ConvertCharSetContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ConvertCharSetContext) IdentifierOrText() IIdentifierOrTextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierOrTextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierOrTextContext) +} + +func (s *ConvertCharSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterConvertCharSet(s) + } +} + +func (s *ConvertCharSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitConvertCharSet(s) + } +} + +func (s *ConvertCharSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitConvertCharSet(s) + + default: + return t.VisitChildren(s) + } +} + +type SubqueryExpressionContext struct { + PrimaryExpressionContext +} + +func NewSubqueryExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryExpressionContext { + var p = new(SubqueryExpressionContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *SubqueryExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryExpressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SubqueryExpressionContext) Query() IQueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueryContext) +} + +func (s *SubqueryExpressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SubqueryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSubqueryExpression(s) + } +} + +func (s *SubqueryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSubqueryExpression(s) + } +} + +func (s *SubqueryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSubqueryExpression(s) + + default: + return t.VisitChildren(s) + } +} + +type EncryptKeyContext struct { + PrimaryExpressionContext + dbName IIdentifierContext + keyName IIdentifierContext +} + +func NewEncryptKeyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EncryptKeyContext { + var p = new(EncryptKeyContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *EncryptKeyContext) GetDbName() IIdentifierContext { return s.dbName } + +func (s *EncryptKeyContext) GetKeyName() IIdentifierContext { return s.keyName } + +func (s *EncryptKeyContext) SetDbName(v IIdentifierContext) { s.dbName = v } + +func (s *EncryptKeyContext) SetKeyName(v IIdentifierContext) { s.keyName = v } + +func (s *EncryptKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EncryptKeyContext) KEY() antlr.TerminalNode { + return s.GetToken(DorisParserKEY, 0) +} + +func (s *EncryptKeyContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *EncryptKeyContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *EncryptKeyContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *EncryptKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterEncryptKey(s) + } +} + +func (s *EncryptKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitEncryptKey(s) + } +} + +func (s *EncryptKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitEncryptKey(s) + + default: + return t.VisitChildren(s) + } +} + +type CurrentTimeContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewCurrentTimeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentTimeContext { + var p = new(CurrentTimeContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CurrentTimeContext) GetName() antlr.Token { return s.name } + +func (s *CurrentTimeContext) SetName(v antlr.Token) { s.name = v } + +func (s *CurrentTimeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentTimeContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_TIME, 0) +} + +func (s *CurrentTimeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCurrentTime(s) + } +} + +func (s *CurrentTimeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCurrentTime(s) + } +} + +func (s *CurrentTimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCurrentTime(s) + + default: + return t.VisitChildren(s) + } +} + +type LocalTimeContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewLocalTimeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LocalTimeContext { + var p = new(LocalTimeContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *LocalTimeContext) GetName() antlr.Token { return s.name } + +func (s *LocalTimeContext) SetName(v antlr.Token) { s.name = v } + +func (s *LocalTimeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LocalTimeContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(DorisParserLOCALTIME, 0) +} + +func (s *LocalTimeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterLocalTime(s) + } +} + +func (s *LocalTimeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitLocalTime(s) + } +} + +func (s *LocalTimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitLocalTime(s) + + default: + return t.VisitChildren(s) + } +} + +type SystemVariableContext struct { + PrimaryExpressionContext + kind antlr.Token +} + +func NewSystemVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SystemVariableContext { + var p = new(SystemVariableContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *SystemVariableContext) GetKind() antlr.Token { return s.kind } + +func (s *SystemVariableContext) SetKind(v antlr.Token) { s.kind = v } + +func (s *SystemVariableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SystemVariableContext) DOUBLEATSIGN() antlr.TerminalNode { + return s.GetToken(DorisParserDOUBLEATSIGN, 0) +} + +func (s *SystemVariableContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SystemVariableContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *SystemVariableContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(DorisParserGLOBAL, 0) +} + +func (s *SystemVariableContext) SESSION() antlr.TerminalNode { + return s.GetToken(DorisParserSESSION, 0) +} + +func (s *SystemVariableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSystemVariable(s) + } +} + +func (s *SystemVariableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSystemVariable(s) + } +} + +func (s *SystemVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSystemVariable(s) + + default: + return t.VisitChildren(s) + } +} + +type CollateContext struct { + PrimaryExpressionContext +} + +func NewCollateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollateContext { + var p = new(CollateContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CollateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollateContext) PrimaryExpression() IPrimaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryExpressionContext) +} + +func (s *CollateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(DorisParserCOLLATE, 0) +} + +func (s *CollateContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CollateContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CollateContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(DorisParserDEFAULT, 0) +} + +func (s *CollateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCollate(s) + } +} + +func (s *CollateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCollate(s) + } +} + +func (s *CollateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCollate(s) + + default: + return t.VisitChildren(s) + } +} + +type CurrentUserContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewCurrentUserContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentUserContext { + var p = new(CurrentUserContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CurrentUserContext) GetName() antlr.Token { return s.name } + +func (s *CurrentUserContext) SetName(v antlr.Token) { s.name = v } + +func (s *CurrentUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentUserContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_USER, 0) +} + +func (s *CurrentUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCurrentUser(s) + } +} + +func (s *CurrentUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCurrentUser(s) + } +} + +func (s *CurrentUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCurrentUser(s) + + default: + return t.VisitChildren(s) + } +} + +type ConstantDefaultContext struct { + PrimaryExpressionContext +} + +func NewConstantDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstantDefaultContext { + var p = new(ConstantDefaultContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ConstantDefaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantDefaultContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *ConstantDefaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterConstantDefault(s) + } +} + +func (s *ConstantDefaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitConstantDefault(s) + } +} + +func (s *ConstantDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitConstantDefault(s) + + default: + return t.VisitChildren(s) + } +} + +type ExtractContext struct { + PrimaryExpressionContext + field IIdentifierContext + source IValueExpressionContext +} + +func NewExtractContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExtractContext { + var p = new(ExtractContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ExtractContext) GetField() IIdentifierContext { return s.field } + +func (s *ExtractContext) GetSource() IValueExpressionContext { return s.source } + +func (s *ExtractContext) SetField(v IIdentifierContext) { s.field = v } + +func (s *ExtractContext) SetSource(v IValueExpressionContext) { s.source = v } + +func (s *ExtractContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExtractContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserEXTRACT, 0) +} + +func (s *ExtractContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ExtractContext) FROM() antlr.TerminalNode { + return s.GetToken(DorisParserFROM, 0) +} + +func (s *ExtractContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ExtractContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ExtractContext) ValueExpression() IValueExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ExtractContext) DATE() antlr.TerminalNode { + return s.GetToken(DorisParserDATE, 0) +} + +func (s *ExtractContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserTIMESTAMP, 0) +} + +func (s *ExtractContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExtract(s) + } +} + +func (s *ExtractContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExtract(s) + } +} + +func (s *ExtractContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExtract(s) + + default: + return t.VisitChildren(s) + } +} + +type CurrentTimestampContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewCurrentTimestampContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CurrentTimestampContext { + var p = new(CurrentTimestampContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *CurrentTimestampContext) GetName() antlr.Token { return s.name } + +func (s *CurrentTimestampContext) SetName(v antlr.Token) { s.name = v } + +func (s *CurrentTimestampContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CurrentTimestampContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_TIMESTAMP, 0) +} + +func (s *CurrentTimestampContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCurrentTimestamp(s) + } +} + +func (s *CurrentTimestampContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCurrentTimestamp(s) + } +} + +func (s *CurrentTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCurrentTimestamp(s) + + default: + return t.VisitChildren(s) + } +} + +type FunctionCallContext struct { + PrimaryExpressionContext +} + +func NewFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FunctionCallContext { + var p = new(FunctionCallContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionCallContext) FunctionCallExpression() IFunctionCallExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallExpressionContext) +} + +func (s *FunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFunctionCall(s) + } +} + +func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFunctionCall(s) + } +} + +func (s *FunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFunctionCall(s) + + default: + return t.VisitChildren(s) + } +} + +type ArraySliceContext struct { + PrimaryExpressionContext + value IPrimaryExpressionContext + begin IValueExpressionContext + end IValueExpressionContext +} + +func NewArraySliceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArraySliceContext { + var p = new(ArraySliceContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *ArraySliceContext) GetValue() IPrimaryExpressionContext { return s.value } + +func (s *ArraySliceContext) GetBegin() IValueExpressionContext { return s.begin } + +func (s *ArraySliceContext) GetEnd() IValueExpressionContext { return s.end } + +func (s *ArraySliceContext) SetValue(v IPrimaryExpressionContext) { s.value = v } + +func (s *ArraySliceContext) SetBegin(v IValueExpressionContext) { s.begin = v } + +func (s *ArraySliceContext) SetEnd(v IValueExpressionContext) { s.end = v } + +func (s *ArraySliceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ArraySliceContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *ArraySliceContext) COLON() antlr.TerminalNode { + return s.GetToken(DorisParserCOLON, 0) +} + +func (s *ArraySliceContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *ArraySliceContext) PrimaryExpression() IPrimaryExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryExpressionContext) +} + +func (s *ArraySliceContext) AllValueExpression() []IValueExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValueExpressionContext); ok { + len++ + } + } + + tst := make([]IValueExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValueExpressionContext); ok { + tst[i] = t.(IValueExpressionContext) + i++ + } + } + + return tst +} + +func (s *ArraySliceContext) ValueExpression(i int) IValueExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValueExpressionContext) +} + +func (s *ArraySliceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterArraySlice(s) + } +} + +func (s *ArraySliceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitArraySlice(s) + } +} + +func (s *ArraySliceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitArraySlice(s) + + default: + return t.VisitChildren(s) + } +} + +type SearchedCaseContext struct { + PrimaryExpressionContext + elseExpression IExpressionContext +} + +func NewSearchedCaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SearchedCaseContext { + var p = new(SearchedCaseContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *SearchedCaseContext) GetElseExpression() IExpressionContext { return s.elseExpression } + +func (s *SearchedCaseContext) SetElseExpression(v IExpressionContext) { s.elseExpression = v } + +func (s *SearchedCaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SearchedCaseContext) CASE() antlr.TerminalNode { + return s.GetToken(DorisParserCASE, 0) +} + +func (s *SearchedCaseContext) END() antlr.TerminalNode { + return s.GetToken(DorisParserEND, 0) +} + +func (s *SearchedCaseContext) AllWhenClause() []IWhenClauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWhenClauseContext); ok { + len++ + } + } + + tst := make([]IWhenClauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWhenClauseContext); ok { + tst[i] = t.(IWhenClauseContext) + i++ + } + } + + return tst +} + +func (s *SearchedCaseContext) WhenClause(i int) IWhenClauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenClauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWhenClauseContext) +} + +func (s *SearchedCaseContext) ELSE() antlr.TerminalNode { + return s.GetToken(DorisParserELSE, 0) +} + +func (s *SearchedCaseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SearchedCaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSearchedCase(s) + } +} + +func (s *SearchedCaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSearchedCase(s) + } +} + +func (s *SearchedCaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSearchedCase(s) + + default: + return t.VisitChildren(s) + } +} + +type PositionContext struct { + PrimaryExpressionContext +} + +func NewPositionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PositionContext { + var p = new(PositionContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *PositionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PositionContext) POSITION() antlr.TerminalNode { + return s.GetToken(DorisParserPOSITION, 0) +} + +func (s *PositionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PositionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PositionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PositionContext) IN() antlr.TerminalNode { + return s.GetToken(DorisParserIN, 0) +} + +func (s *PositionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PositionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPosition(s) + } +} + +func (s *PositionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPosition(s) + } +} + +func (s *PositionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPosition(s) + + default: + return t.VisitChildren(s) + } +} + +type TryCastContext struct { + PrimaryExpressionContext + name antlr.Token +} + +func NewTryCastContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TryCastContext { + var p = new(TryCastContext) + + InitEmptyPrimaryExpressionContext(&p.PrimaryExpressionContext) + p.parser = parser + p.CopyAll(ctx.(*PrimaryExpressionContext)) + + return p +} + +func (s *TryCastContext) GetName() antlr.Token { return s.name } + +func (s *TryCastContext) SetName(v antlr.Token) { s.name = v } + +func (s *TryCastContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TryCastContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *TryCastContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TryCastContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *TryCastContext) CastDataType() ICastDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICastDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICastDataTypeContext) +} + +func (s *TryCastContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *TryCastContext) TRY_CAST() antlr.TerminalNode { + return s.GetToken(DorisParserTRY_CAST, 0) +} + +func (s *TryCastContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTryCast(s) + } +} + +func (s *TryCastContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTryCast(s) + } +} + +func (s *TryCastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTryCast(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { + return p.primaryExpression(0) +} + +func (p *DorisParser) primaryExpression(_p int) (localctx IPrimaryExpressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewPrimaryExpressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IPrimaryExpressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 398 + p.EnterRecursionRule(localctx, 398, DorisParserRULE_primaryExpression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 902, p.GetParserRuleContext()) { + case 1: + localctx = NewCurrentDateContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + + { + p.SetState(6124) + + var _m = p.Match(DorisParserCURRENT_DATE) + + localctx.(*CurrentDateContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewCurrentTimeContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6125) + + var _m = p.Match(DorisParserCURRENT_TIME) + + localctx.(*CurrentTimeContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewCurrentTimestampContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6126) + + var _m = p.Match(DorisParserCURRENT_TIMESTAMP) + + localctx.(*CurrentTimestampContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewLocalTimeContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6127) + + var _m = p.Match(DorisParserLOCALTIME) + + localctx.(*LocalTimeContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewLocalTimestampContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6128) + + var _m = p.Match(DorisParserLOCALTIMESTAMP) + + localctx.(*LocalTimestampContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewCurrentUserContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6129) + + var _m = p.Match(DorisParserCURRENT_USER) + + localctx.(*CurrentUserContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + localctx = NewSessionUserContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6130) + + var _m = p.Match(DorisParserSESSION_USER) + + localctx.(*SessionUserContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewSearchedCaseContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6131) + p.Match(DorisParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == DorisParserWHEN { + { + p.SetState(6132) + p.WhenClause() + } + + p.SetState(6135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserELSE { + { + p.SetState(6137) + p.Match(DorisParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6138) + + var _x = p.Expression() + + localctx.(*SearchedCaseContext).elseExpression = _x + } + + } + { + p.SetState(6141) + p.Match(DorisParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewSimpleCaseContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6143) + p.Match(DorisParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6144) + + var _x = p.Expression() + + localctx.(*SimpleCaseContext).value = _x + } + p.SetState(6146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == DorisParserWHEN { + { + p.SetState(6145) + p.WhenClause() + } + + p.SetState(6148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserELSE { + { + p.SetState(6150) + p.Match(DorisParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6151) + + var _x = p.Expression() + + localctx.(*SimpleCaseContext).elseExpression = _x + } + + } + { + p.SetState(6154) + p.Match(DorisParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewCastContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6156) + + var _m = p.Match(DorisParserCAST) + + localctx.(*CastContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6157) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6158) + p.Expression() + } + { + p.SetState(6159) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6160) + p.CastDataType() + } + { + p.SetState(6161) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + localctx = NewTryCastContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6163) + + var _m = p.Match(DorisParserTRY_CAST) + + localctx.(*TryCastContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6164) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6165) + p.Expression() + } + { + p.SetState(6166) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6167) + p.CastDataType() + } + { + p.SetState(6168) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewConstantDefaultContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6170) + p.Constant() + } + + case 13: + localctx = NewIntervalLiteralContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6171) + p.Interval() + } + + case 14: + localctx = NewStarContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6172) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 885, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6173) + p.ExceptOrReplace() + } + + } + p.SetState(6178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 885, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 15: + localctx = NewStarContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6179) + p.QualifiedName() + } + { + p.SetState(6180) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6181) + p.Match(DorisParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 886, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6182) + p.ExceptOrReplace() + } + + } + p.SetState(6187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 886, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 16: + localctx = NewCharFunctionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6188) + p.Match(DorisParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6189) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6190) + + var _x = p.Expression() + + localctx.(*CharFunctionContext)._expression = _x + } + localctx.(*CharFunctionContext).arguments = append(localctx.(*CharFunctionContext).arguments, localctx.(*CharFunctionContext)._expression) + p.SetState(6195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6191) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6192) + + var _x = p.Expression() + + localctx.(*CharFunctionContext)._expression = _x + } + localctx.(*CharFunctionContext).arguments = append(localctx.(*CharFunctionContext).arguments, localctx.(*CharFunctionContext)._expression) + + p.SetState(6197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserUSING { + { + p.SetState(6198) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6199) + + var _x = p.IdentifierOrText() + + localctx.(*CharFunctionContext).charSet = _x + } + + } + { + p.SetState(6202) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + localctx = NewConvertCharSetContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6204) + p.Match(DorisParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6205) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6206) + + var _x = p.Expression() + + localctx.(*ConvertCharSetContext).argument = _x + } + { + p.SetState(6207) + p.Match(DorisParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6208) + + var _x = p.IdentifierOrText() + + localctx.(*ConvertCharSetContext).charSet = _x + } + { + p.SetState(6209) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + localctx = NewConvertTypeContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6211) + p.Match(DorisParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6212) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6213) + + var _x = p.Expression() + + localctx.(*ConvertTypeContext).argument = _x + } + { + p.SetState(6214) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6215) + p.CastDataType() + } + { + p.SetState(6216) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + localctx = NewGroupConcatContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6218) + p.Match(DorisParserGROUP_CONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6219) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL || _la == DorisParserDISTINCT { + { + p.SetState(6220) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserALL || _la == DorisParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6227) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 890, p.GetParserRuleContext()) == 1 { + { + p.SetState(6223) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6224) + p.Identifier() + } + { + p.SetState(6225) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6229) + + var _x = p.Expression() + + localctx.(*GroupConcatContext).argument = _x + } + p.SetState(6240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(6230) + p.Match(DorisParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6231) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6232) + p.SortItem() + } + p.SetState(6237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6233) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6234) + p.SortItem() + } + + p.SetState(6239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(6244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSEPARATOR { + { + p.SetState(6242) + p.Match(DorisParserSEPARATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6243) + + var _x = p.Expression() + + localctx.(*GroupConcatContext).sep = _x + } + + } + { + p.SetState(6246) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6249) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 1 { + { + p.SetState(6247) + p.Match(DorisParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6248) + p.WindowSpec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 20: + localctx = NewGetFormatFunctionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6251) + p.Match(DorisParserGET_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6252) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6253) + p.Expression() + } + { + p.SetState(6254) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6255) + p.Expression() + } + { + p.SetState(6256) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + localctx = NewTrimContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6258) + p.Match(DorisParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6259) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserBOTH, DorisParserLEADING, DorisParserTRAILING: + { + p.SetState(6260) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserBOTH || _la == DorisParserLEADING || _la == DorisParserTRAILING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762031699) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(6261) + p.Expression() + } + + } + + case DorisParserLEFT_PAREN, DorisParserLEFT_BRACKET, DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserADD, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBINARY, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCASE, DorisParserCAST, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATABASE, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXISTS, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserEXTRACT, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFALSE, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIF, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINTERVAL, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserKEY, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLEFT, DorisParserLESS, DorisParserLEVEL, DorisParserLIKE, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNOT, DorisParserNULL, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLACEHOLDER, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREGEXP, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRIGHT, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRIM, DorisParserTRUE, DorisParserTRUNCATE, DorisParserTRY_CAST, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserPLUS, DorisParserSUBTRACT, DorisParserASTERISK, DorisParserTILDE, DorisParserLOGICALNOT, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserATSIGN, DorisParserDOUBLEATSIGN, DorisParserSTRING_LITERAL, DorisParserVARBINARY_LITERAL, DorisParserINTEGER_VALUE, DorisParserEXPONENT_VALUE, DorisParserDECIMAL_VALUE, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(6264) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6267) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6268) + p.Expression() + } + { + p.SetState(6269) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + localctx = NewSubstringContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6271) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserMID || _la == DorisParserSUBSTR || _la == DorisParserSUBSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6272) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6273) + p.Expression() + } + { + p.SetState(6274) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6275) + p.Expression() + } + p.SetState(6278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserFOR { + { + p.SetState(6276) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6277) + p.Expression() + } + + } + { + p.SetState(6280) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + localctx = NewPositionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6282) + p.Match(DorisParserPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6283) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6284) + p.Expression() + } + { + p.SetState(6285) + p.Match(DorisParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6286) + p.Expression() + } + { + p.SetState(6287) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + localctx = NewFunctionCallContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6289) + p.FunctionCallExpression() + } + + case 25: + localctx = NewSubqueryExpressionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6290) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6291) + p.Query() + } + { + p.SetState(6292) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + localctx = NewUserVariableContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6294) + p.Match(DorisParserATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6295) + p.IdentifierOrText() + } + + case 27: + localctx = NewSystemVariableContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6296) + p.Match(DorisParserDOUBLEATSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6299) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 898, p.GetParserRuleContext()) == 1 { + { + p.SetState(6297) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*SystemVariableContext).kind = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserGLOBAL || _la == DorisParserSESSION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*SystemVariableContext).kind = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6298) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6301) + p.Identifier() + } + + case 28: + localctx = NewColumnReferenceContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + p.SetState(6303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBINARY { + { + p.SetState(6302) + p.Match(DorisParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6305) + p.Identifier() + } + + case 29: + localctx = NewParenthesizedExpressionContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6306) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6307) + p.Expression() + } + { + p.SetState(6308) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + localctx = NewEncryptKeyContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6310) + p.Match(DorisParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6314) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 900, p.GetParserRuleContext()) == 1 { + { + p.SetState(6311) + + var _x = p.Identifier() + + localctx.(*EncryptKeyContext).dbName = _x + } + { + p.SetState(6312) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6316) + + var _x = p.Identifier() + + localctx.(*EncryptKeyContext).keyName = _x + } + + case 31: + localctx = NewExtractContext(p, localctx) + p.SetParserRuleContext(localctx) + _prevctx = localctx + { + p.SetState(6317) + p.Match(DorisParserEXTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6318) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6319) + + var _x = p.Identifier() + + localctx.(*ExtractContext).field = _x + } + { + p.SetState(6320) + p.Match(DorisParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6322) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 901, p.GetParserRuleContext()) == 1 { + { + p.SetState(6321) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserDATE || _la == DorisParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6324) + + var _x = p.valueExpression(0) + + localctx.(*ExtractContext).source = _x + } + { + p.SetState(6325) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(6355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 906, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(6353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 905, p.GetParserRuleContext()) { + case 1: + localctx = NewElementAtContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) + localctx.(*ElementAtContext).value = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_primaryExpression) + p.SetState(6329) + + if !(p.Precpred(p.GetParserRuleContext(), 11)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", "")) + goto errorExit + } + { + p.SetState(6330) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6331) + + var _x = p.valueExpression(0) + + localctx.(*ElementAtContext).index = _x + } + { + p.SetState(6332) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewArraySliceContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) + localctx.(*ArraySliceContext).value = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_primaryExpression) + p.SetState(6334) + + if !(p.Precpred(p.GetParserRuleContext(), 10)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) + goto errorExit + } + { + p.SetState(6335) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6336) + + var _x = p.valueExpression(0) + + localctx.(*ArraySliceContext).begin = _x + } + { + p.SetState(6337) + p.Match(DorisParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277557787004) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607516119273676371) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&6899197694829293417) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935272342204252157) != 0) || _la == DorisParserGET_FORMAT { + { + p.SetState(6338) + + var _x = p.valueExpression(0) + + localctx.(*ArraySliceContext).end = _x + } + + } + { + p.SetState(6341) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewDereferenceContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) + localctx.(*DereferenceContext).base = _prevctx + + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_primaryExpression) + p.SetState(6343) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(6344) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6345) + + var _x = p.Identifier() + + localctx.(*DereferenceContext).fieldName = _x + } + + case 4: + localctx = NewCollateContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) + p.PushNewRecursionContext(localctx, _startState, DorisParserRULE_primaryExpression) + p.SetState(6346) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(6347) + p.Match(DorisParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(6348) + p.Identifier() + } + + case DorisParserSTRING_LITERAL: + { + p.SetState(6349) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDEFAULT: + { + p.SetState(6350) + p.Match(DorisParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(6357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 906, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExceptOrReplaceContext is an interface to support dynamic dispatch. +type IExceptOrReplaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsExceptOrReplaceContext differentiates from other interfaces. + IsExceptOrReplaceContext() +} + +type ExceptOrReplaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExceptOrReplaceContext() *ExceptOrReplaceContext { + var p = new(ExceptOrReplaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_exceptOrReplace + return p +} + +func InitEmptyExceptOrReplaceContext(p *ExceptOrReplaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_exceptOrReplace +} + +func (*ExceptOrReplaceContext) IsExceptOrReplaceContext() {} + +func NewExceptOrReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExceptOrReplaceContext { + var p = new(ExceptOrReplaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_exceptOrReplace + + return p +} + +func (s *ExceptOrReplaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExceptOrReplaceContext) CopyAll(ctx *ExceptOrReplaceContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ExceptOrReplaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExceptOrReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ReplaceContext struct { + ExceptOrReplaceContext +} + +func NewReplaceContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ReplaceContext { + var p = new(ReplaceContext) + + InitEmptyExceptOrReplaceContext(&p.ExceptOrReplaceContext) + p.parser = parser + p.CopyAll(ctx.(*ExceptOrReplaceContext)) + + return p +} + +func (s *ReplaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplaceContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *ReplaceContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ReplaceContext) NamedExpressionSeq() INamedExpressionSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamedExpressionSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamedExpressionSeqContext) +} + +func (s *ReplaceContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ReplaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterReplace(s) + } +} + +func (s *ReplaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitReplace(s) + } +} + +func (s *ReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitReplace(s) + + default: + return t.VisitChildren(s) + } +} + +type ExceptContext struct { + ExceptOrReplaceContext +} + +func NewExceptContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExceptContext { + var p = new(ExceptContext) + + InitEmptyExceptOrReplaceContext(&p.ExceptOrReplaceContext) + p.parser = parser + p.CopyAll(ctx.(*ExceptOrReplaceContext)) + + return p +} + +func (s *ExceptContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExceptContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(DorisParserEXCEPT, 0) +} + +func (s *ExceptContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *ExceptContext) NamedExpressionSeq() INamedExpressionSeqContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INamedExpressionSeqContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INamedExpressionSeqContext) +} + +func (s *ExceptContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *ExceptContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterExcept(s) + } +} + +func (s *ExceptContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitExcept(s) + } +} + +func (s *ExceptContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitExcept(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ExceptOrReplace() (localctx IExceptOrReplaceContext) { + localctx = NewExceptOrReplaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, DorisParserRULE_exceptOrReplace) + p.SetState(6368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserEXCEPT: + localctx = NewExceptContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6358) + p.Match(DorisParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6359) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6360) + p.NamedExpressionSeq() + } + { + p.SetState(6361) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserREPLACE: + localctx = NewReplaceContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6363) + p.Match(DorisParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6364) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6365) + p.NamedExpressionSeq() + } + { + p.SetState(6366) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICastDataTypeContext is an interface to support dynamic dispatch. +type ICastDataTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DataType() IDataTypeContext + SIGNED() antlr.TerminalNode + UNSIGNED() antlr.TerminalNode + INT() antlr.TerminalNode + INTEGER() antlr.TerminalNode + + // IsCastDataTypeContext differentiates from other interfaces. + IsCastDataTypeContext() +} + +type CastDataTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCastDataTypeContext() *CastDataTypeContext { + var p = new(CastDataTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_castDataType + return p +} + +func InitEmptyCastDataTypeContext(p *CastDataTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_castDataType +} + +func (*CastDataTypeContext) IsCastDataTypeContext() {} + +func NewCastDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CastDataTypeContext { + var p = new(CastDataTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_castDataType + + return p +} + +func (s *CastDataTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *CastDataTypeContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *CastDataTypeContext) SIGNED() antlr.TerminalNode { + return s.GetToken(DorisParserSIGNED, 0) +} + +func (s *CastDataTypeContext) UNSIGNED() antlr.TerminalNode { + return s.GetToken(DorisParserUNSIGNED, 0) +} + +func (s *CastDataTypeContext) INT() antlr.TerminalNode { + return s.GetToken(DorisParserINT, 0) +} + +func (s *CastDataTypeContext) INTEGER() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER, 0) +} + +func (s *CastDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CastDataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CastDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCastDataType(s) + } +} + +func (s *CastDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCastDataType(s) + } +} + +func (s *CastDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCastDataType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) CastDataType() (localctx ICastDataTypeContext) { + localctx = NewCastDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, DorisParserRULE_castDataType) + var _la int + + p.SetState(6375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserAGG_STATE, DorisParserALL, DorisParserARRAY, DorisParserBIGINT, DorisParserBITMAP, DorisParserBOOLEAN, DorisParserCHAR, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDOUBLE, DorisParserFLOAT, DorisParserHLL, DorisParserINT, DorisParserINTEGER, DorisParserIPV4, DorisParserIPV6, DorisParserJSON, DorisParserJSONB, DorisParserLARGEINT, DorisParserMAP, DorisParserQUANTILE_STATE, DorisParserSMALLINT, DorisParserSTRING, DorisParserSTRUCT, DorisParserTEXT, DorisParserTIME, DorisParserTINYINT, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIANT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6370) + p.DataType() + } + + case DorisParserSIGNED, DorisParserUNSIGNED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6371) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserSIGNED || _la == DorisParserUNSIGNED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINT || _la == DorisParserINTEGER { + { + p.SetState(6372) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserINT || _la == DorisParserINTEGER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionCallExpressionContext is an interface to support dynamic dispatch. +type IFunctionCallExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_funcExpression returns the _funcExpression rule contexts. + Get_funcExpression() IFuncExpressionContext + + // Set_funcExpression sets the _funcExpression rule contexts. + Set_funcExpression(IFuncExpressionContext) + + // GetArguments returns the arguments rule context list. + GetArguments() []IFuncExpressionContext + + // SetArguments sets the arguments rule context list. + SetArguments([]IFuncExpressionContext) + + // Getter signatures + FunctionIdentifier() IFunctionIdentifierContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + OVER() antlr.TerminalNode + WindowSpec() IWindowSpecContext + AllFuncExpression() []IFuncExpressionContext + FuncExpression(i int) IFuncExpressionContext + LEFT_BRACKET() antlr.TerminalNode + Identifier() IIdentifierContext + RIGHT_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllSortItem() []ISortItemContext + SortItem(i int) ISortItemContext + DISTINCT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsFunctionCallExpressionContext differentiates from other interfaces. + IsFunctionCallExpressionContext() +} + +type FunctionCallExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _funcExpression IFuncExpressionContext + arguments []IFuncExpressionContext +} + +func NewEmptyFunctionCallExpressionContext() *FunctionCallExpressionContext { + var p = new(FunctionCallExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionCallExpression + return p +} + +func InitEmptyFunctionCallExpressionContext(p *FunctionCallExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionCallExpression +} + +func (*FunctionCallExpressionContext) IsFunctionCallExpressionContext() {} + +func NewFunctionCallExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallExpressionContext { + var p = new(FunctionCallExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_functionCallExpression + + return p +} + +func (s *FunctionCallExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionCallExpressionContext) Get_funcExpression() IFuncExpressionContext { + return s._funcExpression +} + +func (s *FunctionCallExpressionContext) Set_funcExpression(v IFuncExpressionContext) { + s._funcExpression = v +} + +func (s *FunctionCallExpressionContext) GetArguments() []IFuncExpressionContext { return s.arguments } + +func (s *FunctionCallExpressionContext) SetArguments(v []IFuncExpressionContext) { s.arguments = v } + +func (s *FunctionCallExpressionContext) FunctionIdentifier() IFunctionIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionIdentifierContext) +} + +func (s *FunctionCallExpressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *FunctionCallExpressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *FunctionCallExpressionContext) OVER() antlr.TerminalNode { + return s.GetToken(DorisParserOVER, 0) +} + +func (s *FunctionCallExpressionContext) WindowSpec() IWindowSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowSpecContext) +} + +func (s *FunctionCallExpressionContext) AllFuncExpression() []IFuncExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFuncExpressionContext); ok { + len++ + } + } + + tst := make([]IFuncExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFuncExpressionContext); ok { + tst[i] = t.(IFuncExpressionContext) + i++ + } + } + + return tst +} + +func (s *FunctionCallExpressionContext) FuncExpression(i int) IFuncExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFuncExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFuncExpressionContext) +} + +func (s *FunctionCallExpressionContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *FunctionCallExpressionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *FunctionCallExpressionContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *FunctionCallExpressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *FunctionCallExpressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *FunctionCallExpressionContext) ORDER() antlr.TerminalNode { + return s.GetToken(DorisParserORDER, 0) +} + +func (s *FunctionCallExpressionContext) BY() antlr.TerminalNode { + return s.GetToken(DorisParserBY, 0) +} + +func (s *FunctionCallExpressionContext) AllSortItem() []ISortItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISortItemContext); ok { + len++ + } + } + + tst := make([]ISortItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISortItemContext); ok { + tst[i] = t.(ISortItemContext) + i++ + } + } + + return tst +} + +func (s *FunctionCallExpressionContext) SortItem(i int) ISortItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISortItemContext) +} + +func (s *FunctionCallExpressionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(DorisParserDISTINCT, 0) +} + +func (s *FunctionCallExpressionContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *FunctionCallExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionCallExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionCallExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFunctionCallExpression(s) + } +} + +func (s *FunctionCallExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFunctionCallExpression(s) + } +} + +func (s *FunctionCallExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFunctionCallExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FunctionCallExpression() (localctx IFunctionCallExpressionContext) { + localctx = NewFunctionCallExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, DorisParserRULE_functionCallExpression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6377) + p.FunctionIdentifier() + } + { + p.SetState(6378) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-4629742277556738428) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-5769142467333493765) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&4607656856762048083) != 0) || ((int64((_la-196)) & ^0x3f) == 0 && ((int64(1)<<(_la-196))&-1162348339364124845) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&-2324174342025482391) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-8647012473981499429) != 0) || ((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&-4712482699342778601) != 0) || ((int64((_la-454)) & ^0x3f) == 0 && ((int64(1)<<(_la-454))&2705254366654775295) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&7935273441715879933) != 0) || _la == DorisParserGET_FORMAT { + p.SetState(6380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserALL || _la == DorisParserDISTINCT { + { + p.SetState(6379) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserALL || _la == DorisParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6386) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 911, p.GetParserRuleContext()) == 1 { + { + p.SetState(6382) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6383) + p.Identifier() + } + { + p.SetState(6384) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6388) + + var _x = p.FuncExpression() + + localctx.(*FunctionCallExpressionContext)._funcExpression = _x + } + localctx.(*FunctionCallExpressionContext).arguments = append(localctx.(*FunctionCallExpressionContext).arguments, localctx.(*FunctionCallExpressionContext)._funcExpression) + p.SetState(6393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6389) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6390) + + var _x = p.FuncExpression() + + localctx.(*FunctionCallExpressionContext)._funcExpression = _x + } + localctx.(*FunctionCallExpressionContext).arguments = append(localctx.(*FunctionCallExpressionContext).arguments, localctx.(*FunctionCallExpressionContext)._funcExpression) + + p.SetState(6395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(6396) + p.Match(DorisParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6397) + p.Match(DorisParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6398) + p.SortItem() + } + p.SetState(6403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6399) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6400) + p.SortItem() + } + + p.SetState(6405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + } + { + p.SetState(6410) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6413) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 916, p.GetParserRuleContext()) == 1 { + { + p.SetState(6411) + p.Match(DorisParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6412) + p.WindowSpec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionIdentifierContext is an interface to support dynamic dispatch. +type IFunctionIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDbName returns the dbName rule contexts. + GetDbName() IIdentifierContext + + // SetDbName sets the dbName rule contexts. + SetDbName(IIdentifierContext) + + // Getter signatures + FunctionNameIdentifier() IFunctionNameIdentifierContext + DOT() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsFunctionIdentifierContext differentiates from other interfaces. + IsFunctionIdentifierContext() +} + +type FunctionIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dbName IIdentifierContext +} + +func NewEmptyFunctionIdentifierContext() *FunctionIdentifierContext { + var p = new(FunctionIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionIdentifier + return p +} + +func InitEmptyFunctionIdentifierContext(p *FunctionIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionIdentifier +} + +func (*FunctionIdentifierContext) IsFunctionIdentifierContext() {} + +func NewFunctionIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionIdentifierContext { + var p = new(FunctionIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_functionIdentifier + + return p +} + +func (s *FunctionIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionIdentifierContext) GetDbName() IIdentifierContext { return s.dbName } + +func (s *FunctionIdentifierContext) SetDbName(v IIdentifierContext) { s.dbName = v } + +func (s *FunctionIdentifierContext) FunctionNameIdentifier() IFunctionNameIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionNameIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionNameIdentifierContext) +} + +func (s *FunctionIdentifierContext) DOT() antlr.TerminalNode { + return s.GetToken(DorisParserDOT, 0) +} + +func (s *FunctionIdentifierContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *FunctionIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFunctionIdentifier(s) + } +} + +func (s *FunctionIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFunctionIdentifier(s) + } +} + +func (s *FunctionIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFunctionIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FunctionIdentifier() (localctx IFunctionIdentifierContext) { + localctx = NewFunctionIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, DorisParserRULE_functionIdentifier) + p.EnterOuterAlt(localctx, 1) + p.SetState(6418) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 917, p.GetParserRuleContext()) == 1 { + { + p.SetState(6415) + + var _x = p.Identifier() + + localctx.(*FunctionIdentifierContext).dbName = _x + } + { + p.SetState(6416) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6420) + p.FunctionNameIdentifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionNameIdentifierContext is an interface to support dynamic dispatch. +type IFunctionNameIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + ADD() antlr.TerminalNode + CONNECTION_ID() antlr.TerminalNode + CURRENT_CATALOG() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + IF() antlr.TerminalNode + LEFT() antlr.TerminalNode + LIKE() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + REGEXP() antlr.TerminalNode + RIGHT() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + TRIM() antlr.TerminalNode + USER() antlr.TerminalNode + + // IsFunctionNameIdentifierContext differentiates from other interfaces. + IsFunctionNameIdentifierContext() +} + +type FunctionNameIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionNameIdentifierContext() *FunctionNameIdentifierContext { + var p = new(FunctionNameIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionNameIdentifier + return p +} + +func InitEmptyFunctionNameIdentifierContext(p *FunctionNameIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_functionNameIdentifier +} + +func (*FunctionNameIdentifierContext) IsFunctionNameIdentifierContext() {} + +func NewFunctionNameIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameIdentifierContext { + var p = new(FunctionNameIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_functionNameIdentifier + + return p +} + +func (s *FunctionNameIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionNameIdentifierContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *FunctionNameIdentifierContext) ADD() antlr.TerminalNode { + return s.GetToken(DorisParserADD, 0) +} + +func (s *FunctionNameIdentifierContext) CONNECTION_ID() antlr.TerminalNode { + return s.GetToken(DorisParserCONNECTION_ID, 0) +} + +func (s *FunctionNameIdentifierContext) CURRENT_CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_CATALOG, 0) +} + +func (s *FunctionNameIdentifierContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_USER, 0) +} + +func (s *FunctionNameIdentifierContext) DATABASE() antlr.TerminalNode { + return s.GetToken(DorisParserDATABASE, 0) +} + +func (s *FunctionNameIdentifierContext) IF() antlr.TerminalNode { + return s.GetToken(DorisParserIF, 0) +} + +func (s *FunctionNameIdentifierContext) LEFT() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT, 0) +} + +func (s *FunctionNameIdentifierContext) LIKE() antlr.TerminalNode { + return s.GetToken(DorisParserLIKE, 0) +} + +func (s *FunctionNameIdentifierContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD, 0) +} + +func (s *FunctionNameIdentifierContext) REGEXP() antlr.TerminalNode { + return s.GetToken(DorisParserREGEXP, 0) +} + +func (s *FunctionNameIdentifierContext) RIGHT() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT, 0) +} + +func (s *FunctionNameIdentifierContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEMA, 0) +} + +func (s *FunctionNameIdentifierContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(DorisParserSESSION_USER, 0) +} + +func (s *FunctionNameIdentifierContext) TRIM() antlr.TerminalNode { + return s.GetToken(DorisParserTRIM, 0) +} + +func (s *FunctionNameIdentifierContext) USER() antlr.TerminalNode { + return s.GetToken(DorisParserUSER, 0) +} + +func (s *FunctionNameIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionNameIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionNameIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFunctionNameIdentifier(s) + } +} + +func (s *FunctionNameIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFunctionNameIdentifier(s) + } +} + +func (s *FunctionNameIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFunctionNameIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FunctionNameIdentifier() (localctx IFunctionNameIdentifierContext) { + localctx = NewFunctionNameIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, DorisParserRULE_functionNameIdentifier) + p.SetState(6438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 918, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6422) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6423) + p.Match(DorisParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6424) + p.Match(DorisParserCONNECTION_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6425) + p.Match(DorisParserCURRENT_CATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6426) + p.Match(DorisParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6427) + p.Match(DorisParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6428) + p.Match(DorisParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6429) + p.Match(DorisParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6430) + p.Match(DorisParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6431) + p.Match(DorisParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6432) + p.Match(DorisParserREGEXP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(6433) + p.Match(DorisParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(6434) + p.Match(DorisParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(6435) + p.Match(DorisParserSESSION_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(6436) + p.Match(DorisParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(6437) + p.Match(DorisParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowSpecContext is an interface to support dynamic dispatch. +type IWindowSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + PartitionClause() IPartitionClauseContext + SortClause() ISortClauseContext + WindowFrame() IWindowFrameContext + + // IsWindowSpecContext differentiates from other interfaces. + IsWindowSpecContext() +} + +type WindowSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowSpecContext() *WindowSpecContext { + var p = new(WindowSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_windowSpec + return p +} + +func InitEmptyWindowSpecContext(p *WindowSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_windowSpec +} + +func (*WindowSpecContext) IsWindowSpecContext() {} + +func NewWindowSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowSpecContext { + var p = new(WindowSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_windowSpec + + return p +} + +func (s *WindowSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *WindowSpecContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *WindowSpecContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *WindowSpecContext) PartitionClause() IPartitionClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionClauseContext) +} + +func (s *WindowSpecContext) SortClause() ISortClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortClauseContext) +} + +func (s *WindowSpecContext) WindowFrame() IWindowFrameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowFrameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowFrameContext) +} + +func (s *WindowSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WindowSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WindowSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWindowSpec(s) + } +} + +func (s *WindowSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWindowSpec(s) + } +} + +func (s *WindowSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWindowSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WindowSpec() (localctx IWindowSpecContext) { + localctx = NewWindowSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, DorisParserRULE_windowSpec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6440) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserPARTITION { + { + p.SetState(6441) + p.PartitionClause() + } + + } + p.SetState(6445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserORDER { + { + p.SetState(6444) + p.SortClause() + } + + } + p.SetState(6448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserRANGE || _la == DorisParserROWS { + { + p.SetState(6447) + p.WindowFrame() + } + + } + { + p.SetState(6450) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowFrameContext is an interface to support dynamic dispatch. +type IWindowFrameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStart_ returns the start_ rule contexts. + GetStart_() IFrameBoundaryContext + + // GetEnd returns the end rule contexts. + GetEnd() IFrameBoundaryContext + + // SetStart_ sets the start_ rule contexts. + SetStart_(IFrameBoundaryContext) + + // SetEnd sets the end rule contexts. + SetEnd(IFrameBoundaryContext) + + // Getter signatures + FrameUnits() IFrameUnitsContext + AllFrameBoundary() []IFrameBoundaryContext + FrameBoundary(i int) IFrameBoundaryContext + BETWEEN() antlr.TerminalNode + AND() antlr.TerminalNode + + // IsWindowFrameContext differentiates from other interfaces. + IsWindowFrameContext() +} + +type WindowFrameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + start_ IFrameBoundaryContext + end IFrameBoundaryContext +} + +func NewEmptyWindowFrameContext() *WindowFrameContext { + var p = new(WindowFrameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_windowFrame + return p +} + +func InitEmptyWindowFrameContext(p *WindowFrameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_windowFrame +} + +func (*WindowFrameContext) IsWindowFrameContext() {} + +func NewWindowFrameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowFrameContext { + var p = new(WindowFrameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_windowFrame + + return p +} + +func (s *WindowFrameContext) GetParser() antlr.Parser { return s.parser } + +func (s *WindowFrameContext) GetStart_() IFrameBoundaryContext { return s.start_ } + +func (s *WindowFrameContext) GetEnd() IFrameBoundaryContext { return s.end } + +func (s *WindowFrameContext) SetStart_(v IFrameBoundaryContext) { s.start_ = v } + +func (s *WindowFrameContext) SetEnd(v IFrameBoundaryContext) { s.end = v } + +func (s *WindowFrameContext) FrameUnits() IFrameUnitsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameUnitsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrameUnitsContext) +} + +func (s *WindowFrameContext) AllFrameBoundary() []IFrameBoundaryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFrameBoundaryContext); ok { + len++ + } + } + + tst := make([]IFrameBoundaryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFrameBoundaryContext); ok { + tst[i] = t.(IFrameBoundaryContext) + i++ + } + } + + return tst +} + +func (s *WindowFrameContext) FrameBoundary(i int) IFrameBoundaryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrameBoundaryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFrameBoundaryContext) +} + +func (s *WindowFrameContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(DorisParserBETWEEN, 0) +} + +func (s *WindowFrameContext) AND() antlr.TerminalNode { + return s.GetToken(DorisParserAND, 0) +} + +func (s *WindowFrameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WindowFrameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WindowFrameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWindowFrame(s) + } +} + +func (s *WindowFrameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWindowFrame(s) + } +} + +func (s *WindowFrameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWindowFrame(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WindowFrame() (localctx IWindowFrameContext) { + localctx = NewWindowFrameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, DorisParserRULE_windowFrame) + p.SetState(6461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 922, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6452) + p.FrameUnits() + } + { + p.SetState(6453) + + var _x = p.FrameBoundary() + + localctx.(*WindowFrameContext).start_ = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6455) + p.FrameUnits() + } + { + p.SetState(6456) + p.Match(DorisParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6457) + + var _x = p.FrameBoundary() + + localctx.(*WindowFrameContext).start_ = _x + } + { + p.SetState(6458) + p.Match(DorisParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6459) + + var _x = p.FrameBoundary() + + localctx.(*WindowFrameContext).end = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameUnitsContext is an interface to support dynamic dispatch. +type IFrameUnitsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWS() antlr.TerminalNode + RANGE() antlr.TerminalNode + + // IsFrameUnitsContext differentiates from other interfaces. + IsFrameUnitsContext() +} + +type FrameUnitsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrameUnitsContext() *FrameUnitsContext { + var p = new(FrameUnitsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_frameUnits + return p +} + +func InitEmptyFrameUnitsContext(p *FrameUnitsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_frameUnits +} + +func (*FrameUnitsContext) IsFrameUnitsContext() {} + +func NewFrameUnitsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameUnitsContext { + var p = new(FrameUnitsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_frameUnits + + return p +} + +func (s *FrameUnitsContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameUnitsContext) ROWS() antlr.TerminalNode { + return s.GetToken(DorisParserROWS, 0) +} + +func (s *FrameUnitsContext) RANGE() antlr.TerminalNode { + return s.GetToken(DorisParserRANGE, 0) +} + +func (s *FrameUnitsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameUnitsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameUnitsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFrameUnits(s) + } +} + +func (s *FrameUnitsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFrameUnits(s) + } +} + +func (s *FrameUnitsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFrameUnits(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FrameUnits() (localctx IFrameUnitsContext) { + localctx = NewFrameUnitsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, DorisParserRULE_frameUnits) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6463) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserRANGE || _la == DorisParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrameBoundaryContext is an interface to support dynamic dispatch. +type IFrameBoundaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBoundType returns the boundType token. + GetBoundType() antlr.Token + + // SetBoundType sets the boundType token. + SetBoundType(antlr.Token) + + // Getter signatures + UNBOUNDED() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + ROW() antlr.TerminalNode + CURRENT() antlr.TerminalNode + Expression() IExpressionContext + + // IsFrameBoundaryContext differentiates from other interfaces. + IsFrameBoundaryContext() +} + +type FrameBoundaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + boundType antlr.Token +} + +func NewEmptyFrameBoundaryContext() *FrameBoundaryContext { + var p = new(FrameBoundaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_frameBoundary + return p +} + +func InitEmptyFrameBoundaryContext(p *FrameBoundaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_frameBoundary +} + +func (*FrameBoundaryContext) IsFrameBoundaryContext() {} + +func NewFrameBoundaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrameBoundaryContext { + var p = new(FrameBoundaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_frameBoundary + + return p +} + +func (s *FrameBoundaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrameBoundaryContext) GetBoundType() antlr.Token { return s.boundType } + +func (s *FrameBoundaryContext) SetBoundType(v antlr.Token) { s.boundType = v } + +func (s *FrameBoundaryContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(DorisParserUNBOUNDED, 0) +} + +func (s *FrameBoundaryContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(DorisParserPRECEDING, 0) +} + +func (s *FrameBoundaryContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(DorisParserFOLLOWING, 0) +} + +func (s *FrameBoundaryContext) ROW() antlr.TerminalNode { + return s.GetToken(DorisParserROW, 0) +} + +func (s *FrameBoundaryContext) CURRENT() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT, 0) +} + +func (s *FrameBoundaryContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FrameBoundaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrameBoundaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrameBoundaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterFrameBoundary(s) + } +} + +func (s *FrameBoundaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitFrameBoundary(s) + } +} + +func (s *FrameBoundaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitFrameBoundary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) FrameBoundary() (localctx IFrameBoundaryContext) { + localctx = NewFrameBoundaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, DorisParserRULE_frameBoundary) + var _la int + + p.SetState(6472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserUNBOUNDED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6465) + p.Match(DorisParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6466) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FrameBoundaryContext).boundType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFOLLOWING || _la == DorisParserPRECEDING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FrameBoundaryContext).boundType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case DorisParserCURRENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6467) + + var _m = p.Match(DorisParserCURRENT) + + localctx.(*FrameBoundaryContext).boundType = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6468) + p.Match(DorisParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserLEFT_PAREN, DorisParserLEFT_BRACKET, DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserADD, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBINARY, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCASE, DorisParserCAST, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATABASE, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXISTS, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserEXTRACT, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFALSE, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIF, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINTERVAL, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserKEY, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLEFT, DorisParserLESS, DorisParserLEVEL, DorisParserLIKE, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNOT, DorisParserNULL, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLACEHOLDER, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREGEXP, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRIGHT, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRIM, DorisParserTRUE, DorisParserTRUNCATE, DorisParserTRY_CAST, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserPLUS, DorisParserSUBTRACT, DorisParserASTERISK, DorisParserTILDE, DorisParserLOGICALNOT, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserATSIGN, DorisParserDOUBLEATSIGN, DorisParserSTRING_LITERAL, DorisParserVARBINARY_LITERAL, DorisParserINTEGER_VALUE, DorisParserEXPONENT_VALUE, DorisParserDECIMAL_VALUE, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6469) + p.Expression() + } + { + p.SetState(6470) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*FrameBoundaryContext).boundType = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFOLLOWING || _la == DorisParserPRECEDING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*FrameBoundaryContext).boundType = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualifiedNameContext is an interface to support dynamic dispatch. +type IQualifiedNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsQualifiedNameContext differentiates from other interfaces. + IsQualifiedNameContext() +} + +type QualifiedNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualifiedNameContext() *QualifiedNameContext { + var p = new(QualifiedNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_qualifiedName + return p +} + +func InitEmptyQualifiedNameContext(p *QualifiedNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_qualifiedName +} + +func (*QualifiedNameContext) IsQualifiedNameContext() {} + +func NewQualifiedNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QualifiedNameContext { + var p = new(QualifiedNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_qualifiedName + + return p +} + +func (s *QualifiedNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *QualifiedNameContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *QualifiedNameContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *QualifiedNameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(DorisParserDOT) +} + +func (s *QualifiedNameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(DorisParserDOT, i) +} + +func (s *QualifiedNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QualifiedNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QualifiedNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQualifiedName(s) + } +} + +func (s *QualifiedNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQualifiedName(s) + } +} + +func (s *QualifiedNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQualifiedName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QualifiedName() (localctx IQualifiedNameContext) { + localctx = NewQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, DorisParserRULE_qualifiedName) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6474) + p.Identifier() + } + p.SetState(6479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 924, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6475) + p.Match(DorisParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6476) + p.Identifier() + } + + } + p.SetState(6481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 924, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpecifiedPartitionContext is an interface to support dynamic dispatch. +type ISpecifiedPartitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Identifier() IIdentifierContext + IdentifierList() IIdentifierListContext + TEMPORARY() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + + // IsSpecifiedPartitionContext differentiates from other interfaces. + IsSpecifiedPartitionContext() +} + +type SpecifiedPartitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpecifiedPartitionContext() *SpecifiedPartitionContext { + var p = new(SpecifiedPartitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_specifiedPartition + return p +} + +func InitEmptySpecifiedPartitionContext(p *SpecifiedPartitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_specifiedPartition +} + +func (*SpecifiedPartitionContext) IsSpecifiedPartitionContext() {} + +func NewSpecifiedPartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecifiedPartitionContext { + var p = new(SpecifiedPartitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_specifiedPartition + + return p +} + +func (s *SpecifiedPartitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SpecifiedPartitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITION, 0) +} + +func (s *SpecifiedPartitionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *SpecifiedPartitionContext) IdentifierList() IIdentifierListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierListContext) +} + +func (s *SpecifiedPartitionContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *SpecifiedPartitionContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITIONS, 0) +} + +func (s *SpecifiedPartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SpecifiedPartitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SpecifiedPartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSpecifiedPartition(s) + } +} + +func (s *SpecifiedPartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSpecifiedPartition(s) + } +} + +func (s *SpecifiedPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSpecifiedPartition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SpecifiedPartition() (localctx ISpecifiedPartitionContext) { + localctx = NewSpecifiedPartitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, DorisParserRULE_specifiedPartition) + var _la int + + p.SetState(6495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 928, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(6483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(6482) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6485) + p.Match(DorisParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserIDENTIFIER, DorisParserBACKQUOTED_IDENTIFIER, DorisParserGET_FORMAT: + { + p.SetState(6486) + p.Identifier() + } + + case DorisParserLEFT_PAREN: + { + p.SetState(6487) + p.IdentifierList() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(6491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserTEMPORARY { + { + p.SetState(6490) + p.Match(DorisParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6493) + p.Match(DorisParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6494) + p.IdentifierList() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantContext is an interface to support dynamic dispatch. +type IConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsConstantContext differentiates from other interfaces. + IsConstantContext() +} + +type ConstantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstantContext() *ConstantContext { + var p = new(ConstantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constant + return p +} + +func InitEmptyConstantContext(p *ConstantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_constant +} + +func (*ConstantContext) IsConstantContext() {} + +func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext { + var p = new(ConstantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_constant + + return p +} + +func (s *ConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantContext) CopyAll(ctx *ConstantContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type StructLiteralContext struct { + ConstantContext + _constant IConstantContext + items []IConstantContext +} + +func NewStructLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StructLiteralContext { + var p = new(StructLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *StructLiteralContext) Get_constant() IConstantContext { return s._constant } + +func (s *StructLiteralContext) Set_constant(v IConstantContext) { s._constant = v } + +func (s *StructLiteralContext) GetItems() []IConstantContext { return s.items } + +func (s *StructLiteralContext) SetItems(v []IConstantContext) { s.items = v } + +func (s *StructLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StructLiteralContext) LEFT_BRACE() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACE, 0) +} + +func (s *StructLiteralContext) RIGHT_BRACE() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACE, 0) +} + +func (s *StructLiteralContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *StructLiteralContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *StructLiteralContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *StructLiteralContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *StructLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStructLiteral(s) + } +} + +func (s *StructLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStructLiteral(s) + } +} + +func (s *StructLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStructLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type NullLiteralContext struct { + ConstantContext +} + +func NewNullLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullLiteralContext { + var p = new(NullLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *NullLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NullLiteralContext) NULL() antlr.TerminalNode { + return s.GetToken(DorisParserNULL, 0) +} + +func (s *NullLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterNullLiteral(s) + } +} + +func (s *NullLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitNullLiteral(s) + } +} + +func (s *NullLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitNullLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type StringLiteralContext struct { + ConstantContext +} + +func NewStringLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringLiteralContext { + var p = new(StringLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringLiteralContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *StringLiteralContext) BINARY() antlr.TerminalNode { + return s.GetToken(DorisParserBINARY, 0) +} + +func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterStringLiteral(s) + } +} + +func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitStringLiteral(s) + } +} + +func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitStringLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type TypeConstructorContext struct { + ConstantContext + type_ antlr.Token +} + +func NewTypeConstructorContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TypeConstructorContext { + var p = new(TypeConstructorContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *TypeConstructorContext) GetType_() antlr.Token { return s.type_ } + +func (s *TypeConstructorContext) SetType_(v antlr.Token) { s.type_ = v } + +func (s *TypeConstructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeConstructorContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *TypeConstructorContext) DATE() antlr.TerminalNode { + return s.GetToken(DorisParserDATE, 0) +} + +func (s *TypeConstructorContext) DATEV1() antlr.TerminalNode { + return s.GetToken(DorisParserDATEV1, 0) +} + +func (s *TypeConstructorContext) DATEV2() antlr.TerminalNode { + return s.GetToken(DorisParserDATEV2, 0) +} + +func (s *TypeConstructorContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserTIMESTAMP, 0) +} + +func (s *TypeConstructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTypeConstructor(s) + } +} + +func (s *TypeConstructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTypeConstructor(s) + } +} + +func (s *TypeConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTypeConstructor(s) + + default: + return t.VisitChildren(s) + } +} + +type VarbinaryLiteralContext struct { + ConstantContext +} + +func NewVarbinaryLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VarbinaryLiteralContext { + var p = new(VarbinaryLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *VarbinaryLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VarbinaryLiteralContext) VARBINARY_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserVARBINARY_LITERAL, 0) +} + +func (s *VarbinaryLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterVarbinaryLiteral(s) + } +} + +func (s *VarbinaryLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitVarbinaryLiteral(s) + } +} + +func (s *VarbinaryLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitVarbinaryLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type ArrayLiteralContext struct { + ConstantContext + _constant IConstantContext + items []IConstantContext +} + +func NewArrayLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ArrayLiteralContext { + var p = new(ArrayLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *ArrayLiteralContext) Get_constant() IConstantContext { return s._constant } + +func (s *ArrayLiteralContext) Set_constant(v IConstantContext) { s._constant = v } + +func (s *ArrayLiteralContext) GetItems() []IConstantContext { return s.items } + +func (s *ArrayLiteralContext) SetItems(v []IConstantContext) { s.items = v } + +func (s *ArrayLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ArrayLiteralContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACKET, 0) +} + +func (s *ArrayLiteralContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACKET, 0) +} + +func (s *ArrayLiteralContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ArrayLiteralContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ArrayLiteralContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *ArrayLiteralContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *ArrayLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterArrayLiteral(s) + } +} + +func (s *ArrayLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitArrayLiteral(s) + } +} + +func (s *ArrayLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitArrayLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type PlaceholderContext struct { + ConstantContext +} + +func NewPlaceholderContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PlaceholderContext { + var p = new(PlaceholderContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *PlaceholderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlaceholderContext) PLACEHOLDER() antlr.TerminalNode { + return s.GetToken(DorisParserPLACEHOLDER, 0) +} + +func (s *PlaceholderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPlaceholder(s) + } +} + +func (s *PlaceholderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPlaceholder(s) + } +} + +func (s *PlaceholderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPlaceholder(s) + + default: + return t.VisitChildren(s) + } +} + +type MapLiteralContext struct { + ConstantContext + _constant IConstantContext + items []IConstantContext +} + +func NewMapLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MapLiteralContext { + var p = new(MapLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *MapLiteralContext) Get_constant() IConstantContext { return s._constant } + +func (s *MapLiteralContext) Set_constant(v IConstantContext) { s._constant = v } + +func (s *MapLiteralContext) GetItems() []IConstantContext { return s.items } + +func (s *MapLiteralContext) SetItems(v []IConstantContext) { s.items = v } + +func (s *MapLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MapLiteralContext) LEFT_BRACE() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACE, 0) +} + +func (s *MapLiteralContext) RIGHT_BRACE() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACE, 0) +} + +func (s *MapLiteralContext) AllCOLON() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOLON) +} + +func (s *MapLiteralContext) COLON(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOLON, i) +} + +func (s *MapLiteralContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *MapLiteralContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *MapLiteralContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *MapLiteralContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *MapLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterMapLiteral(s) + } +} + +func (s *MapLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitMapLiteral(s) + } +} + +func (s *MapLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitMapLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type NumericLiteralContext struct { + ConstantContext +} + +func NewNumericLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NumericLiteralContext { + var p = new(NumericLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *NumericLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumericLiteralContext) Number() INumberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumberContext) +} + +func (s *NumericLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterNumericLiteral(s) + } +} + +func (s *NumericLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitNumericLiteral(s) + } +} + +func (s *NumericLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitNumericLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type BooleanLiteralContext struct { + ConstantContext +} + +func NewBooleanLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BooleanLiteralContext { + var p = new(BooleanLiteralContext) + + InitEmptyConstantContext(&p.ConstantContext) + p.parser = parser + p.CopyAll(ctx.(*ConstantContext)) + + return p +} + +func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BooleanLiteralContext) BooleanValue() IBooleanValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanValueContext) +} + +func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBooleanLiteral(s) + } +} + +func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBooleanLiteral(s) + } +} + +func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBooleanLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Constant() (localctx IConstantContext) { + localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, DorisParserRULE_constant) + var _la int + + p.SetState(6549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 935, p.GetParserRuleContext()) { + case 1: + localctx = NewNullLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6497) + p.Match(DorisParserNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewTypeConstructorContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6498) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TypeConstructorContext).type_ = _lt + + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-117)) & ^0x3f) == 0 && ((int64(1)<<(_la-117))&41) != 0) || _la == DorisParserTIMESTAMP) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TypeConstructorContext).type_ = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6499) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewNumericLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6500) + p.Number() + } + + case 4: + localctx = NewBooleanLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6501) + p.BooleanValue() + } + + case 5: + localctx = NewStringLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + p.SetState(6503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserBINARY { + { + p.SetState(6502) + p.Match(DorisParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6505) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewVarbinaryLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6506) + p.Match(DorisParserVARBINARY_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + localctx = NewArrayLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6507) + p.Match(DorisParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&17592186045056) != 0) || ((int64((_la-117)) & ^0x3f) == 0 && ((int64(1)<<(_la-117))&41) != 0) || _la == DorisParserFALSE || _la == DorisParserNULL || _la == DorisParserPLACEHOLDER || _la == DorisParserTIMESTAMP || _la == DorisParserTRUE || ((int64((_la-551)) & ^0x3f) == 0 && ((int64(1)<<(_la-551))&118226945) != 0) { + { + p.SetState(6508) + + var _x = p.Constant() + + localctx.(*ArrayLiteralContext)._constant = _x + } + localctx.(*ArrayLiteralContext).items = append(localctx.(*ArrayLiteralContext).items, localctx.(*ArrayLiteralContext)._constant) + + } + p.SetState(6515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6511) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6512) + + var _x = p.Constant() + + localctx.(*ArrayLiteralContext)._constant = _x + } + localctx.(*ArrayLiteralContext).items = append(localctx.(*ArrayLiteralContext).items, localctx.(*ArrayLiteralContext)._constant) + + p.SetState(6517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6518) + p.Match(DorisParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewMapLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6519) + p.Match(DorisParserLEFT_BRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&17592186045056) != 0) || ((int64((_la-117)) & ^0x3f) == 0 && ((int64(1)<<(_la-117))&41) != 0) || _la == DorisParserFALSE || _la == DorisParserNULL || _la == DorisParserPLACEHOLDER || _la == DorisParserTIMESTAMP || _la == DorisParserTRUE || ((int64((_la-551)) & ^0x3f) == 0 && ((int64(1)<<(_la-551))&118226945) != 0) { + { + p.SetState(6520) + + var _x = p.Constant() + + localctx.(*MapLiteralContext)._constant = _x + } + localctx.(*MapLiteralContext).items = append(localctx.(*MapLiteralContext).items, localctx.(*MapLiteralContext)._constant) + { + p.SetState(6521) + p.Match(DorisParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6522) + + var _x = p.Constant() + + localctx.(*MapLiteralContext)._constant = _x + } + localctx.(*MapLiteralContext).items = append(localctx.(*MapLiteralContext).items, localctx.(*MapLiteralContext)._constant) + + } + p.SetState(6533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6526) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6527) + + var _x = p.Constant() + + localctx.(*MapLiteralContext)._constant = _x + } + localctx.(*MapLiteralContext).items = append(localctx.(*MapLiteralContext).items, localctx.(*MapLiteralContext)._constant) + { + p.SetState(6528) + p.Match(DorisParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6529) + + var _x = p.Constant() + + localctx.(*MapLiteralContext)._constant = _x + } + localctx.(*MapLiteralContext).items = append(localctx.(*MapLiteralContext).items, localctx.(*MapLiteralContext)._constant) + + p.SetState(6535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6536) + p.Match(DorisParserRIGHT_BRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewStructLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6537) + p.Match(DorisParserLEFT_BRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6538) + + var _x = p.Constant() + + localctx.(*StructLiteralContext)._constant = _x + } + localctx.(*StructLiteralContext).items = append(localctx.(*StructLiteralContext).items, localctx.(*StructLiteralContext)._constant) + p.SetState(6543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6539) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6540) + + var _x = p.Constant() + + localctx.(*StructLiteralContext)._constant = _x + } + localctx.(*StructLiteralContext).items = append(localctx.(*StructLiteralContext).items, localctx.(*StructLiteralContext)._constant) + + p.SetState(6545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6546) + p.Match(DorisParserRIGHT_BRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewPlaceholderContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6548) + p.Match(DorisParserPLACEHOLDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComparisonOperatorContext is an interface to support dynamic dispatch. +type IComparisonOperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQ() antlr.TerminalNode + NEQ() antlr.TerminalNode + LT() antlr.TerminalNode + LTE() antlr.TerminalNode + GT() antlr.TerminalNode + GTE() antlr.TerminalNode + NSEQ() antlr.TerminalNode + + // IsComparisonOperatorContext differentiates from other interfaces. + IsComparisonOperatorContext() +} + +type ComparisonOperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext { + var p = new(ComparisonOperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_comparisonOperator + return p +} + +func InitEmptyComparisonOperatorContext(p *ComparisonOperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_comparisonOperator +} + +func (*ComparisonOperatorContext) IsComparisonOperatorContext() {} + +func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext { + var p = new(ComparisonOperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_comparisonOperator + + return p +} + +func (s *ComparisonOperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *ComparisonOperatorContext) EQ() antlr.TerminalNode { + return s.GetToken(DorisParserEQ, 0) +} + +func (s *ComparisonOperatorContext) NEQ() antlr.TerminalNode { + return s.GetToken(DorisParserNEQ, 0) +} + +func (s *ComparisonOperatorContext) LT() antlr.TerminalNode { + return s.GetToken(DorisParserLT, 0) +} + +func (s *ComparisonOperatorContext) LTE() antlr.TerminalNode { + return s.GetToken(DorisParserLTE, 0) +} + +func (s *ComparisonOperatorContext) GT() antlr.TerminalNode { + return s.GetToken(DorisParserGT, 0) +} + +func (s *ComparisonOperatorContext) GTE() antlr.TerminalNode { + return s.GetToken(DorisParserGTE, 0) +} + +func (s *ComparisonOperatorContext) NSEQ() antlr.TerminalNode { + return s.GetToken(DorisParserNSEQ, 0) +} + +func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterComparisonOperator(s) + } +} + +func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitComparisonOperator(s) + } +} + +func (s *ComparisonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitComparisonOperator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ComparisonOperator() (localctx IComparisonOperatorContext) { + localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, DorisParserRULE_comparisonOperator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6551) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-543)) & ^0x3f) == 0 && ((int64(1)<<(_la-543))&127) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBooleanValueContext is an interface to support dynamic dispatch. +type IBooleanValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + + // IsBooleanValueContext differentiates from other interfaces. + IsBooleanValueContext() +} + +type BooleanValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBooleanValueContext() *BooleanValueContext { + var p = new(BooleanValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_booleanValue + return p +} + +func InitEmptyBooleanValueContext(p *BooleanValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_booleanValue +} + +func (*BooleanValueContext) IsBooleanValueContext() {} + +func NewBooleanValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanValueContext { + var p = new(BooleanValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_booleanValue + + return p +} + +func (s *BooleanValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *BooleanValueContext) TRUE() antlr.TerminalNode { + return s.GetToken(DorisParserTRUE, 0) +} + +func (s *BooleanValueContext) FALSE() antlr.TerminalNode { + return s.GetToken(DorisParserFALSE, 0) +} + +func (s *BooleanValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BooleanValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BooleanValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterBooleanValue(s) + } +} + +func (s *BooleanValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitBooleanValue(s) + } +} + +func (s *BooleanValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitBooleanValue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) BooleanValue() (localctx IBooleanValueContext) { + localctx = NewBooleanValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, DorisParserRULE_booleanValue) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6553) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserFALSE || _la == DorisParserTRUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhenClauseContext is an interface to support dynamic dispatch. +type IWhenClauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCondition returns the condition rule contexts. + GetCondition() IExpressionContext + + // GetResult returns the result rule contexts. + GetResult() IExpressionContext + + // SetCondition sets the condition rule contexts. + SetCondition(IExpressionContext) + + // SetResult sets the result rule contexts. + SetResult(IExpressionContext) + + // Getter signatures + WHEN() antlr.TerminalNode + THEN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + + // IsWhenClauseContext differentiates from other interfaces. + IsWhenClauseContext() +} + +type WhenClauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + condition IExpressionContext + result IExpressionContext +} + +func NewEmptyWhenClauseContext() *WhenClauseContext { + var p = new(WhenClauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_whenClause + return p +} + +func InitEmptyWhenClauseContext(p *WhenClauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_whenClause +} + +func (*WhenClauseContext) IsWhenClauseContext() {} + +func NewWhenClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhenClauseContext { + var p = new(WhenClauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_whenClause + + return p +} + +func (s *WhenClauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhenClauseContext) GetCondition() IExpressionContext { return s.condition } + +func (s *WhenClauseContext) GetResult() IExpressionContext { return s.result } + +func (s *WhenClauseContext) SetCondition(v IExpressionContext) { s.condition = v } + +func (s *WhenClauseContext) SetResult(v IExpressionContext) { s.result = v } + +func (s *WhenClauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(DorisParserWHEN, 0) +} + +func (s *WhenClauseContext) THEN() antlr.TerminalNode { + return s.GetToken(DorisParserTHEN, 0) +} + +func (s *WhenClauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *WhenClauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *WhenClauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhenClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhenClauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterWhenClause(s) + } +} + +func (s *WhenClauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitWhenClause(s) + } +} + +func (s *WhenClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitWhenClause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) WhenClause() (localctx IWhenClauseContext) { + localctx = NewWhenClauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, DorisParserRULE_whenClause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6555) + p.Match(DorisParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6556) + + var _x = p.Expression() + + localctx.(*WhenClauseContext).condition = _x + } + { + p.SetState(6557) + p.Match(DorisParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6558) + + var _x = p.Expression() + + localctx.(*WhenClauseContext).result = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIntervalContext is an interface to support dynamic dispatch. +type IIntervalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetValue returns the value rule contexts. + GetValue() IExpressionContext + + // GetUnit returns the unit rule contexts. + GetUnit() IUnitIdentifierContext + + // SetValue sets the value rule contexts. + SetValue(IExpressionContext) + + // SetUnit sets the unit rule contexts. + SetUnit(IUnitIdentifierContext) + + // Getter signatures + INTERVAL() antlr.TerminalNode + Expression() IExpressionContext + UnitIdentifier() IUnitIdentifierContext + + // IsIntervalContext differentiates from other interfaces. + IsIntervalContext() +} + +type IntervalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + value IExpressionContext + unit IUnitIdentifierContext +} + +func NewEmptyIntervalContext() *IntervalContext { + var p = new(IntervalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_interval + return p +} + +func InitEmptyIntervalContext(p *IntervalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_interval +} + +func (*IntervalContext) IsIntervalContext() {} + +func NewIntervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalContext { + var p = new(IntervalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_interval + + return p +} + +func (s *IntervalContext) GetParser() antlr.Parser { return s.parser } + +func (s *IntervalContext) GetValue() IExpressionContext { return s.value } + +func (s *IntervalContext) GetUnit() IUnitIdentifierContext { return s.unit } + +func (s *IntervalContext) SetValue(v IExpressionContext) { s.value = v } + +func (s *IntervalContext) SetUnit(v IUnitIdentifierContext) { s.unit = v } + +func (s *IntervalContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(DorisParserINTERVAL, 0) +} + +func (s *IntervalContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IntervalContext) UnitIdentifier() IUnitIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnitIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnitIdentifierContext) +} + +func (s *IntervalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IntervalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterInterval(s) + } +} + +func (s *IntervalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitInterval(s) + } +} + +func (s *IntervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitInterval(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Interval() (localctx IIntervalContext) { + localctx = NewIntervalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, DorisParserRULE_interval) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6560) + p.Match(DorisParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6561) + + var _x = p.Expression() + + localctx.(*IntervalContext).value = _x + } + { + p.SetState(6562) + + var _x = p.UnitIdentifier() + + localctx.(*IntervalContext).unit = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnitIdentifierContext is an interface to support dynamic dispatch. +type IUnitIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + YEAR() antlr.TerminalNode + QUARTER() antlr.TerminalNode + MONTH() antlr.TerminalNode + WEEK() antlr.TerminalNode + DAY() antlr.TerminalNode + HOUR() antlr.TerminalNode + MINUTE() antlr.TerminalNode + SECOND() antlr.TerminalNode + DAY_SECOND() antlr.TerminalNode + DAY_HOUR() antlr.TerminalNode + MINUTE_SECOND() antlr.TerminalNode + + // IsUnitIdentifierContext differentiates from other interfaces. + IsUnitIdentifierContext() +} + +type UnitIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnitIdentifierContext() *UnitIdentifierContext { + var p = new(UnitIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_unitIdentifier + return p +} + +func InitEmptyUnitIdentifierContext(p *UnitIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_unitIdentifier +} + +func (*UnitIdentifierContext) IsUnitIdentifierContext() {} + +func NewUnitIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnitIdentifierContext { + var p = new(UnitIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_unitIdentifier + + return p +} + +func (s *UnitIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnitIdentifierContext) YEAR() antlr.TerminalNode { + return s.GetToken(DorisParserYEAR, 0) +} + +func (s *UnitIdentifierContext) QUARTER() antlr.TerminalNode { + return s.GetToken(DorisParserQUARTER, 0) +} + +func (s *UnitIdentifierContext) MONTH() antlr.TerminalNode { + return s.GetToken(DorisParserMONTH, 0) +} + +func (s *UnitIdentifierContext) WEEK() antlr.TerminalNode { + return s.GetToken(DorisParserWEEK, 0) +} + +func (s *UnitIdentifierContext) DAY() antlr.TerminalNode { + return s.GetToken(DorisParserDAY, 0) +} + +func (s *UnitIdentifierContext) HOUR() antlr.TerminalNode { + return s.GetToken(DorisParserHOUR, 0) +} + +func (s *UnitIdentifierContext) MINUTE() antlr.TerminalNode { + return s.GetToken(DorisParserMINUTE, 0) +} + +func (s *UnitIdentifierContext) SECOND() antlr.TerminalNode { + return s.GetToken(DorisParserSECOND, 0) +} + +func (s *UnitIdentifierContext) DAY_SECOND() antlr.TerminalNode { + return s.GetToken(DorisParserDAY_SECOND, 0) +} + +func (s *UnitIdentifierContext) DAY_HOUR() antlr.TerminalNode { + return s.GetToken(DorisParserDAY_HOUR, 0) +} + +func (s *UnitIdentifierContext) MINUTE_SECOND() antlr.TerminalNode { + return s.GetToken(DorisParserMINUTE_SECOND, 0) +} + +func (s *UnitIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnitIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnitIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUnitIdentifier(s) + } +} + +func (s *UnitIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUnitIdentifier(s) + } +} + +func (s *UnitIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUnitIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) UnitIdentifier() (localctx IUnitIdentifierContext) { + localctx = NewUnitIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, DorisParserRULE_unitIdentifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6564) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-123)) & ^0x3f) == 0 && ((int64(1)<<(_la-123))&11) != 0) || _la == DorisParserHOUR || ((int64((_la-308)) & ^0x3f) == 0 && ((int64(1)<<(_la-308))&21) != 0) || _la == DorisParserQUARTER || _la == DorisParserSECOND || _la == DorisParserWEEK || _la == DorisParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeWithNullableContext is an interface to support dynamic dispatch. +type IDataTypeWithNullableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DataType() IDataTypeContext + NULL() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsDataTypeWithNullableContext differentiates from other interfaces. + IsDataTypeWithNullableContext() +} + +type DataTypeWithNullableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeWithNullableContext() *DataTypeWithNullableContext { + var p = new(DataTypeWithNullableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataTypeWithNullable + return p +} + +func InitEmptyDataTypeWithNullableContext(p *DataTypeWithNullableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataTypeWithNullable +} + +func (*DataTypeWithNullableContext) IsDataTypeWithNullableContext() {} + +func NewDataTypeWithNullableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeWithNullableContext { + var p = new(DataTypeWithNullableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dataTypeWithNullable + + return p +} + +func (s *DataTypeWithNullableContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeWithNullableContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *DataTypeWithNullableContext) NULL() antlr.TerminalNode { + return s.GetToken(DorisParserNULL, 0) +} + +func (s *DataTypeWithNullableContext) NOT() antlr.TerminalNode { + return s.GetToken(DorisParserNOT, 0) +} + +func (s *DataTypeWithNullableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeWithNullableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataTypeWithNullableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDataTypeWithNullable(s) + } +} + +func (s *DataTypeWithNullableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDataTypeWithNullable(s) + } +} + +func (s *DataTypeWithNullableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDataTypeWithNullable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DataTypeWithNullable() (localctx IDataTypeWithNullableContext) { + localctx = NewDataTypeWithNullableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, DorisParserRULE_dataTypeWithNullable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6566) + p.DataType() + } + p.SetState(6571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT || _la == DorisParserNULL { + p.SetState(6568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserNOT { + { + p.SetState(6567) + p.Match(DorisParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6570) + p.Match(DorisParserNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeContext is an interface to support dynamic dispatch. +type IDataTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsDataTypeContext differentiates from other interfaces. + IsDataTypeContext() +} + +type DataTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeContext() *DataTypeContext { + var p = new(DataTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataType + return p +} + +func InitEmptyDataTypeContext(p *DataTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_dataType +} + +func (*DataTypeContext) IsDataTypeContext() {} + +func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext { + var p = new(DataTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_dataType + + return p +} + +func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeContext) CopyAll(ctx *DataTypeContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *DataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type VariantPredefinedFieldsContext struct { + DataTypeContext + complex_ IVariantTypeDefinitionsContext +} + +func NewVariantPredefinedFieldsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VariantPredefinedFieldsContext { + var p = new(VariantPredefinedFieldsContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *VariantPredefinedFieldsContext) GetComplex_() IVariantTypeDefinitionsContext { + return s.complex_ +} + +func (s *VariantPredefinedFieldsContext) SetComplex_(v IVariantTypeDefinitionsContext) { + s.complex_ = v +} + +func (s *VariantPredefinedFieldsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariantPredefinedFieldsContext) VariantTypeDefinitions() IVariantTypeDefinitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariantTypeDefinitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariantTypeDefinitionsContext) +} + +func (s *VariantPredefinedFieldsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterVariantPredefinedFields(s) + } +} + +func (s *VariantPredefinedFieldsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitVariantPredefinedFields(s) + } +} + +func (s *VariantPredefinedFieldsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitVariantPredefinedFields(s) + + default: + return t.VisitChildren(s) + } +} + +type ComplexDataTypeContext struct { + DataTypeContext + complex_ antlr.Token +} + +func NewComplexDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ComplexDataTypeContext { + var p = new(ComplexDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *ComplexDataTypeContext) GetComplex_() antlr.Token { return s.complex_ } + +func (s *ComplexDataTypeContext) SetComplex_(v antlr.Token) { s.complex_ = v } + +func (s *ComplexDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComplexDataTypeContext) LT() antlr.TerminalNode { + return s.GetToken(DorisParserLT, 0) +} + +func (s *ComplexDataTypeContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *ComplexDataTypeContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ComplexDataTypeContext) GT() antlr.TerminalNode { + return s.GetToken(DorisParserGT, 0) +} + +func (s *ComplexDataTypeContext) ARRAY() antlr.TerminalNode { + return s.GetToken(DorisParserARRAY, 0) +} + +func (s *ComplexDataTypeContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *ComplexDataTypeContext) MAP() antlr.TerminalNode { + return s.GetToken(DorisParserMAP, 0) +} + +func (s *ComplexDataTypeContext) ComplexColTypeList() IComplexColTypeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComplexColTypeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComplexColTypeListContext) +} + +func (s *ComplexDataTypeContext) STRUCT() antlr.TerminalNode { + return s.GetToken(DorisParserSTRUCT, 0) +} + +func (s *ComplexDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterComplexDataType(s) + } +} + +func (s *ComplexDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitComplexDataType(s) + } +} + +func (s *ComplexDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitComplexDataType(s) + + default: + return t.VisitChildren(s) + } +} + +type AggStateDataTypeContext struct { + DataTypeContext + _dataTypeWithNullable IDataTypeWithNullableContext + dataTypes []IDataTypeWithNullableContext +} + +func NewAggStateDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AggStateDataTypeContext { + var p = new(AggStateDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *AggStateDataTypeContext) Get_dataTypeWithNullable() IDataTypeWithNullableContext { + return s._dataTypeWithNullable +} + +func (s *AggStateDataTypeContext) Set_dataTypeWithNullable(v IDataTypeWithNullableContext) { + s._dataTypeWithNullable = v +} + +func (s *AggStateDataTypeContext) GetDataTypes() []IDataTypeWithNullableContext { return s.dataTypes } + +func (s *AggStateDataTypeContext) SetDataTypes(v []IDataTypeWithNullableContext) { s.dataTypes = v } + +func (s *AggStateDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AggStateDataTypeContext) AGG_STATE() antlr.TerminalNode { + return s.GetToken(DorisParserAGG_STATE, 0) +} + +func (s *AggStateDataTypeContext) LT() antlr.TerminalNode { + return s.GetToken(DorisParserLT, 0) +} + +func (s *AggStateDataTypeContext) FunctionNameIdentifier() IFunctionNameIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionNameIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionNameIdentifierContext) +} + +func (s *AggStateDataTypeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *AggStateDataTypeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *AggStateDataTypeContext) GT() antlr.TerminalNode { + return s.GetToken(DorisParserGT, 0) +} + +func (s *AggStateDataTypeContext) AllDataTypeWithNullable() []IDataTypeWithNullableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeWithNullableContext); ok { + len++ + } + } + + tst := make([]IDataTypeWithNullableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeWithNullableContext); ok { + tst[i] = t.(IDataTypeWithNullableContext) + i++ + } + } + + return tst +} + +func (s *AggStateDataTypeContext) DataTypeWithNullable(i int) IDataTypeWithNullableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeWithNullableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeWithNullableContext) +} + +func (s *AggStateDataTypeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *AggStateDataTypeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *AggStateDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterAggStateDataType(s) + } +} + +func (s *AggStateDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitAggStateDataType(s) + } +} + +func (s *AggStateDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitAggStateDataType(s) + + default: + return t.VisitChildren(s) + } +} + +type PrimitiveDataTypeContext struct { + DataTypeContext +} + +func NewPrimitiveDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimitiveDataTypeContext { + var p = new(PrimitiveDataTypeContext) + + InitEmptyDataTypeContext(&p.DataTypeContext) + p.parser = parser + p.CopyAll(ctx.(*DataTypeContext)) + + return p +} + +func (s *PrimitiveDataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimitiveDataTypeContext) PrimitiveColType() IPrimitiveColTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimitiveColTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimitiveColTypeContext) +} + +func (s *PrimitiveDataTypeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *PrimitiveDataTypeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *PrimitiveDataTypeContext) AllINTEGER_VALUE() []antlr.TerminalNode { + return s.GetTokens(DorisParserINTEGER_VALUE) +} + +func (s *PrimitiveDataTypeContext) INTEGER_VALUE(i int) antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, i) +} + +func (s *PrimitiveDataTypeContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(DorisParserASTERISK, 0) +} + +func (s *PrimitiveDataTypeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *PrimitiveDataTypeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *PrimitiveDataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPrimitiveDataType(s) + } +} + +func (s *PrimitiveDataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPrimitiveDataType(s) + } +} + +func (s *PrimitiveDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPrimitiveDataType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) DataType() (localctx IDataTypeContext) { + localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, DorisParserRULE_dataType) + var _la int + + p.SetState(6619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 941, p.GetParserRuleContext()) { + case 1: + localctx = NewComplexDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6573) + + var _m = p.Match(DorisParserARRAY) + + localctx.(*ComplexDataTypeContext).complex_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6574) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6575) + p.DataType() + } + { + p.SetState(6576) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewComplexDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6578) + + var _m = p.Match(DorisParserMAP) + + localctx.(*ComplexDataTypeContext).complex_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6579) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6580) + p.DataType() + } + { + p.SetState(6581) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6582) + p.DataType() + } + { + p.SetState(6583) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewComplexDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6585) + + var _m = p.Match(DorisParserSTRUCT) + + localctx.(*ComplexDataTypeContext).complex_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6586) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6587) + p.ComplexColTypeList() + } + { + p.SetState(6588) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewVariantPredefinedFieldsContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6590) + + var _x = p.VariantTypeDefinitions() + + localctx.(*VariantPredefinedFieldsContext).complex_ = _x + } + + case 5: + localctx = NewAggStateDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6591) + p.Match(DorisParserAGG_STATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6592) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6593) + p.FunctionNameIdentifier() + } + { + p.SetState(6594) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6595) + + var _x = p.DataTypeWithNullable() + + localctx.(*AggStateDataTypeContext)._dataTypeWithNullable = _x + } + localctx.(*AggStateDataTypeContext).dataTypes = append(localctx.(*AggStateDataTypeContext).dataTypes, localctx.(*AggStateDataTypeContext)._dataTypeWithNullable) + p.SetState(6600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6596) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6597) + + var _x = p.DataTypeWithNullable() + + localctx.(*AggStateDataTypeContext)._dataTypeWithNullable = _x + } + localctx.(*AggStateDataTypeContext).dataTypes = append(localctx.(*AggStateDataTypeContext).dataTypes, localctx.(*AggStateDataTypeContext)._dataTypeWithNullable) + + p.SetState(6602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6603) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6604) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewPrimitiveDataTypeContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6606) + p.PrimitiveColType() + } + p.SetState(6617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserLEFT_PAREN { + { + p.SetState(6607) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6608) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserASTERISK || _la == DorisParserINTEGER_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6609) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6610) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(6615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6616) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimitiveColTypeContext is an interface to support dynamic dispatch. +type IPrimitiveColTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetType_ returns the type_ token. + GetType_() antlr.Token + + // SetType_ sets the type_ token. + SetType_(antlr.Token) + + // Getter signatures + TINYINT() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + INT() antlr.TerminalNode + INTEGER() antlr.TerminalNode + BIGINT() antlr.TerminalNode + LARGEINT() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + FLOAT() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + DATE() antlr.TerminalNode + DATETIME() antlr.TerminalNode + TIME() antlr.TerminalNode + DATEV2() antlr.TerminalNode + DATETIMEV2() antlr.TerminalNode + DATEV1() antlr.TerminalNode + DATETIMEV1() antlr.TerminalNode + BITMAP() antlr.TerminalNode + QUANTILE_STATE() antlr.TerminalNode + HLL() antlr.TerminalNode + AGG_STATE() antlr.TerminalNode + STRING() antlr.TerminalNode + JSON() antlr.TerminalNode + JSONB() antlr.TerminalNode + TEXT() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + CHAR() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DECIMALV2() antlr.TerminalNode + DECIMALV3() antlr.TerminalNode + IPV4() antlr.TerminalNode + IPV6() antlr.TerminalNode + VARBINARY() antlr.TerminalNode + VARIANT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsPrimitiveColTypeContext differentiates from other interfaces. + IsPrimitiveColTypeContext() +} + +type PrimitiveColTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + type_ antlr.Token +} + +func NewEmptyPrimitiveColTypeContext() *PrimitiveColTypeContext { + var p = new(PrimitiveColTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_primitiveColType + return p +} + +func InitEmptyPrimitiveColTypeContext(p *PrimitiveColTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_primitiveColType +} + +func (*PrimitiveColTypeContext) IsPrimitiveColTypeContext() {} + +func NewPrimitiveColTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimitiveColTypeContext { + var p = new(PrimitiveColTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_primitiveColType + + return p +} + +func (s *PrimitiveColTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimitiveColTypeContext) GetType_() antlr.Token { return s.type_ } + +func (s *PrimitiveColTypeContext) SetType_(v antlr.Token) { s.type_ = v } + +func (s *PrimitiveColTypeContext) TINYINT() antlr.TerminalNode { + return s.GetToken(DorisParserTINYINT, 0) +} + +func (s *PrimitiveColTypeContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(DorisParserSMALLINT, 0) +} + +func (s *PrimitiveColTypeContext) INT() antlr.TerminalNode { + return s.GetToken(DorisParserINT, 0) +} + +func (s *PrimitiveColTypeContext) INTEGER() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER, 0) +} + +func (s *PrimitiveColTypeContext) BIGINT() antlr.TerminalNode { + return s.GetToken(DorisParserBIGINT, 0) +} + +func (s *PrimitiveColTypeContext) LARGEINT() antlr.TerminalNode { + return s.GetToken(DorisParserLARGEINT, 0) +} + +func (s *PrimitiveColTypeContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserBOOLEAN, 0) +} + +func (s *PrimitiveColTypeContext) FLOAT() antlr.TerminalNode { + return s.GetToken(DorisParserFLOAT, 0) +} + +func (s *PrimitiveColTypeContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(DorisParserDOUBLE, 0) +} + +func (s *PrimitiveColTypeContext) DATE() antlr.TerminalNode { + return s.GetToken(DorisParserDATE, 0) +} + +func (s *PrimitiveColTypeContext) DATETIME() antlr.TerminalNode { + return s.GetToken(DorisParserDATETIME, 0) +} + +func (s *PrimitiveColTypeContext) TIME() antlr.TerminalNode { + return s.GetToken(DorisParserTIME, 0) +} + +func (s *PrimitiveColTypeContext) DATEV2() antlr.TerminalNode { + return s.GetToken(DorisParserDATEV2, 0) +} + +func (s *PrimitiveColTypeContext) DATETIMEV2() antlr.TerminalNode { + return s.GetToken(DorisParserDATETIMEV2, 0) +} + +func (s *PrimitiveColTypeContext) DATEV1() antlr.TerminalNode { + return s.GetToken(DorisParserDATEV1, 0) +} + +func (s *PrimitiveColTypeContext) DATETIMEV1() antlr.TerminalNode { + return s.GetToken(DorisParserDATETIMEV1, 0) +} + +func (s *PrimitiveColTypeContext) BITMAP() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP, 0) +} + +func (s *PrimitiveColTypeContext) QUANTILE_STATE() antlr.TerminalNode { + return s.GetToken(DorisParserQUANTILE_STATE, 0) +} + +func (s *PrimitiveColTypeContext) HLL() antlr.TerminalNode { + return s.GetToken(DorisParserHLL, 0) +} + +func (s *PrimitiveColTypeContext) AGG_STATE() antlr.TerminalNode { + return s.GetToken(DorisParserAGG_STATE, 0) +} + +func (s *PrimitiveColTypeContext) STRING() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING, 0) +} + +func (s *PrimitiveColTypeContext) JSON() antlr.TerminalNode { + return s.GetToken(DorisParserJSON, 0) +} + +func (s *PrimitiveColTypeContext) JSONB() antlr.TerminalNode { + return s.GetToken(DorisParserJSONB, 0) +} + +func (s *PrimitiveColTypeContext) TEXT() antlr.TerminalNode { + return s.GetToken(DorisParserTEXT, 0) +} + +func (s *PrimitiveColTypeContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(DorisParserVARCHAR, 0) +} + +func (s *PrimitiveColTypeContext) CHAR() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR, 0) +} + +func (s *PrimitiveColTypeContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMAL, 0) +} + +func (s *PrimitiveColTypeContext) DECIMALV2() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMALV2, 0) +} + +func (s *PrimitiveColTypeContext) DECIMALV3() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMALV3, 0) +} + +func (s *PrimitiveColTypeContext) IPV4() antlr.TerminalNode { + return s.GetToken(DorisParserIPV4, 0) +} + +func (s *PrimitiveColTypeContext) IPV6() antlr.TerminalNode { + return s.GetToken(DorisParserIPV6, 0) +} + +func (s *PrimitiveColTypeContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(DorisParserVARBINARY, 0) +} + +func (s *PrimitiveColTypeContext) VARIANT() antlr.TerminalNode { + return s.GetToken(DorisParserVARIANT, 0) +} + +func (s *PrimitiveColTypeContext) ALL() antlr.TerminalNode { + return s.GetToken(DorisParserALL, 0) +} + +func (s *PrimitiveColTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimitiveColTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrimitiveColTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterPrimitiveColType(s) + } +} + +func (s *PrimitiveColTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitPrimitiveColType(s) + } +} + +func (s *PrimitiveColTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitPrimitiveColType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) PrimitiveColType() (localctx IPrimitiveColTypeContext) { + localctx = NewPrimitiveColTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, DorisParserRULE_primitiveColType) + var _la int + + p.SetState(6654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserTINYINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6621) + + var _m = p.Match(DorisParserTINYINT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSMALLINT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6622) + + var _m = p.Match(DorisParserSMALLINT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserINT, DorisParserINTEGER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6623) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*PrimitiveColTypeContext).type_ = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserINT || _la == DorisParserINTEGER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*PrimitiveColTypeContext).type_ = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case DorisParserBIGINT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6624) + + var _m = p.Match(DorisParserBIGINT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserLARGEINT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6625) + + var _m = p.Match(DorisParserLARGEINT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserBOOLEAN: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6626) + + var _m = p.Match(DorisParserBOOLEAN) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserFLOAT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6627) + + var _m = p.Match(DorisParserFLOAT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDOUBLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6628) + + var _m = p.Match(DorisParserDOUBLE) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDATE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6629) + + var _m = p.Match(DorisParserDATE) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDATETIME: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6630) + + var _m = p.Match(DorisParserDATETIME) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserTIME: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6631) + + var _m = p.Match(DorisParserTIME) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDATEV2: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(6632) + + var _m = p.Match(DorisParserDATEV2) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDATETIMEV2: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(6633) + + var _m = p.Match(DorisParserDATETIMEV2) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDATEV1: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(6634) + + var _m = p.Match(DorisParserDATEV1) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDATETIMEV1: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(6635) + + var _m = p.Match(DorisParserDATETIMEV1) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserBITMAP: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(6636) + + var _m = p.Match(DorisParserBITMAP) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserQUANTILE_STATE: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(6637) + + var _m = p.Match(DorisParserQUANTILE_STATE) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserHLL: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(6638) + + var _m = p.Match(DorisParserHLL) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserAGG_STATE: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(6639) + + var _m = p.Match(DorisParserAGG_STATE) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserSTRING: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(6640) + + var _m = p.Match(DorisParserSTRING) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserJSON: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(6641) + + var _m = p.Match(DorisParserJSON) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserJSONB: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(6642) + + var _m = p.Match(DorisParserJSONB) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserTEXT: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(6643) + + var _m = p.Match(DorisParserTEXT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserVARCHAR: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(6644) + + var _m = p.Match(DorisParserVARCHAR) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserCHAR: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(6645) + + var _m = p.Match(DorisParserCHAR) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDECIMAL: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(6646) + + var _m = p.Match(DorisParserDECIMAL) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDECIMALV2: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(6647) + + var _m = p.Match(DorisParserDECIMALV2) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserDECIMALV3: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(6648) + + var _m = p.Match(DorisParserDECIMALV3) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserIPV4: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(6649) + + var _m = p.Match(DorisParserIPV4) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserIPV6: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(6650) + + var _m = p.Match(DorisParserIPV6) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserVARBINARY: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(6651) + + var _m = p.Match(DorisParserVARBINARY) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserVARIANT: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(6652) + + var _m = p.Match(DorisParserVARIANT) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserALL: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(6653) + + var _m = p.Match(DorisParserALL) + + localctx.(*PrimitiveColTypeContext).type_ = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComplexColTypeListContext is an interface to support dynamic dispatch. +type IComplexColTypeListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllComplexColType() []IComplexColTypeContext + ComplexColType(i int) IComplexColTypeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsComplexColTypeListContext differentiates from other interfaces. + IsComplexColTypeListContext() +} + +type ComplexColTypeListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComplexColTypeListContext() *ComplexColTypeListContext { + var p = new(ComplexColTypeListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_complexColTypeList + return p +} + +func InitEmptyComplexColTypeListContext(p *ComplexColTypeListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_complexColTypeList +} + +func (*ComplexColTypeListContext) IsComplexColTypeListContext() {} + +func NewComplexColTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComplexColTypeListContext { + var p = new(ComplexColTypeListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_complexColTypeList + + return p +} + +func (s *ComplexColTypeListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ComplexColTypeListContext) AllComplexColType() []IComplexColTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComplexColTypeContext); ok { + len++ + } + } + + tst := make([]IComplexColTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComplexColTypeContext); ok { + tst[i] = t.(IComplexColTypeContext) + i++ + } + } + + return tst +} + +func (s *ComplexColTypeListContext) ComplexColType(i int) IComplexColTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComplexColTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComplexColTypeContext) +} + +func (s *ComplexColTypeListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *ComplexColTypeListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *ComplexColTypeListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComplexColTypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ComplexColTypeListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterComplexColTypeList(s) + } +} + +func (s *ComplexColTypeListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitComplexColTypeList(s) + } +} + +func (s *ComplexColTypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitComplexColTypeList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ComplexColTypeList() (localctx IComplexColTypeListContext) { + localctx = NewComplexColTypeListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, DorisParserRULE_complexColTypeList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6656) + p.ComplexColType() + } + p.SetState(6661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == DorisParserCOMMA { + { + p.SetState(6657) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6658) + p.ComplexColType() + } + + p.SetState(6663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComplexColTypeContext is an interface to support dynamic dispatch. +type IComplexColTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + COLON() antlr.TerminalNode + DataType() IDataTypeContext + CommentSpec() ICommentSpecContext + + // IsComplexColTypeContext differentiates from other interfaces. + IsComplexColTypeContext() +} + +type ComplexColTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComplexColTypeContext() *ComplexColTypeContext { + var p = new(ComplexColTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_complexColType + return p +} + +func InitEmptyComplexColTypeContext(p *ComplexColTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_complexColType +} + +func (*ComplexColTypeContext) IsComplexColTypeContext() {} + +func NewComplexColTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComplexColTypeContext { + var p = new(ComplexColTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_complexColType + + return p +} + +func (s *ComplexColTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ComplexColTypeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ComplexColTypeContext) COLON() antlr.TerminalNode { + return s.GetToken(DorisParserCOLON, 0) +} + +func (s *ComplexColTypeContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ComplexColTypeContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *ComplexColTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ComplexColTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ComplexColTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterComplexColType(s) + } +} + +func (s *ComplexColTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitComplexColType(s) + } +} + +func (s *ComplexColTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitComplexColType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ComplexColType() (localctx IComplexColTypeContext) { + localctx = NewComplexColTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, DorisParserRULE_complexColType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6664) + p.Identifier() + } + { + p.SetState(6665) + p.Match(DorisParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6666) + p.DataType() + } + p.SetState(6668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(6667) + p.CommentSpec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariantTypeDefinitionsContext is an interface to support dynamic dispatch. +type IVariantTypeDefinitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsVariantTypeDefinitionsContext differentiates from other interfaces. + IsVariantTypeDefinitionsContext() +} + +type VariantTypeDefinitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariantTypeDefinitionsContext() *VariantTypeDefinitionsContext { + var p = new(VariantTypeDefinitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantTypeDefinitions + return p +} + +func InitEmptyVariantTypeDefinitionsContext(p *VariantTypeDefinitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantTypeDefinitions +} + +func (*VariantTypeDefinitionsContext) IsVariantTypeDefinitionsContext() {} + +func NewVariantTypeDefinitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariantTypeDefinitionsContext { + var p = new(VariantTypeDefinitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_variantTypeDefinitions + + return p +} + +func (s *VariantTypeDefinitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariantTypeDefinitionsContext) CopyAll(ctx *VariantTypeDefinitionsContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *VariantTypeDefinitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariantTypeDefinitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type VariantContext struct { + VariantTypeDefinitionsContext + properties IPropertyClauseContext +} + +func NewVariantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VariantContext { + var p = new(VariantContext) + + InitEmptyVariantTypeDefinitionsContext(&p.VariantTypeDefinitionsContext) + p.parser = parser + p.CopyAll(ctx.(*VariantTypeDefinitionsContext)) + + return p +} + +func (s *VariantContext) GetProperties() IPropertyClauseContext { return s.properties } + +func (s *VariantContext) SetProperties(v IPropertyClauseContext) { s.properties = v } + +func (s *VariantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariantContext) VARIANT() antlr.TerminalNode { + return s.GetToken(DorisParserVARIANT, 0) +} + +func (s *VariantContext) LT() antlr.TerminalNode { + return s.GetToken(DorisParserLT, 0) +} + +func (s *VariantContext) VariantSubColTypeList() IVariantSubColTypeListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariantSubColTypeListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariantSubColTypeListContext) +} + +func (s *VariantContext) COMMA() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, 0) +} + +func (s *VariantContext) GT() antlr.TerminalNode { + return s.GetToken(DorisParserGT, 0) +} + +func (s *VariantContext) PropertyClause() IPropertyClauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPropertyClauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPropertyClauseContext) +} + +func (s *VariantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterVariant(s) + } +} + +func (s *VariantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitVariant(s) + } +} + +func (s *VariantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitVariant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) VariantTypeDefinitions() (localctx IVariantTypeDefinitionsContext) { + localctx = NewVariantTypeDefinitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, DorisParserRULE_variantTypeDefinitions) + p.SetState(6688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 945, p.GetParserRuleContext()) { + case 1: + localctx = NewVariantContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6670) + p.Match(DorisParserVARIANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6671) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6672) + p.VariantSubColTypeList() + } + { + p.SetState(6673) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6674) + + var _x = p.PropertyClause() + + localctx.(*VariantContext).properties = _x + } + { + p.SetState(6675) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewVariantContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6677) + p.Match(DorisParserVARIANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6678) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6679) + p.VariantSubColTypeList() + } + { + p.SetState(6680) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewVariantContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6682) + p.Match(DorisParserVARIANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6683) + p.Match(DorisParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6684) + + var _x = p.PropertyClause() + + localctx.(*VariantContext).properties = _x + } + { + p.SetState(6685) + p.Match(DorisParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewVariantContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6687) + p.Match(DorisParserVARIANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariantSubColTypeListContext is an interface to support dynamic dispatch. +type IVariantSubColTypeListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllVariantSubColType() []IVariantSubColTypeContext + VariantSubColType(i int) IVariantSubColTypeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsVariantSubColTypeListContext differentiates from other interfaces. + IsVariantSubColTypeListContext() +} + +type VariantSubColTypeListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariantSubColTypeListContext() *VariantSubColTypeListContext { + var p = new(VariantSubColTypeListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantSubColTypeList + return p +} + +func InitEmptyVariantSubColTypeListContext(p *VariantSubColTypeListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantSubColTypeList +} + +func (*VariantSubColTypeListContext) IsVariantSubColTypeListContext() {} + +func NewVariantSubColTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariantSubColTypeListContext { + var p = new(VariantSubColTypeListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_variantSubColTypeList + + return p +} + +func (s *VariantSubColTypeListContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariantSubColTypeListContext) AllVariantSubColType() []IVariantSubColTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariantSubColTypeContext); ok { + len++ + } + } + + tst := make([]IVariantSubColTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariantSubColTypeContext); ok { + tst[i] = t.(IVariantSubColTypeContext) + i++ + } + } + + return tst +} + +func (s *VariantSubColTypeListContext) VariantSubColType(i int) IVariantSubColTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariantSubColTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariantSubColTypeContext) +} + +func (s *VariantSubColTypeListContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(DorisParserCOMMA) +} + +func (s *VariantSubColTypeListContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(DorisParserCOMMA, i) +} + +func (s *VariantSubColTypeListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariantSubColTypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariantSubColTypeListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterVariantSubColTypeList(s) + } +} + +func (s *VariantSubColTypeListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitVariantSubColTypeList(s) + } +} + +func (s *VariantSubColTypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitVariantSubColTypeList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) VariantSubColTypeList() (localctx IVariantSubColTypeListContext) { + localctx = NewVariantSubColTypeListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, DorisParserRULE_variantSubColTypeList) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6690) + p.VariantSubColType() + } + p.SetState(6695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 946, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(6691) + p.Match(DorisParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6692) + p.VariantSubColType() + } + + } + p.SetState(6697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 946, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariantSubColTypeContext is an interface to support dynamic dispatch. +type IVariantSubColTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING_LITERAL() antlr.TerminalNode + COLON() antlr.TerminalNode + DataType() IDataTypeContext + VariantSubColMatchType() IVariantSubColMatchTypeContext + CommentSpec() ICommentSpecContext + + // IsVariantSubColTypeContext differentiates from other interfaces. + IsVariantSubColTypeContext() +} + +type VariantSubColTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariantSubColTypeContext() *VariantSubColTypeContext { + var p = new(VariantSubColTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantSubColType + return p +} + +func InitEmptyVariantSubColTypeContext(p *VariantSubColTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantSubColType +} + +func (*VariantSubColTypeContext) IsVariantSubColTypeContext() {} + +func NewVariantSubColTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariantSubColTypeContext { + var p = new(VariantSubColTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_variantSubColType + + return p +} + +func (s *VariantSubColTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariantSubColTypeContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *VariantSubColTypeContext) COLON() antlr.TerminalNode { + return s.GetToken(DorisParserCOLON, 0) +} + +func (s *VariantSubColTypeContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *VariantSubColTypeContext) VariantSubColMatchType() IVariantSubColMatchTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariantSubColMatchTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariantSubColMatchTypeContext) +} + +func (s *VariantSubColTypeContext) CommentSpec() ICommentSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentSpecContext) +} + +func (s *VariantSubColTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariantSubColTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariantSubColTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterVariantSubColType(s) + } +} + +func (s *VariantSubColTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitVariantSubColType(s) + } +} + +func (s *VariantSubColTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitVariantSubColType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) VariantSubColType() (localctx IVariantSubColTypeContext) { + localctx = NewVariantSubColTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, DorisParserRULE_variantSubColType) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserMATCH_NAME || _la == DorisParserMATCH_NAME_GLOB { + { + p.SetState(6698) + p.VariantSubColMatchType() + } + + } + { + p.SetState(6701) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6702) + p.Match(DorisParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6703) + p.DataType() + } + p.SetState(6705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserCOMMENT { + { + p.SetState(6704) + p.CommentSpec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariantSubColMatchTypeContext is an interface to support dynamic dispatch. +type IVariantSubColMatchTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATCH_NAME() antlr.TerminalNode + MATCH_NAME_GLOB() antlr.TerminalNode + + // IsVariantSubColMatchTypeContext differentiates from other interfaces. + IsVariantSubColMatchTypeContext() +} + +type VariantSubColMatchTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariantSubColMatchTypeContext() *VariantSubColMatchTypeContext { + var p = new(VariantSubColMatchTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantSubColMatchType + return p +} + +func InitEmptyVariantSubColMatchTypeContext(p *VariantSubColMatchTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_variantSubColMatchType +} + +func (*VariantSubColMatchTypeContext) IsVariantSubColMatchTypeContext() {} + +func NewVariantSubColMatchTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariantSubColMatchTypeContext { + var p = new(VariantSubColMatchTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_variantSubColMatchType + + return p +} + +func (s *VariantSubColMatchTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariantSubColMatchTypeContext) MATCH_NAME() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_NAME, 0) +} + +func (s *VariantSubColMatchTypeContext) MATCH_NAME_GLOB() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_NAME_GLOB, 0) +} + +func (s *VariantSubColMatchTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariantSubColMatchTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariantSubColMatchTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterVariantSubColMatchType(s) + } +} + +func (s *VariantSubColMatchTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitVariantSubColMatchType(s) + } +} + +func (s *VariantSubColMatchTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitVariantSubColMatchType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) VariantSubColMatchType() (localctx IVariantSubColMatchTypeContext) { + localctx = NewVariantSubColMatchTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, DorisParserRULE_variantSubColMatchType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6707) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserMATCH_NAME || _la == DorisParserMATCH_NAME_GLOB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommentSpecContext is an interface to support dynamic dispatch. +type ICommentSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsCommentSpecContext differentiates from other interfaces. + IsCommentSpecContext() +} + +type CommentSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommentSpecContext() *CommentSpecContext { + var p = new(CommentSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_commentSpec + return p +} + +func InitEmptyCommentSpecContext(p *CommentSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_commentSpec +} + +func (*CommentSpecContext) IsCommentSpecContext() {} + +func NewCommentSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentSpecContext { + var p = new(CommentSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_commentSpec + + return p +} + +func (s *CommentSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *CommentSpecContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *CommentSpecContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *CommentSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommentSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CommentSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterCommentSpec(s) + } +} + +func (s *CommentSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitCommentSpec(s) + } +} + +func (s *CommentSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitCommentSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) CommentSpec() (localctx ICommentSpecContext) { + localctx = NewCommentSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, DorisParserRULE_commentSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6709) + p.Match(DorisParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6710) + p.Match(DorisParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISampleContext is an interface to support dynamic dispatch. +type ISampleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSeed returns the seed token. + GetSeed() antlr.Token + + // SetSeed sets the seed token. + SetSeed(antlr.Token) + + // Getter signatures + TABLESAMPLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SampleMethod() ISampleMethodContext + REPEATABLE() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + + // IsSampleContext differentiates from other interfaces. + IsSampleContext() +} + +type SampleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + seed antlr.Token +} + +func NewEmptySampleContext() *SampleContext { + var p = new(SampleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sample + return p +} + +func InitEmptySampleContext(p *SampleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sample +} + +func (*SampleContext) IsSampleContext() {} + +func NewSampleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SampleContext { + var p = new(SampleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_sample + + return p +} + +func (s *SampleContext) GetParser() antlr.Parser { return s.parser } + +func (s *SampleContext) GetSeed() antlr.Token { return s.seed } + +func (s *SampleContext) SetSeed(v antlr.Token) { s.seed = v } + +func (s *SampleContext) TABLESAMPLE() antlr.TerminalNode { + return s.GetToken(DorisParserTABLESAMPLE, 0) +} + +func (s *SampleContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_PAREN, 0) +} + +func (s *SampleContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_PAREN, 0) +} + +func (s *SampleContext) SampleMethod() ISampleMethodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISampleMethodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISampleMethodContext) +} + +func (s *SampleContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(DorisParserREPEATABLE, 0) +} + +func (s *SampleContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *SampleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SampleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SampleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSample(s) + } +} + +func (s *SampleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSample(s) + } +} + +func (s *SampleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSample(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Sample() (localctx ISampleContext) { + localctx = NewSampleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, DorisParserRULE_sample) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6712) + p.Match(DorisParserTABLESAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6713) + p.Match(DorisParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserINTEGER_VALUE { + { + p.SetState(6714) + p.SampleMethod() + } + + } + { + p.SetState(6717) + p.Match(DorisParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6720) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 950, p.GetParserRuleContext()) == 1 { + { + p.SetState(6718) + p.Match(DorisParserREPEATABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6719) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*SampleContext).seed = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISampleMethodContext is an interface to support dynamic dispatch. +type ISampleMethodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsSampleMethodContext differentiates from other interfaces. + IsSampleMethodContext() +} + +type SampleMethodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySampleMethodContext() *SampleMethodContext { + var p = new(SampleMethodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sampleMethod + return p +} + +func InitEmptySampleMethodContext(p *SampleMethodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_sampleMethod +} + +func (*SampleMethodContext) IsSampleMethodContext() {} + +func NewSampleMethodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SampleMethodContext { + var p = new(SampleMethodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_sampleMethod + + return p +} + +func (s *SampleMethodContext) GetParser() antlr.Parser { return s.parser } + +func (s *SampleMethodContext) CopyAll(ctx *SampleMethodContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *SampleMethodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SampleMethodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type SampleByRowsContext struct { + SampleMethodContext +} + +func NewSampleByRowsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SampleByRowsContext { + var p = new(SampleByRowsContext) + + InitEmptySampleMethodContext(&p.SampleMethodContext) + p.parser = parser + p.CopyAll(ctx.(*SampleMethodContext)) + + return p +} + +func (s *SampleByRowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SampleByRowsContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *SampleByRowsContext) ROWS() antlr.TerminalNode { + return s.GetToken(DorisParserROWS, 0) +} + +func (s *SampleByRowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSampleByRows(s) + } +} + +func (s *SampleByRowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSampleByRows(s) + } +} + +func (s *SampleByRowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSampleByRows(s) + + default: + return t.VisitChildren(s) + } +} + +type SampleByPercentileContext struct { + SampleMethodContext + percentage antlr.Token +} + +func NewSampleByPercentileContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SampleByPercentileContext { + var p = new(SampleByPercentileContext) + + InitEmptySampleMethodContext(&p.SampleMethodContext) + p.parser = parser + p.CopyAll(ctx.(*SampleMethodContext)) + + return p +} + +func (s *SampleByPercentileContext) GetPercentage() antlr.Token { return s.percentage } + +func (s *SampleByPercentileContext) SetPercentage(v antlr.Token) { s.percentage = v } + +func (s *SampleByPercentileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SampleByPercentileContext) PERCENT() antlr.TerminalNode { + return s.GetToken(DorisParserPERCENT, 0) +} + +func (s *SampleByPercentileContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *SampleByPercentileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterSampleByPercentile(s) + } +} + +func (s *SampleByPercentileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitSampleByPercentile(s) + } +} + +func (s *SampleByPercentileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitSampleByPercentile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) SampleMethod() (localctx ISampleMethodContext) { + localctx = NewSampleMethodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, DorisParserRULE_sampleMethod) + p.SetState(6726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 951, p.GetParserRuleContext()) { + case 1: + localctx = NewSampleByPercentileContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6722) + + var _m = p.Match(DorisParserINTEGER_VALUE) + + localctx.(*SampleByPercentileContext).percentage = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6723) + p.Match(DorisParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewSampleByRowsContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6724) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6725) + p.Match(DorisParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableSnapshotContext is an interface to support dynamic dispatch. +type ITableSnapshotContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetVersion returns the version token. + GetVersion() antlr.Token + + // GetTime returns the time token. + GetTime() antlr.Token + + // SetVersion sets the version token. + SetVersion(antlr.Token) + + // SetTime sets the time token. + SetTime(antlr.Token) + + // Getter signatures + FOR() antlr.TerminalNode + VERSION() antlr.TerminalNode + AS() antlr.TerminalNode + OF() antlr.TerminalNode + INTEGER_VALUE() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + TIME() antlr.TerminalNode + + // IsTableSnapshotContext differentiates from other interfaces. + IsTableSnapshotContext() +} + +type TableSnapshotContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + version antlr.Token + time antlr.Token +} + +func NewEmptyTableSnapshotContext() *TableSnapshotContext { + var p = new(TableSnapshotContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tableSnapshot + return p +} + +func InitEmptyTableSnapshotContext(p *TableSnapshotContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_tableSnapshot +} + +func (*TableSnapshotContext) IsTableSnapshotContext() {} + +func NewTableSnapshotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSnapshotContext { + var p = new(TableSnapshotContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_tableSnapshot + + return p +} + +func (s *TableSnapshotContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableSnapshotContext) GetVersion() antlr.Token { return s.version } + +func (s *TableSnapshotContext) GetTime() antlr.Token { return s.time } + +func (s *TableSnapshotContext) SetVersion(v antlr.Token) { s.version = v } + +func (s *TableSnapshotContext) SetTime(v antlr.Token) { s.time = v } + +func (s *TableSnapshotContext) FOR() antlr.TerminalNode { + return s.GetToken(DorisParserFOR, 0) +} + +func (s *TableSnapshotContext) VERSION() antlr.TerminalNode { + return s.GetToken(DorisParserVERSION, 0) +} + +func (s *TableSnapshotContext) AS() antlr.TerminalNode { + return s.GetToken(DorisParserAS, 0) +} + +func (s *TableSnapshotContext) OF() antlr.TerminalNode { + return s.GetToken(DorisParserOF, 0) +} + +func (s *TableSnapshotContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *TableSnapshotContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING_LITERAL, 0) +} + +func (s *TableSnapshotContext) TIME() antlr.TerminalNode { + return s.GetToken(DorisParserTIME, 0) +} + +func (s *TableSnapshotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableSnapshotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableSnapshotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterTableSnapshot(s) + } +} + +func (s *TableSnapshotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitTableSnapshot(s) + } +} + +func (s *TableSnapshotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitTableSnapshot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) TableSnapshot() (localctx ITableSnapshotContext) { + localctx = NewTableSnapshotContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, DorisParserRULE_tableSnapshot) + var _la int + + p.SetState(6738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 952, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6728) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6729) + p.Match(DorisParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6730) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6731) + p.Match(DorisParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6732) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableSnapshotContext).version = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserSTRING_LITERAL || _la == DorisParserINTEGER_VALUE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableSnapshotContext).version = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6733) + p.Match(DorisParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6734) + p.Match(DorisParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6735) + p.Match(DorisParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6736) + p.Match(DorisParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6737) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*TableSnapshotContext).time = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserSTRING_LITERAL || _la == DorisParserINTEGER_VALUE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*TableSnapshotContext).time = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IErrorCapturingIdentifierContext is an interface to support dynamic dispatch. +type IErrorCapturingIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + ErrorCapturingIdentifierExtra() IErrorCapturingIdentifierExtraContext + + // IsErrorCapturingIdentifierContext differentiates from other interfaces. + IsErrorCapturingIdentifierContext() +} + +type ErrorCapturingIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyErrorCapturingIdentifierContext() *ErrorCapturingIdentifierContext { + var p = new(ErrorCapturingIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_errorCapturingIdentifier + return p +} + +func InitEmptyErrorCapturingIdentifierContext(p *ErrorCapturingIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_errorCapturingIdentifier +} + +func (*ErrorCapturingIdentifierContext) IsErrorCapturingIdentifierContext() {} + +func NewErrorCapturingIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ErrorCapturingIdentifierContext { + var p = new(ErrorCapturingIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_errorCapturingIdentifier + + return p +} + +func (s *ErrorCapturingIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *ErrorCapturingIdentifierContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ErrorCapturingIdentifierContext) ErrorCapturingIdentifierExtra() IErrorCapturingIdentifierExtraContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IErrorCapturingIdentifierExtraContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IErrorCapturingIdentifierExtraContext) +} + +func (s *ErrorCapturingIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ErrorCapturingIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ErrorCapturingIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterErrorCapturingIdentifier(s) + } +} + +func (s *ErrorCapturingIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitErrorCapturingIdentifier(s) + } +} + +func (s *ErrorCapturingIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitErrorCapturingIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ErrorCapturingIdentifier() (localctx IErrorCapturingIdentifierContext) { + localctx = NewErrorCapturingIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, DorisParserRULE_errorCapturingIdentifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6740) + p.Identifier() + } + { + p.SetState(6741) + p.ErrorCapturingIdentifierExtra() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IErrorCapturingIdentifierExtraContext is an interface to support dynamic dispatch. +type IErrorCapturingIdentifierExtraContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsErrorCapturingIdentifierExtraContext differentiates from other interfaces. + IsErrorCapturingIdentifierExtraContext() +} + +type ErrorCapturingIdentifierExtraContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyErrorCapturingIdentifierExtraContext() *ErrorCapturingIdentifierExtraContext { + var p = new(ErrorCapturingIdentifierExtraContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_errorCapturingIdentifierExtra + return p +} + +func InitEmptyErrorCapturingIdentifierExtraContext(p *ErrorCapturingIdentifierExtraContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_errorCapturingIdentifierExtra +} + +func (*ErrorCapturingIdentifierExtraContext) IsErrorCapturingIdentifierExtraContext() {} + +func NewErrorCapturingIdentifierExtraContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ErrorCapturingIdentifierExtraContext { + var p = new(ErrorCapturingIdentifierExtraContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_errorCapturingIdentifierExtra + + return p +} + +func (s *ErrorCapturingIdentifierExtraContext) GetParser() antlr.Parser { return s.parser } + +func (s *ErrorCapturingIdentifierExtraContext) CopyAll(ctx *ErrorCapturingIdentifierExtraContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *ErrorCapturingIdentifierExtraContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ErrorCapturingIdentifierExtraContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type ErrorIdentContext struct { + ErrorCapturingIdentifierExtraContext +} + +func NewErrorIdentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ErrorIdentContext { + var p = new(ErrorIdentContext) + + InitEmptyErrorCapturingIdentifierExtraContext(&p.ErrorCapturingIdentifierExtraContext) + p.parser = parser + p.CopyAll(ctx.(*ErrorCapturingIdentifierExtraContext)) + + return p +} + +func (s *ErrorIdentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ErrorIdentContext) AllSUBTRACT() []antlr.TerminalNode { + return s.GetTokens(DorisParserSUBTRACT) +} + +func (s *ErrorIdentContext) SUBTRACT(i int) antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, i) +} + +func (s *ErrorIdentContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *ErrorIdentContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ErrorIdentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterErrorIdent(s) + } +} + +func (s *ErrorIdentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitErrorIdent(s) + } +} + +func (s *ErrorIdentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitErrorIdent(s) + + default: + return t.VisitChildren(s) + } +} + +type RealIdentContext struct { + ErrorCapturingIdentifierExtraContext +} + +func NewRealIdentContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RealIdentContext { + var p = new(RealIdentContext) + + InitEmptyErrorCapturingIdentifierExtraContext(&p.ErrorCapturingIdentifierExtraContext) + p.parser = parser + p.CopyAll(ctx.(*ErrorCapturingIdentifierExtraContext)) + + return p +} + +func (s *RealIdentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RealIdentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterRealIdent(s) + } +} + +func (s *RealIdentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitRealIdent(s) + } +} + +func (s *RealIdentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitRealIdent(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) ErrorCapturingIdentifierExtra() (localctx IErrorCapturingIdentifierExtraContext) { + localctx = NewErrorCapturingIdentifierExtraContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, DorisParserRULE_errorCapturingIdentifierExtra) + var _alt int + + p.SetState(6750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 954, p.GetParserRuleContext()) { + case 1: + localctx = NewErrorIdentContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(6745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(6743) + p.Match(DorisParserSUBTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6744) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6747) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 953, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + localctx = NewRealIdentContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierContext is an interface to support dynamic dispatch. +type IIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StrictIdentifier() IStrictIdentifierContext + + // IsIdentifierContext differentiates from other interfaces. + IsIdentifierContext() +} + +type IdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierContext() *IdentifierContext { + var p = new(IdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifier + return p +} + +func InitEmptyIdentifierContext(p *IdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_identifier +} + +func (*IdentifierContext) IsIdentifierContext() {} + +func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext { + var p = new(IdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_identifier + + return p +} + +func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierContext) StrictIdentifier() IStrictIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStrictIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStrictIdentifierContext) +} + +func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIdentifier(s) + } +} + +func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIdentifier(s) + } +} + +func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Identifier() (localctx IIdentifierContext) { + localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, DorisParserRULE_identifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6752) + p.StrictIdentifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStrictIdentifierContext is an interface to support dynamic dispatch. +type IStrictIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsStrictIdentifierContext differentiates from other interfaces. + IsStrictIdentifierContext() +} + +type StrictIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStrictIdentifierContext() *StrictIdentifierContext { + var p = new(StrictIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_strictIdentifier + return p +} + +func InitEmptyStrictIdentifierContext(p *StrictIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_strictIdentifier +} + +func (*StrictIdentifierContext) IsStrictIdentifierContext() {} + +func NewStrictIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StrictIdentifierContext { + var p = new(StrictIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_strictIdentifier + + return p +} + +func (s *StrictIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *StrictIdentifierContext) CopyAll(ctx *StrictIdentifierContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *StrictIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StrictIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type QuotedIdentifierAlternativeContext struct { + StrictIdentifierContext +} + +func NewQuotedIdentifierAlternativeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QuotedIdentifierAlternativeContext { + var p = new(QuotedIdentifierAlternativeContext) + + InitEmptyStrictIdentifierContext(&p.StrictIdentifierContext) + p.parser = parser + p.CopyAll(ctx.(*StrictIdentifierContext)) + + return p +} + +func (s *QuotedIdentifierAlternativeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QuotedIdentifierAlternativeContext) QuotedIdentifier() IQuotedIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuotedIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuotedIdentifierContext) +} + +func (s *QuotedIdentifierAlternativeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQuotedIdentifierAlternative(s) + } +} + +func (s *QuotedIdentifierAlternativeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQuotedIdentifierAlternative(s) + } +} + +func (s *QuotedIdentifierAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQuotedIdentifierAlternative(s) + + default: + return t.VisitChildren(s) + } +} + +type UnquotedIdentifierContext struct { + StrictIdentifierContext +} + +func NewUnquotedIdentifierContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UnquotedIdentifierContext { + var p = new(UnquotedIdentifierContext) + + InitEmptyStrictIdentifierContext(&p.StrictIdentifierContext) + p.parser = parser + p.CopyAll(ctx.(*StrictIdentifierContext)) + + return p +} + +func (s *UnquotedIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnquotedIdentifierContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(DorisParserIDENTIFIER, 0) +} + +func (s *UnquotedIdentifierContext) NonReserved() INonReservedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonReservedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonReservedContext) +} + +func (s *UnquotedIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterUnquotedIdentifier(s) + } +} + +func (s *UnquotedIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitUnquotedIdentifier(s) + } +} + +func (s *UnquotedIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitUnquotedIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) StrictIdentifier() (localctx IStrictIdentifierContext) { + localctx = NewStrictIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, DorisParserRULE_strictIdentifier) + p.SetState(6757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case DorisParserIDENTIFIER: + localctx = NewUnquotedIdentifierContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6754) + p.Match(DorisParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case DorisParserBACKQUOTED_IDENTIFIER: + localctx = NewQuotedIdentifierAlternativeContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6755) + p.QuotedIdentifier() + } + + case DorisParserLEFT_BRACE, DorisParserRIGHT_BRACE, DorisParserACTIONS, DorisParserAFTER, DorisParserAGG_STATE, DorisParserAGGREGATE, DorisParserALIAS, DorisParserANALYZED, DorisParserARRAY, DorisParserAT, DorisParserAUTHORS, DorisParserAUTO_INCREMENT, DorisParserALWAYS, DorisParserBACKENDS, DorisParserBACKUP, DorisParserBEGIN, DorisParserBELONG, DorisParserBIN, DorisParserBITAND, DorisParserBITMAP, DorisParserBITMAP_EMPTY, DorisParserBITMAP_UNION, DorisParserBITOR, DorisParserBITXOR, DorisParserBLOB, DorisParserBOOLEAN, DorisParserBRANCH, DorisParserBRIEF, DorisParserBROKER, DorisParserBUCKETS, DorisParserBUILD, DorisParserBUILTIN, DorisParserBULK, DorisParserCACHE, DorisParserCACHED, DorisParserCALL, DorisParserCATALOG, DorisParserCATALOGS, DorisParserCHAIN, DorisParserCHAR, DorisParserCHARSET, DorisParserCHECK, DorisParserCLUSTER, DorisParserCLUSTERS, DorisParserCOLLATION, DorisParserCOLLECT, DorisParserCOLOCATE, DorisParserCOLUMNS, DorisParserCOMMENT, DorisParserCOMMIT, DorisParserCOMMITTED, DorisParserCOMPACT, DorisParserCOMPLETE, DorisParserCOMPRESS_TYPE, DorisParserCOMPUTE, DorisParserCONDITIONS, DorisParserCONFIG, DorisParserCONNECTION, DorisParserCONNECTION_ID, DorisParserCONSISTENT, DorisParserCONSTRAINTS, DorisParserCONVERT, DorisParserCONVERT_LSC, DorisParserCOPY, DorisParserCOUNT, DorisParserCREATION, DorisParserCRON, DorisParserCURRENT_CATALOG, DorisParserCURRENT_DATE, DorisParserCURRENT_TIME, DorisParserCURRENT_TIMESTAMP, DorisParserCURRENT_USER, DorisParserDATA, DorisParserDATE, DorisParserDATETIME, DorisParserDATETIMEV2, DorisParserDATEV2, DorisParserDATETIMEV1, DorisParserDATEV1, DorisParserDAY, DorisParserDAYS, DorisParserDECIMAL, DorisParserDECIMALV2, DorisParserDECIMALV3, DorisParserDEFERRED, DorisParserDEMAND, DorisParserDIAGNOSE, DorisParserDIAGNOSIS, DorisParserDICTIONARIES, DorisParserDICTIONARY, DorisParserDISTINCTPC, DorisParserDISTINCTPCSA, DorisParserDO, DorisParserDORIS_INTERNAL_TABLE_ID, DorisParserDUAL, DorisParserDYNAMIC, DorisParserE, DorisParserENABLE, DorisParserENCRYPTION, DorisParserENCRYPTKEY, DorisParserENCRYPTKEYS, DorisParserEND, DorisParserENDS, DorisParserENGINE, DorisParserENGINES, DorisParserERRORS, DorisParserESCAPE, DorisParserEVENTS, DorisParserEVERY, DorisParserEXCLUDE, DorisParserEXPIRED, DorisParserEXTERNAL, DorisParserFAILED_LOGIN_ATTEMPTS, DorisParserFAST, DorisParserFEATURE, DorisParserFIELDS, DorisParserFILE, DorisParserFILTER, DorisParserFIRST, DorisParserFORMAT, DorisParserFREE, DorisParserFRONTENDS, DorisParserFUNCTION, DorisParserGENERATED, DorisParserGENERIC, DorisParserGLOBAL, DorisParserGRAPH, DorisParserGROUPING, DorisParserGROUPS, DorisParserGROUP_CONCAT, DorisParserHASH, DorisParserHASH_MAP, DorisParserHDFS, DorisParserHELP, DorisParserHISTOGRAM, DorisParserHLL_UNION, DorisParserHOSTNAME, DorisParserHOTSPOT, DorisParserHOUR, DorisParserHOURS, DorisParserHUB, DorisParserIDENTIFIED, DorisParserIGNORE, DorisParserIMMEDIATE, DorisParserINCREMENTAL, DorisParserINDEXES, DorisParserINSERT, DorisParserINVERTED, DorisParserIP_TRIE, DorisParserIPV4, DorisParserIPV6, DorisParserIS_NOT_NULL_PRED, DorisParserIS_NULL_PRED, DorisParserISNULL, DorisParserISOLATION, DorisParserJOB, DorisParserJOBS, DorisParserJSON, DorisParserJSONB, DorisParserLABEL, DorisParserLAST, DorisParserLDAP, DorisParserLDAP_ADMIN_PASSWORD, DorisParserLESS, DorisParserLEVEL, DorisParserLINES, DorisParserLINK, DorisParserLOCAL, DorisParserLOCALTIME, DorisParserLOCALTIMESTAMP, DorisParserLOCATION, DorisParserLOCK, DorisParserLOGICAL, DorisParserMANUAL, DorisParserMAP, DorisParserMATCHED, DorisParserMATCH_ALL, DorisParserMATCH_ANY, DorisParserMATCH_NAME, DorisParserMATCH_NAME_GLOB, DorisParserMATCH_PHRASE, DorisParserMATCH_PHRASE_EDGE, DorisParserMATCH_PHRASE_PREFIX, DorisParserMATCH_REGEXP, DorisParserMATERIALIZED, DorisParserMAX, DorisParserMEMO, DorisParserMERGE, DorisParserMID, DorisParserMIGRATE, DorisParserMIGRATIONS, DorisParserMIN, DorisParserMINUTE, DorisParserMINUTES, DorisParserMODIFY, DorisParserMONTH, DorisParserMTMV, DorisParserNAME, DorisParserNAMES, DorisParserNEGATIVE, DorisParserNEVER, DorisParserNEXT, DorisParserNGRAM_BF, DorisParserANN, DorisParserNO, DorisParserNON_NULLABLE, DorisParserNULLS, DorisParserOF, DorisParserOFFSET, DorisParserOFF, DorisParserONLY, DorisParserOPEN, DorisParserOPTIMIZE, DorisParserOPTIMIZED, DorisParserPARAMETER, DorisParserPARSED, DorisParserPARTITIONS, DorisParserPASSWORD, DorisParserPASSWORD_EXPIRE, DorisParserPASSWORD_HISTORY, DorisParserPASSWORD_LOCK_TIME, DorisParserPASSWORD_REUSE, DorisParserPATH, DorisParserPAUSE, DorisParserPERCENT, DorisParserPERIOD, DorisParserPERMISSIVE, DorisParserPHYSICAL, DorisParserPI, DorisParserPLAN, DorisParserPRIVILEGES, DorisParserPROCESS, DorisParserPLUGIN, DorisParserPLUGINS, DorisParserPOLICY, DorisParserPOSITION, DorisParserPROC, DorisParserPROCESSLIST, DorisParserPROFILE, DorisParserPROPERTIES, DorisParserPROPERTY, DorisParserQUANTILE_STATE, DorisParserQUANTILE_UNION, DorisParserQUERY, DorisParserQUEUED, DorisParserQUOTA, DorisParserQUALIFY, DorisParserQUARTER, DorisParserRANDOM, DorisParserRECENT, DorisParserRECOVER, DorisParserRECYCLE, DorisParserREFRESH, DorisParserREPEATABLE, DorisParserREPLACE, DorisParserREPLACE_IF_NOT_NULL, DorisParserREPLAYER, DorisParserREPOSITORIES, DorisParserREPOSITORY, DorisParserRESOURCE, DorisParserRESOURCES, DorisParserRESTORE, DorisParserRESTRICTIVE, DorisParserRESUME, DorisParserRETAIN, DorisParserRETENTION, DorisParserRETURNS, DorisParserREWRITTEN, DorisParserRLIKE, DorisParserROLLBACK, DorisParserROLLUP, DorisParserROOT, DorisParserROTATE, DorisParserROUTINE, DorisParserS3, DorisParserSAMPLE, DorisParserSCHEDULE, DorisParserSCHEDULER, DorisParserSCHEMA, DorisParserSECOND, DorisParserSEPARATOR, DorisParserSERIALIZABLE, DorisParserSESSION, DorisParserSESSION_USER, DorisParserSET_SESSION_VARIABLE, DorisParserSHAPE, DorisParserSKEW, DorisParserSNAPSHOT, DorisParserSNAPSHOTS, DorisParserSONAME, DorisParserSPLIT, DorisParserSQL, DorisParserSTAGE, DorisParserSTAGES, DorisParserSTART, DorisParserSTARTS, DorisParserSTATS, DorisParserSTATUS, DorisParserSTOP, DorisParserSTORAGE, DorisParserSTREAM, DorisParserSTREAMING, DorisParserSTRING, DorisParserSTRUCT, DorisParserSUBSTR, DorisParserSUBSTRING, DorisParserSUM, DorisParserTABLES, DorisParserTAG, DorisParserTASK, DorisParserTASKS, DorisParserTDE, DorisParserTEMPORARY, DorisParserTEXT, DorisParserTHAN, DorisParserTIME, DorisParserTIMESTAMP, DorisParserTRANSACTION, DorisParserTREE, DorisParserTRIGGERS, DorisParserTRUNCATE, DorisParserTYPE, DorisParserTYPES, DorisParserUNCOMMITTED, DorisParserUNLOCK, DorisParserUNSET, DorisParserUP, DorisParserUSER, DorisParserVALUE, DorisParserVARBINARY, DorisParserVARCHAR, DorisParserVARIABLE, DorisParserVARIABLES, DorisParserVARIANT, DorisParserVAULT, DorisParserVAULTS, DorisParserVERBOSE, DorisParserVERSION, DorisParserVIEW, DorisParserVIEWS, DorisParserWARM, DorisParserWARNINGS, DorisParserWEEK, DorisParserWORK, DorisParserYEAR, DorisParserHINT_START, DorisParserHINT_END, DorisParserCOMMENT_START, DorisParserGET_FORMAT: + localctx = NewUnquotedIdentifierContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6756) + p.NonReserved() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuotedIdentifierContext is an interface to support dynamic dispatch. +type IQuotedIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BACKQUOTED_IDENTIFIER() antlr.TerminalNode + + // IsQuotedIdentifierContext differentiates from other interfaces. + IsQuotedIdentifierContext() +} + +type QuotedIdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuotedIdentifierContext() *QuotedIdentifierContext { + var p = new(QuotedIdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_quotedIdentifier + return p +} + +func InitEmptyQuotedIdentifierContext(p *QuotedIdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_quotedIdentifier +} + +func (*QuotedIdentifierContext) IsQuotedIdentifierContext() {} + +func NewQuotedIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QuotedIdentifierContext { + var p = new(QuotedIdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_quotedIdentifier + + return p +} + +func (s *QuotedIdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *QuotedIdentifierContext) BACKQUOTED_IDENTIFIER() antlr.TerminalNode { + return s.GetToken(DorisParserBACKQUOTED_IDENTIFIER, 0) +} + +func (s *QuotedIdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QuotedIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *QuotedIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterQuotedIdentifier(s) + } +} + +func (s *QuotedIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitQuotedIdentifier(s) + } +} + +func (s *QuotedIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitQuotedIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) QuotedIdentifier() (localctx IQuotedIdentifierContext) { + localctx = NewQuotedIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, DorisParserRULE_quotedIdentifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6759) + p.Match(DorisParserBACKQUOTED_IDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumberContext is an interface to support dynamic dispatch. +type INumberContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsNumberContext differentiates from other interfaces. + IsNumberContext() +} + +type NumberContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumberContext() *NumberContext { + var p = new(NumberContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_number + return p +} + +func InitEmptyNumberContext(p *NumberContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_number +} + +func (*NumberContext) IsNumberContext() {} + +func NewNumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberContext { + var p = new(NumberContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_number + + return p +} + +func (s *NumberContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumberContext) CopyAll(ctx *NumberContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *NumberContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type DecimalLiteralContext struct { + NumberContext +} + +func NewDecimalLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DecimalLiteralContext { + var p = new(DecimalLiteralContext) + + InitEmptyNumberContext(&p.NumberContext) + p.parser = parser + p.CopyAll(ctx.(*NumberContext)) + + return p +} + +func (s *DecimalLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DecimalLiteralContext) EXPONENT_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserEXPONENT_VALUE, 0) +} + +func (s *DecimalLiteralContext) DECIMAL_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMAL_VALUE, 0) +} + +func (s *DecimalLiteralContext) SUBTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, 0) +} + +func (s *DecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterDecimalLiteral(s) + } +} + +func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitDecimalLiteral(s) + } +} + +func (s *DecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitDecimalLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +type IntegerLiteralContext struct { + NumberContext +} + +func NewIntegerLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntegerLiteralContext { + var p = new(IntegerLiteralContext) + + InitEmptyNumberContext(&p.NumberContext) + p.parser = parser + p.CopyAll(ctx.(*NumberContext)) + + return p +} + +func (s *IntegerLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IntegerLiteralContext) INTEGER_VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserINTEGER_VALUE, 0) +} + +func (s *IntegerLiteralContext) SUBTRACT() antlr.TerminalNode { + return s.GetToken(DorisParserSUBTRACT, 0) +} + +func (s *IntegerLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterIntegerLiteral(s) + } +} + +func (s *IntegerLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitIntegerLiteral(s) + } +} + +func (s *IntegerLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitIntegerLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) Number() (localctx INumberContext) { + localctx = NewNumberContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, DorisParserRULE_number) + var _la int + + p.SetState(6769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 958, p.GetParserRuleContext()) { + case 1: + localctx = NewIntegerLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + p.SetState(6762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSUBTRACT { + { + p.SetState(6761) + p.Match(DorisParserSUBTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6764) + p.Match(DorisParserINTEGER_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewDecimalLiteralContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + p.SetState(6766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == DorisParserSUBTRACT { + { + p.SetState(6765) + p.Match(DorisParserSUBTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6768) + _la = p.GetTokenStream().LA(1) + + if !(_la == DorisParserEXPONENT_VALUE || _la == DorisParserDECIMAL_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INonReservedContext is an interface to support dynamic dispatch. +type INonReservedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIONS() antlr.TerminalNode + AFTER() antlr.TerminalNode + AGG_STATE() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ALIAS() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + ANALYZED() antlr.TerminalNode + ANN() antlr.TerminalNode + ARRAY() antlr.TerminalNode + AT() antlr.TerminalNode + AUTHORS() antlr.TerminalNode + AUTO_INCREMENT() antlr.TerminalNode + BACKENDS() antlr.TerminalNode + BACKUP() antlr.TerminalNode + BEGIN() antlr.TerminalNode + BELONG() antlr.TerminalNode + BIN() antlr.TerminalNode + BITAND() antlr.TerminalNode + BITMAP() antlr.TerminalNode + BITMAP_EMPTY() antlr.TerminalNode + BITMAP_UNION() antlr.TerminalNode + BITOR() antlr.TerminalNode + BITXOR() antlr.TerminalNode + BLOB() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + BRANCH() antlr.TerminalNode + BRIEF() antlr.TerminalNode + BROKER() antlr.TerminalNode + BUCKETS() antlr.TerminalNode + BUILD() antlr.TerminalNode + BUILTIN() antlr.TerminalNode + BULK() antlr.TerminalNode + CACHE() antlr.TerminalNode + CACHED() antlr.TerminalNode + CALL() antlr.TerminalNode + CATALOG() antlr.TerminalNode + CATALOGS() antlr.TerminalNode + CHAIN() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARSET() antlr.TerminalNode + CHECK() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CLUSTERS() antlr.TerminalNode + COLLATION() antlr.TerminalNode + COLLECT() antlr.TerminalNode + COLOCATE() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COMMENT() antlr.TerminalNode + COMMENT_START() antlr.TerminalNode + COMMIT() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + COMPACT() antlr.TerminalNode + COMPLETE() antlr.TerminalNode + COMPRESS_TYPE() antlr.TerminalNode + COMPUTE() antlr.TerminalNode + CONDITIONS() antlr.TerminalNode + CONFIG() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + CONNECTION_ID() antlr.TerminalNode + CONSISTENT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + CONVERT() antlr.TerminalNode + CONVERT_LSC() antlr.TerminalNode + COPY() antlr.TerminalNode + COUNT() antlr.TerminalNode + CREATION() antlr.TerminalNode + CRON() antlr.TerminalNode + CURRENT_CATALOG() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + CURRENT_TIME() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + DATA() antlr.TerminalNode + DATE() antlr.TerminalNode + DATETIME() antlr.TerminalNode + DATETIMEV1() antlr.TerminalNode + DATETIMEV2() antlr.TerminalNode + DATEV1() antlr.TerminalNode + DATEV2() antlr.TerminalNode + DAY() antlr.TerminalNode + DAYS() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DECIMALV2() antlr.TerminalNode + DECIMALV3() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + DEMAND() antlr.TerminalNode + DIAGNOSE() antlr.TerminalNode + DIAGNOSIS() antlr.TerminalNode + DICTIONARIES() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + DISTINCTPC() antlr.TerminalNode + DISTINCTPCSA() antlr.TerminalNode + DO() antlr.TerminalNode + DORIS_INTERNAL_TABLE_ID() antlr.TerminalNode + DUAL() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + E() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + ENCRYPTKEY() antlr.TerminalNode + ENCRYPTKEYS() antlr.TerminalNode + END() antlr.TerminalNode + ENDS() antlr.TerminalNode + ENGINE() antlr.TerminalNode + ENGINES() antlr.TerminalNode + ERRORS() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + EVENTS() antlr.TerminalNode + EVERY() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + EXPIRED() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + FAST() antlr.TerminalNode + FEATURE() antlr.TerminalNode + FIELDS() antlr.TerminalNode + FILE() antlr.TerminalNode + FILTER() antlr.TerminalNode + FIRST() antlr.TerminalNode + FORMAT() antlr.TerminalNode + FREE() antlr.TerminalNode + FRONTENDS() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + GENERATED() antlr.TerminalNode + GET_FORMAT() antlr.TerminalNode + GENERIC() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GRAPH() antlr.TerminalNode + GROUPING() antlr.TerminalNode + GROUPS() antlr.TerminalNode + GROUP_CONCAT() antlr.TerminalNode + HASH() antlr.TerminalNode + HASH_MAP() antlr.TerminalNode + HDFS() antlr.TerminalNode + HELP() antlr.TerminalNode + HINT_END() antlr.TerminalNode + HINT_START() antlr.TerminalNode + HISTOGRAM() antlr.TerminalNode + HLL_UNION() antlr.TerminalNode + HOSTNAME() antlr.TerminalNode + HOTSPOT() antlr.TerminalNode + HOUR() antlr.TerminalNode + HOURS() antlr.TerminalNode + HUB() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + IGNORE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INSERT() antlr.TerminalNode + INVERTED() antlr.TerminalNode + IP_TRIE() antlr.TerminalNode + IPV4() antlr.TerminalNode + IPV6() antlr.TerminalNode + IS_NOT_NULL_PRED() antlr.TerminalNode + IS_NULL_PRED() antlr.TerminalNode + ISNULL() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + JOB() antlr.TerminalNode + JOBS() antlr.TerminalNode + JSON() antlr.TerminalNode + JSONB() antlr.TerminalNode + LABEL() antlr.TerminalNode + LAST() antlr.TerminalNode + LDAP() antlr.TerminalNode + LDAP_ADMIN_PASSWORD() antlr.TerminalNode + LEFT_BRACE() antlr.TerminalNode + LESS() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LINES() antlr.TerminalNode + LINK() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + LOCATION() antlr.TerminalNode + LOCK() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + MANUAL() antlr.TerminalNode + MAP() antlr.TerminalNode + MATCHED() antlr.TerminalNode + MATCH_ALL() antlr.TerminalNode + MATCH_ANY() antlr.TerminalNode + MATCH_PHRASE() antlr.TerminalNode + MATCH_PHRASE_EDGE() antlr.TerminalNode + MATCH_PHRASE_PREFIX() antlr.TerminalNode + MATCH_REGEXP() antlr.TerminalNode + MATCH_NAME() antlr.TerminalNode + MATCH_NAME_GLOB() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MAX() antlr.TerminalNode + MEMO() antlr.TerminalNode + MERGE() antlr.TerminalNode + MID() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + MIGRATIONS() antlr.TerminalNode + MIN() antlr.TerminalNode + MINUTE() antlr.TerminalNode + MINUTES() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MONTH() antlr.TerminalNode + MTMV() antlr.TerminalNode + NAME() antlr.TerminalNode + NAMES() antlr.TerminalNode + NEGATIVE() antlr.TerminalNode + NEVER() antlr.TerminalNode + NEXT() antlr.TerminalNode + NGRAM_BF() antlr.TerminalNode + NO() antlr.TerminalNode + NON_NULLABLE() antlr.TerminalNode + NULLS() antlr.TerminalNode + OF() antlr.TerminalNode + OFF() antlr.TerminalNode + OFFSET() antlr.TerminalNode + ONLY() antlr.TerminalNode + OPEN() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + OPTIMIZED() antlr.TerminalNode + PARAMETER() antlr.TerminalNode + PARSED() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PASSWORD_EXPIRE() antlr.TerminalNode + PASSWORD_HISTORY() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + PASSWORD_REUSE() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + PATH() antlr.TerminalNode + PAUSE() antlr.TerminalNode + PERCENT() antlr.TerminalNode + PERIOD() antlr.TerminalNode + PERMISSIVE() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + PI() antlr.TerminalNode + PLAN() antlr.TerminalNode + PLUGIN() antlr.TerminalNode + PLUGINS() antlr.TerminalNode + POLICY() antlr.TerminalNode + POSITION() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROC() antlr.TerminalNode + PROCESS() antlr.TerminalNode + PROCESSLIST() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PROPERTIES() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + QUANTILE_STATE() antlr.TerminalNode + QUANTILE_UNION() antlr.TerminalNode + QUARTER() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUOTA() antlr.TerminalNode + QUALIFY() antlr.TerminalNode + QUEUED() antlr.TerminalNode + RANDOM() antlr.TerminalNode + RECENT() antlr.TerminalNode + RECOVER() antlr.TerminalNode + RECYCLE() antlr.TerminalNode + REFRESH() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REPLACE_IF_NOT_NULL() antlr.TerminalNode + REPLAYER() antlr.TerminalNode + REPOSITORIES() antlr.TerminalNode + REPOSITORY() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + RESOURCES() antlr.TerminalNode + RESTORE() antlr.TerminalNode + RESTRICTIVE() antlr.TerminalNode + RESUME() antlr.TerminalNode + RETAIN() antlr.TerminalNode + RETENTION() antlr.TerminalNode + RETURNS() antlr.TerminalNode + REWRITTEN() antlr.TerminalNode + RIGHT_BRACE() antlr.TerminalNode + RLIKE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROOT() antlr.TerminalNode + ROTATE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + S3() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SECOND() antlr.TerminalNode + SEPARATOR() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SET_SESSION_VARIABLE() antlr.TerminalNode + SESSION() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + SHAPE() antlr.TerminalNode + SKEW() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SNAPSHOTS() antlr.TerminalNode + SONAME() antlr.TerminalNode + SPLIT() antlr.TerminalNode + SQL() antlr.TerminalNode + STAGE() antlr.TerminalNode + STAGES() antlr.TerminalNode + START() antlr.TerminalNode + STARTS() antlr.TerminalNode + STATS() antlr.TerminalNode + STATUS() antlr.TerminalNode + STOP() antlr.TerminalNode + STORAGE() antlr.TerminalNode + STREAM() antlr.TerminalNode + STREAMING() antlr.TerminalNode + STRING() antlr.TerminalNode + STRUCT() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + SUM() antlr.TerminalNode + TABLES() antlr.TerminalNode + TAG() antlr.TerminalNode + TASK() antlr.TerminalNode + TASKS() antlr.TerminalNode + TDE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TEXT() antlr.TerminalNode + THAN() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + TREE() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + TYPE() antlr.TerminalNode + TYPES() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + UNSET() antlr.TerminalNode + UP() antlr.TerminalNode + USER() antlr.TerminalNode + VALUE() antlr.TerminalNode + VARBINARY() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + VARIABLES() antlr.TerminalNode + VARIANT() antlr.TerminalNode + VAULT() antlr.TerminalNode + VAULTS() antlr.TerminalNode + VERBOSE() antlr.TerminalNode + VERSION() antlr.TerminalNode + VIEW() antlr.TerminalNode + VIEWS() antlr.TerminalNode + WARM() antlr.TerminalNode + WARNINGS() antlr.TerminalNode + WEEK() antlr.TerminalNode + WORK() antlr.TerminalNode + YEAR() antlr.TerminalNode + + // IsNonReservedContext differentiates from other interfaces. + IsNonReservedContext() +} + +type NonReservedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNonReservedContext() *NonReservedContext { + var p = new(NonReservedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_nonReserved + return p +} + +func InitEmptyNonReservedContext(p *NonReservedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = DorisParserRULE_nonReserved +} + +func (*NonReservedContext) IsNonReservedContext() {} + +func NewNonReservedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonReservedContext { + var p = new(NonReservedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = DorisParserRULE_nonReserved + + return p +} + +func (s *NonReservedContext) GetParser() antlr.Parser { return s.parser } + +func (s *NonReservedContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(DorisParserACTIONS, 0) +} + +func (s *NonReservedContext) AFTER() antlr.TerminalNode { + return s.GetToken(DorisParserAFTER, 0) +} + +func (s *NonReservedContext) AGG_STATE() antlr.TerminalNode { + return s.GetToken(DorisParserAGG_STATE, 0) +} + +func (s *NonReservedContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(DorisParserAGGREGATE, 0) +} + +func (s *NonReservedContext) ALIAS() antlr.TerminalNode { + return s.GetToken(DorisParserALIAS, 0) +} + +func (s *NonReservedContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(DorisParserALWAYS, 0) +} + +func (s *NonReservedContext) ANALYZED() antlr.TerminalNode { + return s.GetToken(DorisParserANALYZED, 0) +} + +func (s *NonReservedContext) ANN() antlr.TerminalNode { + return s.GetToken(DorisParserANN, 0) +} + +func (s *NonReservedContext) ARRAY() antlr.TerminalNode { + return s.GetToken(DorisParserARRAY, 0) +} + +func (s *NonReservedContext) AT() antlr.TerminalNode { + return s.GetToken(DorisParserAT, 0) +} + +func (s *NonReservedContext) AUTHORS() antlr.TerminalNode { + return s.GetToken(DorisParserAUTHORS, 0) +} + +func (s *NonReservedContext) AUTO_INCREMENT() antlr.TerminalNode { + return s.GetToken(DorisParserAUTO_INCREMENT, 0) +} + +func (s *NonReservedContext) BACKENDS() antlr.TerminalNode { + return s.GetToken(DorisParserBACKENDS, 0) +} + +func (s *NonReservedContext) BACKUP() antlr.TerminalNode { + return s.GetToken(DorisParserBACKUP, 0) +} + +func (s *NonReservedContext) BEGIN() antlr.TerminalNode { + return s.GetToken(DorisParserBEGIN, 0) +} + +func (s *NonReservedContext) BELONG() antlr.TerminalNode { + return s.GetToken(DorisParserBELONG, 0) +} + +func (s *NonReservedContext) BIN() antlr.TerminalNode { + return s.GetToken(DorisParserBIN, 0) +} + +func (s *NonReservedContext) BITAND() antlr.TerminalNode { + return s.GetToken(DorisParserBITAND, 0) +} + +func (s *NonReservedContext) BITMAP() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP, 0) +} + +func (s *NonReservedContext) BITMAP_EMPTY() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP_EMPTY, 0) +} + +func (s *NonReservedContext) BITMAP_UNION() antlr.TerminalNode { + return s.GetToken(DorisParserBITMAP_UNION, 0) +} + +func (s *NonReservedContext) BITOR() antlr.TerminalNode { + return s.GetToken(DorisParserBITOR, 0) +} + +func (s *NonReservedContext) BITXOR() antlr.TerminalNode { + return s.GetToken(DorisParserBITXOR, 0) +} + +func (s *NonReservedContext) BLOB() antlr.TerminalNode { + return s.GetToken(DorisParserBLOB, 0) +} + +func (s *NonReservedContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(DorisParserBOOLEAN, 0) +} + +func (s *NonReservedContext) BRANCH() antlr.TerminalNode { + return s.GetToken(DorisParserBRANCH, 0) +} + +func (s *NonReservedContext) BRIEF() antlr.TerminalNode { + return s.GetToken(DorisParserBRIEF, 0) +} + +func (s *NonReservedContext) BROKER() antlr.TerminalNode { + return s.GetToken(DorisParserBROKER, 0) +} + +func (s *NonReservedContext) BUCKETS() antlr.TerminalNode { + return s.GetToken(DorisParserBUCKETS, 0) +} + +func (s *NonReservedContext) BUILD() antlr.TerminalNode { + return s.GetToken(DorisParserBUILD, 0) +} + +func (s *NonReservedContext) BUILTIN() antlr.TerminalNode { + return s.GetToken(DorisParserBUILTIN, 0) +} + +func (s *NonReservedContext) BULK() antlr.TerminalNode { + return s.GetToken(DorisParserBULK, 0) +} + +func (s *NonReservedContext) CACHE() antlr.TerminalNode { + return s.GetToken(DorisParserCACHE, 0) +} + +func (s *NonReservedContext) CACHED() antlr.TerminalNode { + return s.GetToken(DorisParserCACHED, 0) +} + +func (s *NonReservedContext) CALL() antlr.TerminalNode { + return s.GetToken(DorisParserCALL, 0) +} + +func (s *NonReservedContext) CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOG, 0) +} + +func (s *NonReservedContext) CATALOGS() antlr.TerminalNode { + return s.GetToken(DorisParserCATALOGS, 0) +} + +func (s *NonReservedContext) CHAIN() antlr.TerminalNode { + return s.GetToken(DorisParserCHAIN, 0) +} + +func (s *NonReservedContext) CHAR() antlr.TerminalNode { + return s.GetToken(DorisParserCHAR, 0) +} + +func (s *NonReservedContext) CHARSET() antlr.TerminalNode { + return s.GetToken(DorisParserCHARSET, 0) +} + +func (s *NonReservedContext) CHECK() antlr.TerminalNode { + return s.GetToken(DorisParserCHECK, 0) +} + +func (s *NonReservedContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTER, 0) +} + +func (s *NonReservedContext) CLUSTERS() antlr.TerminalNode { + return s.GetToken(DorisParserCLUSTERS, 0) +} + +func (s *NonReservedContext) COLLATION() antlr.TerminalNode { + return s.GetToken(DorisParserCOLLATION, 0) +} + +func (s *NonReservedContext) COLLECT() antlr.TerminalNode { + return s.GetToken(DorisParserCOLLECT, 0) +} + +func (s *NonReservedContext) COLOCATE() antlr.TerminalNode { + return s.GetToken(DorisParserCOLOCATE, 0) +} + +func (s *NonReservedContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(DorisParserCOLUMNS, 0) +} + +func (s *NonReservedContext) COMMENT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT, 0) +} + +func (s *NonReservedContext) COMMENT_START() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMENT_START, 0) +} + +func (s *NonReservedContext) COMMIT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMIT, 0) +} + +func (s *NonReservedContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(DorisParserCOMMITTED, 0) +} + +func (s *NonReservedContext) COMPACT() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPACT, 0) +} + +func (s *NonReservedContext) COMPLETE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPLETE, 0) +} + +func (s *NonReservedContext) COMPRESS_TYPE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPRESS_TYPE, 0) +} + +func (s *NonReservedContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(DorisParserCOMPUTE, 0) +} + +func (s *NonReservedContext) CONDITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserCONDITIONS, 0) +} + +func (s *NonReservedContext) CONFIG() antlr.TerminalNode { + return s.GetToken(DorisParserCONFIG, 0) +} + +func (s *NonReservedContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(DorisParserCONNECTION, 0) +} + +func (s *NonReservedContext) CONNECTION_ID() antlr.TerminalNode { + return s.GetToken(DorisParserCONNECTION_ID, 0) +} + +func (s *NonReservedContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(DorisParserCONSISTENT, 0) +} + +func (s *NonReservedContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(DorisParserCONSTRAINTS, 0) +} + +func (s *NonReservedContext) CONVERT() antlr.TerminalNode { + return s.GetToken(DorisParserCONVERT, 0) +} + +func (s *NonReservedContext) CONVERT_LSC() antlr.TerminalNode { + return s.GetToken(DorisParserCONVERT_LSC, 0) +} + +func (s *NonReservedContext) COPY() antlr.TerminalNode { + return s.GetToken(DorisParserCOPY, 0) +} + +func (s *NonReservedContext) COUNT() antlr.TerminalNode { + return s.GetToken(DorisParserCOUNT, 0) +} + +func (s *NonReservedContext) CREATION() antlr.TerminalNode { + return s.GetToken(DorisParserCREATION, 0) +} + +func (s *NonReservedContext) CRON() antlr.TerminalNode { + return s.GetToken(DorisParserCRON, 0) +} + +func (s *NonReservedContext) CURRENT_CATALOG() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_CATALOG, 0) +} + +func (s *NonReservedContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_DATE, 0) +} + +func (s *NonReservedContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_TIME, 0) +} + +func (s *NonReservedContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_TIMESTAMP, 0) +} + +func (s *NonReservedContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(DorisParserCURRENT_USER, 0) +} + +func (s *NonReservedContext) DATA() antlr.TerminalNode { + return s.GetToken(DorisParserDATA, 0) +} + +func (s *NonReservedContext) DATE() antlr.TerminalNode { + return s.GetToken(DorisParserDATE, 0) +} + +func (s *NonReservedContext) DATETIME() antlr.TerminalNode { + return s.GetToken(DorisParserDATETIME, 0) +} + +func (s *NonReservedContext) DATETIMEV1() antlr.TerminalNode { + return s.GetToken(DorisParserDATETIMEV1, 0) +} + +func (s *NonReservedContext) DATETIMEV2() antlr.TerminalNode { + return s.GetToken(DorisParserDATETIMEV2, 0) +} + +func (s *NonReservedContext) DATEV1() antlr.TerminalNode { + return s.GetToken(DorisParserDATEV1, 0) +} + +func (s *NonReservedContext) DATEV2() antlr.TerminalNode { + return s.GetToken(DorisParserDATEV2, 0) +} + +func (s *NonReservedContext) DAY() antlr.TerminalNode { + return s.GetToken(DorisParserDAY, 0) +} + +func (s *NonReservedContext) DAYS() antlr.TerminalNode { + return s.GetToken(DorisParserDAYS, 0) +} + +func (s *NonReservedContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMAL, 0) +} + +func (s *NonReservedContext) DECIMALV2() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMALV2, 0) +} + +func (s *NonReservedContext) DECIMALV3() antlr.TerminalNode { + return s.GetToken(DorisParserDECIMALV3, 0) +} + +func (s *NonReservedContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(DorisParserDEFERRED, 0) +} + +func (s *NonReservedContext) DEMAND() antlr.TerminalNode { + return s.GetToken(DorisParserDEMAND, 0) +} + +func (s *NonReservedContext) DIAGNOSE() antlr.TerminalNode { + return s.GetToken(DorisParserDIAGNOSE, 0) +} + +func (s *NonReservedContext) DIAGNOSIS() antlr.TerminalNode { + return s.GetToken(DorisParserDIAGNOSIS, 0) +} + +func (s *NonReservedContext) DICTIONARIES() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARIES, 0) +} + +func (s *NonReservedContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(DorisParserDICTIONARY, 0) +} + +func (s *NonReservedContext) DISTINCTPC() antlr.TerminalNode { + return s.GetToken(DorisParserDISTINCTPC, 0) +} + +func (s *NonReservedContext) DISTINCTPCSA() antlr.TerminalNode { + return s.GetToken(DorisParserDISTINCTPCSA, 0) +} + +func (s *NonReservedContext) DO() antlr.TerminalNode { + return s.GetToken(DorisParserDO, 0) +} + +func (s *NonReservedContext) DORIS_INTERNAL_TABLE_ID() antlr.TerminalNode { + return s.GetToken(DorisParserDORIS_INTERNAL_TABLE_ID, 0) +} + +func (s *NonReservedContext) DUAL() antlr.TerminalNode { + return s.GetToken(DorisParserDUAL, 0) +} + +func (s *NonReservedContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(DorisParserDYNAMIC, 0) +} + +func (s *NonReservedContext) E() antlr.TerminalNode { + return s.GetToken(DorisParserE, 0) +} + +func (s *NonReservedContext) ENABLE() antlr.TerminalNode { + return s.GetToken(DorisParserENABLE, 0) +} + +func (s *NonReservedContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTION, 0) +} + +func (s *NonReservedContext) ENCRYPTKEY() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTKEY, 0) +} + +func (s *NonReservedContext) ENCRYPTKEYS() antlr.TerminalNode { + return s.GetToken(DorisParserENCRYPTKEYS, 0) +} + +func (s *NonReservedContext) END() antlr.TerminalNode { + return s.GetToken(DorisParserEND, 0) +} + +func (s *NonReservedContext) ENDS() antlr.TerminalNode { + return s.GetToken(DorisParserENDS, 0) +} + +func (s *NonReservedContext) ENGINE() antlr.TerminalNode { + return s.GetToken(DorisParserENGINE, 0) +} + +func (s *NonReservedContext) ENGINES() antlr.TerminalNode { + return s.GetToken(DorisParserENGINES, 0) +} + +func (s *NonReservedContext) ERRORS() antlr.TerminalNode { + return s.GetToken(DorisParserERRORS, 0) +} + +func (s *NonReservedContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(DorisParserESCAPE, 0) +} + +func (s *NonReservedContext) EVENTS() antlr.TerminalNode { + return s.GetToken(DorisParserEVENTS, 0) +} + +func (s *NonReservedContext) EVERY() antlr.TerminalNode { + return s.GetToken(DorisParserEVERY, 0) +} + +func (s *NonReservedContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(DorisParserEXCLUDE, 0) +} + +func (s *NonReservedContext) EXPIRED() antlr.TerminalNode { + return s.GetToken(DorisParserEXPIRED, 0) +} + +func (s *NonReservedContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(DorisParserEXTERNAL, 0) +} + +func (s *NonReservedContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(DorisParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *NonReservedContext) FAST() antlr.TerminalNode { + return s.GetToken(DorisParserFAST, 0) +} + +func (s *NonReservedContext) FEATURE() antlr.TerminalNode { + return s.GetToken(DorisParserFEATURE, 0) +} + +func (s *NonReservedContext) FIELDS() antlr.TerminalNode { + return s.GetToken(DorisParserFIELDS, 0) +} + +func (s *NonReservedContext) FILE() antlr.TerminalNode { + return s.GetToken(DorisParserFILE, 0) +} + +func (s *NonReservedContext) FILTER() antlr.TerminalNode { + return s.GetToken(DorisParserFILTER, 0) +} + +func (s *NonReservedContext) FIRST() antlr.TerminalNode { + return s.GetToken(DorisParserFIRST, 0) +} + +func (s *NonReservedContext) FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserFORMAT, 0) +} + +func (s *NonReservedContext) FREE() antlr.TerminalNode { + return s.GetToken(DorisParserFREE, 0) +} + +func (s *NonReservedContext) FRONTENDS() antlr.TerminalNode { + return s.GetToken(DorisParserFRONTENDS, 0) +} + +func (s *NonReservedContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(DorisParserFUNCTION, 0) +} + +func (s *NonReservedContext) GENERATED() antlr.TerminalNode { + return s.GetToken(DorisParserGENERATED, 0) +} + +func (s *NonReservedContext) GET_FORMAT() antlr.TerminalNode { + return s.GetToken(DorisParserGET_FORMAT, 0) +} + +func (s *NonReservedContext) GENERIC() antlr.TerminalNode { + return s.GetToken(DorisParserGENERIC, 0) +} + +func (s *NonReservedContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(DorisParserGLOBAL, 0) +} + +func (s *NonReservedContext) GRAPH() antlr.TerminalNode { + return s.GetToken(DorisParserGRAPH, 0) +} + +func (s *NonReservedContext) GROUPING() antlr.TerminalNode { + return s.GetToken(DorisParserGROUPING, 0) +} + +func (s *NonReservedContext) GROUPS() antlr.TerminalNode { + return s.GetToken(DorisParserGROUPS, 0) +} + +func (s *NonReservedContext) GROUP_CONCAT() antlr.TerminalNode { + return s.GetToken(DorisParserGROUP_CONCAT, 0) +} + +func (s *NonReservedContext) HASH() antlr.TerminalNode { + return s.GetToken(DorisParserHASH, 0) +} + +func (s *NonReservedContext) HASH_MAP() antlr.TerminalNode { + return s.GetToken(DorisParserHASH_MAP, 0) +} + +func (s *NonReservedContext) HDFS() antlr.TerminalNode { + return s.GetToken(DorisParserHDFS, 0) +} + +func (s *NonReservedContext) HELP() antlr.TerminalNode { + return s.GetToken(DorisParserHELP, 0) +} + +func (s *NonReservedContext) HINT_END() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_END, 0) +} + +func (s *NonReservedContext) HINT_START() antlr.TerminalNode { + return s.GetToken(DorisParserHINT_START, 0) +} + +func (s *NonReservedContext) HISTOGRAM() antlr.TerminalNode { + return s.GetToken(DorisParserHISTOGRAM, 0) +} + +func (s *NonReservedContext) HLL_UNION() antlr.TerminalNode { + return s.GetToken(DorisParserHLL_UNION, 0) +} + +func (s *NonReservedContext) HOSTNAME() antlr.TerminalNode { + return s.GetToken(DorisParserHOSTNAME, 0) +} + +func (s *NonReservedContext) HOTSPOT() antlr.TerminalNode { + return s.GetToken(DorisParserHOTSPOT, 0) +} + +func (s *NonReservedContext) HOUR() antlr.TerminalNode { + return s.GetToken(DorisParserHOUR, 0) +} + +func (s *NonReservedContext) HOURS() antlr.TerminalNode { + return s.GetToken(DorisParserHOURS, 0) +} + +func (s *NonReservedContext) HUB() antlr.TerminalNode { + return s.GetToken(DorisParserHUB, 0) +} + +func (s *NonReservedContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(DorisParserIDENTIFIED, 0) +} + +func (s *NonReservedContext) IGNORE() antlr.TerminalNode { + return s.GetToken(DorisParserIGNORE, 0) +} + +func (s *NonReservedContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(DorisParserIMMEDIATE, 0) +} + +func (s *NonReservedContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(DorisParserINCREMENTAL, 0) +} + +func (s *NonReservedContext) INDEXES() antlr.TerminalNode { + return s.GetToken(DorisParserINDEXES, 0) +} + +func (s *NonReservedContext) INSERT() antlr.TerminalNode { + return s.GetToken(DorisParserINSERT, 0) +} + +func (s *NonReservedContext) INVERTED() antlr.TerminalNode { + return s.GetToken(DorisParserINVERTED, 0) +} + +func (s *NonReservedContext) IP_TRIE() antlr.TerminalNode { + return s.GetToken(DorisParserIP_TRIE, 0) +} + +func (s *NonReservedContext) IPV4() antlr.TerminalNode { + return s.GetToken(DorisParserIPV4, 0) +} + +func (s *NonReservedContext) IPV6() antlr.TerminalNode { + return s.GetToken(DorisParserIPV6, 0) +} + +func (s *NonReservedContext) IS_NOT_NULL_PRED() antlr.TerminalNode { + return s.GetToken(DorisParserIS_NOT_NULL_PRED, 0) +} + +func (s *NonReservedContext) IS_NULL_PRED() antlr.TerminalNode { + return s.GetToken(DorisParserIS_NULL_PRED, 0) +} + +func (s *NonReservedContext) ISNULL() antlr.TerminalNode { + return s.GetToken(DorisParserISNULL, 0) +} + +func (s *NonReservedContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(DorisParserISOLATION, 0) +} + +func (s *NonReservedContext) JOB() antlr.TerminalNode { + return s.GetToken(DorisParserJOB, 0) +} + +func (s *NonReservedContext) JOBS() antlr.TerminalNode { + return s.GetToken(DorisParserJOBS, 0) +} + +func (s *NonReservedContext) JSON() antlr.TerminalNode { + return s.GetToken(DorisParserJSON, 0) +} + +func (s *NonReservedContext) JSONB() antlr.TerminalNode { + return s.GetToken(DorisParserJSONB, 0) +} + +func (s *NonReservedContext) LABEL() antlr.TerminalNode { + return s.GetToken(DorisParserLABEL, 0) +} + +func (s *NonReservedContext) LAST() antlr.TerminalNode { + return s.GetToken(DorisParserLAST, 0) +} + +func (s *NonReservedContext) LDAP() antlr.TerminalNode { + return s.GetToken(DorisParserLDAP, 0) +} + +func (s *NonReservedContext) LDAP_ADMIN_PASSWORD() antlr.TerminalNode { + return s.GetToken(DorisParserLDAP_ADMIN_PASSWORD, 0) +} + +func (s *NonReservedContext) LEFT_BRACE() antlr.TerminalNode { + return s.GetToken(DorisParserLEFT_BRACE, 0) +} + +func (s *NonReservedContext) LESS() antlr.TerminalNode { + return s.GetToken(DorisParserLESS, 0) +} + +func (s *NonReservedContext) LEVEL() antlr.TerminalNode { + return s.GetToken(DorisParserLEVEL, 0) +} + +func (s *NonReservedContext) LINES() antlr.TerminalNode { + return s.GetToken(DorisParserLINES, 0) +} + +func (s *NonReservedContext) LINK() antlr.TerminalNode { + return s.GetToken(DorisParserLINK, 0) +} + +func (s *NonReservedContext) LOCAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOCAL, 0) +} + +func (s *NonReservedContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(DorisParserLOCALTIME, 0) +} + +func (s *NonReservedContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserLOCALTIMESTAMP, 0) +} + +func (s *NonReservedContext) LOCATION() antlr.TerminalNode { + return s.GetToken(DorisParserLOCATION, 0) +} + +func (s *NonReservedContext) LOCK() antlr.TerminalNode { + return s.GetToken(DorisParserLOCK, 0) +} + +func (s *NonReservedContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(DorisParserLOGICAL, 0) +} + +func (s *NonReservedContext) MANUAL() antlr.TerminalNode { + return s.GetToken(DorisParserMANUAL, 0) +} + +func (s *NonReservedContext) MAP() antlr.TerminalNode { + return s.GetToken(DorisParserMAP, 0) +} + +func (s *NonReservedContext) MATCHED() antlr.TerminalNode { + return s.GetToken(DorisParserMATCHED, 0) +} + +func (s *NonReservedContext) MATCH_ALL() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_ALL, 0) +} + +func (s *NonReservedContext) MATCH_ANY() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_ANY, 0) +} + +func (s *NonReservedContext) MATCH_PHRASE() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_PHRASE, 0) +} + +func (s *NonReservedContext) MATCH_PHRASE_EDGE() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_PHRASE_EDGE, 0) +} + +func (s *NonReservedContext) MATCH_PHRASE_PREFIX() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_PHRASE_PREFIX, 0) +} + +func (s *NonReservedContext) MATCH_REGEXP() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_REGEXP, 0) +} + +func (s *NonReservedContext) MATCH_NAME() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_NAME, 0) +} + +func (s *NonReservedContext) MATCH_NAME_GLOB() antlr.TerminalNode { + return s.GetToken(DorisParserMATCH_NAME_GLOB, 0) +} + +func (s *NonReservedContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(DorisParserMATERIALIZED, 0) +} + +func (s *NonReservedContext) MAX() antlr.TerminalNode { + return s.GetToken(DorisParserMAX, 0) +} + +func (s *NonReservedContext) MEMO() antlr.TerminalNode { + return s.GetToken(DorisParserMEMO, 0) +} + +func (s *NonReservedContext) MERGE() antlr.TerminalNode { + return s.GetToken(DorisParserMERGE, 0) +} + +func (s *NonReservedContext) MID() antlr.TerminalNode { + return s.GetToken(DorisParserMID, 0) +} + +func (s *NonReservedContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(DorisParserMIGRATE, 0) +} + +func (s *NonReservedContext) MIGRATIONS() antlr.TerminalNode { + return s.GetToken(DorisParserMIGRATIONS, 0) +} + +func (s *NonReservedContext) MIN() antlr.TerminalNode { + return s.GetToken(DorisParserMIN, 0) +} + +func (s *NonReservedContext) MINUTE() antlr.TerminalNode { + return s.GetToken(DorisParserMINUTE, 0) +} + +func (s *NonReservedContext) MINUTES() antlr.TerminalNode { + return s.GetToken(DorisParserMINUTES, 0) +} + +func (s *NonReservedContext) MODIFY() antlr.TerminalNode { + return s.GetToken(DorisParserMODIFY, 0) +} + +func (s *NonReservedContext) MONTH() antlr.TerminalNode { + return s.GetToken(DorisParserMONTH, 0) +} + +func (s *NonReservedContext) MTMV() antlr.TerminalNode { + return s.GetToken(DorisParserMTMV, 0) +} + +func (s *NonReservedContext) NAME() antlr.TerminalNode { + return s.GetToken(DorisParserNAME, 0) +} + +func (s *NonReservedContext) NAMES() antlr.TerminalNode { + return s.GetToken(DorisParserNAMES, 0) +} + +func (s *NonReservedContext) NEGATIVE() antlr.TerminalNode { + return s.GetToken(DorisParserNEGATIVE, 0) +} + +func (s *NonReservedContext) NEVER() antlr.TerminalNode { + return s.GetToken(DorisParserNEVER, 0) +} + +func (s *NonReservedContext) NEXT() antlr.TerminalNode { + return s.GetToken(DorisParserNEXT, 0) +} + +func (s *NonReservedContext) NGRAM_BF() antlr.TerminalNode { + return s.GetToken(DorisParserNGRAM_BF, 0) +} + +func (s *NonReservedContext) NO() antlr.TerminalNode { + return s.GetToken(DorisParserNO, 0) +} + +func (s *NonReservedContext) NON_NULLABLE() antlr.TerminalNode { + return s.GetToken(DorisParserNON_NULLABLE, 0) +} + +func (s *NonReservedContext) NULLS() antlr.TerminalNode { + return s.GetToken(DorisParserNULLS, 0) +} + +func (s *NonReservedContext) OF() antlr.TerminalNode { + return s.GetToken(DorisParserOF, 0) +} + +func (s *NonReservedContext) OFF() antlr.TerminalNode { + return s.GetToken(DorisParserOFF, 0) +} + +func (s *NonReservedContext) OFFSET() antlr.TerminalNode { + return s.GetToken(DorisParserOFFSET, 0) +} + +func (s *NonReservedContext) ONLY() antlr.TerminalNode { + return s.GetToken(DorisParserONLY, 0) +} + +func (s *NonReservedContext) OPEN() antlr.TerminalNode { + return s.GetToken(DorisParserOPEN, 0) +} + +func (s *NonReservedContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(DorisParserOPTIMIZE, 0) +} + +func (s *NonReservedContext) OPTIMIZED() antlr.TerminalNode { + return s.GetToken(DorisParserOPTIMIZED, 0) +} + +func (s *NonReservedContext) PARAMETER() antlr.TerminalNode { + return s.GetToken(DorisParserPARAMETER, 0) +} + +func (s *NonReservedContext) PARSED() antlr.TerminalNode { + return s.GetToken(DorisParserPARSED, 0) +} + +func (s *NonReservedContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD, 0) +} + +func (s *NonReservedContext) PASSWORD_EXPIRE() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_EXPIRE, 0) +} + +func (s *NonReservedContext) PASSWORD_HISTORY() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_HISTORY, 0) +} + +func (s *NonReservedContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_LOCK_TIME, 0) +} + +func (s *NonReservedContext) PASSWORD_REUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPASSWORD_REUSE, 0) +} + +func (s *NonReservedContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(DorisParserPARTITIONS, 0) +} + +func (s *NonReservedContext) PATH() antlr.TerminalNode { + return s.GetToken(DorisParserPATH, 0) +} + +func (s *NonReservedContext) PAUSE() antlr.TerminalNode { + return s.GetToken(DorisParserPAUSE, 0) +} + +func (s *NonReservedContext) PERCENT() antlr.TerminalNode { + return s.GetToken(DorisParserPERCENT, 0) +} + +func (s *NonReservedContext) PERIOD() antlr.TerminalNode { + return s.GetToken(DorisParserPERIOD, 0) +} + +func (s *NonReservedContext) PERMISSIVE() antlr.TerminalNode { + return s.GetToken(DorisParserPERMISSIVE, 0) +} + +func (s *NonReservedContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(DorisParserPHYSICAL, 0) +} + +func (s *NonReservedContext) PI() antlr.TerminalNode { + return s.GetToken(DorisParserPI, 0) +} + +func (s *NonReservedContext) PLAN() antlr.TerminalNode { + return s.GetToken(DorisParserPLAN, 0) +} + +func (s *NonReservedContext) PLUGIN() antlr.TerminalNode { + return s.GetToken(DorisParserPLUGIN, 0) +} + +func (s *NonReservedContext) PLUGINS() antlr.TerminalNode { + return s.GetToken(DorisParserPLUGINS, 0) +} + +func (s *NonReservedContext) POLICY() antlr.TerminalNode { + return s.GetToken(DorisParserPOLICY, 0) +} + +func (s *NonReservedContext) POSITION() antlr.TerminalNode { + return s.GetToken(DorisParserPOSITION, 0) +} + +func (s *NonReservedContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(DorisParserPRIVILEGES, 0) +} + +func (s *NonReservedContext) PROC() antlr.TerminalNode { + return s.GetToken(DorisParserPROC, 0) +} + +func (s *NonReservedContext) PROCESS() antlr.TerminalNode { + return s.GetToken(DorisParserPROCESS, 0) +} + +func (s *NonReservedContext) PROCESSLIST() antlr.TerminalNode { + return s.GetToken(DorisParserPROCESSLIST, 0) +} + +func (s *NonReservedContext) PROFILE() antlr.TerminalNode { + return s.GetToken(DorisParserPROFILE, 0) +} + +func (s *NonReservedContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTIES, 0) +} + +func (s *NonReservedContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(DorisParserPROPERTY, 0) +} + +func (s *NonReservedContext) QUANTILE_STATE() antlr.TerminalNode { + return s.GetToken(DorisParserQUANTILE_STATE, 0) +} + +func (s *NonReservedContext) QUANTILE_UNION() antlr.TerminalNode { + return s.GetToken(DorisParserQUANTILE_UNION, 0) +} + +func (s *NonReservedContext) QUARTER() antlr.TerminalNode { + return s.GetToken(DorisParserQUARTER, 0) +} + +func (s *NonReservedContext) QUERY() antlr.TerminalNode { + return s.GetToken(DorisParserQUERY, 0) +} + +func (s *NonReservedContext) QUOTA() antlr.TerminalNode { + return s.GetToken(DorisParserQUOTA, 0) +} + +func (s *NonReservedContext) QUALIFY() antlr.TerminalNode { + return s.GetToken(DorisParserQUALIFY, 0) +} + +func (s *NonReservedContext) QUEUED() antlr.TerminalNode { + return s.GetToken(DorisParserQUEUED, 0) +} + +func (s *NonReservedContext) RANDOM() antlr.TerminalNode { + return s.GetToken(DorisParserRANDOM, 0) +} + +func (s *NonReservedContext) RECENT() antlr.TerminalNode { + return s.GetToken(DorisParserRECENT, 0) +} + +func (s *NonReservedContext) RECOVER() antlr.TerminalNode { + return s.GetToken(DorisParserRECOVER, 0) +} + +func (s *NonReservedContext) RECYCLE() antlr.TerminalNode { + return s.GetToken(DorisParserRECYCLE, 0) +} + +func (s *NonReservedContext) REFRESH() antlr.TerminalNode { + return s.GetToken(DorisParserREFRESH, 0) +} + +func (s *NonReservedContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(DorisParserREPEATABLE, 0) +} + +func (s *NonReservedContext) REPLACE() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE, 0) +} + +func (s *NonReservedContext) REPLACE_IF_NOT_NULL() antlr.TerminalNode { + return s.GetToken(DorisParserREPLACE_IF_NOT_NULL, 0) +} + +func (s *NonReservedContext) REPLAYER() antlr.TerminalNode { + return s.GetToken(DorisParserREPLAYER, 0) +} + +func (s *NonReservedContext) REPOSITORIES() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORIES, 0) +} + +func (s *NonReservedContext) REPOSITORY() antlr.TerminalNode { + return s.GetToken(DorisParserREPOSITORY, 0) +} + +func (s *NonReservedContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCE, 0) +} + +func (s *NonReservedContext) RESOURCES() antlr.TerminalNode { + return s.GetToken(DorisParserRESOURCES, 0) +} + +func (s *NonReservedContext) RESTORE() antlr.TerminalNode { + return s.GetToken(DorisParserRESTORE, 0) +} + +func (s *NonReservedContext) RESTRICTIVE() antlr.TerminalNode { + return s.GetToken(DorisParserRESTRICTIVE, 0) +} + +func (s *NonReservedContext) RESUME() antlr.TerminalNode { + return s.GetToken(DorisParserRESUME, 0) +} + +func (s *NonReservedContext) RETAIN() antlr.TerminalNode { + return s.GetToken(DorisParserRETAIN, 0) +} + +func (s *NonReservedContext) RETENTION() antlr.TerminalNode { + return s.GetToken(DorisParserRETENTION, 0) +} + +func (s *NonReservedContext) RETURNS() antlr.TerminalNode { + return s.GetToken(DorisParserRETURNS, 0) +} + +func (s *NonReservedContext) REWRITTEN() antlr.TerminalNode { + return s.GetToken(DorisParserREWRITTEN, 0) +} + +func (s *NonReservedContext) RIGHT_BRACE() antlr.TerminalNode { + return s.GetToken(DorisParserRIGHT_BRACE, 0) +} + +func (s *NonReservedContext) RLIKE() antlr.TerminalNode { + return s.GetToken(DorisParserRLIKE, 0) +} + +func (s *NonReservedContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(DorisParserROLLBACK, 0) +} + +func (s *NonReservedContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(DorisParserROLLUP, 0) +} + +func (s *NonReservedContext) ROOT() antlr.TerminalNode { + return s.GetToken(DorisParserROOT, 0) +} + +func (s *NonReservedContext) ROTATE() antlr.TerminalNode { + return s.GetToken(DorisParserROTATE, 0) +} + +func (s *NonReservedContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(DorisParserROUTINE, 0) +} + +func (s *NonReservedContext) S3() antlr.TerminalNode { + return s.GetToken(DorisParserS3, 0) +} + +func (s *NonReservedContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(DorisParserSAMPLE, 0) +} + +func (s *NonReservedContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEDULE, 0) +} + +func (s *NonReservedContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEDULER, 0) +} + +func (s *NonReservedContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(DorisParserSCHEMA, 0) +} + +func (s *NonReservedContext) SECOND() antlr.TerminalNode { + return s.GetToken(DorisParserSECOND, 0) +} + +func (s *NonReservedContext) SEPARATOR() antlr.TerminalNode { + return s.GetToken(DorisParserSEPARATOR, 0) +} + +func (s *NonReservedContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(DorisParserSERIALIZABLE, 0) +} + +func (s *NonReservedContext) SET_SESSION_VARIABLE() antlr.TerminalNode { + return s.GetToken(DorisParserSET_SESSION_VARIABLE, 0) +} + +func (s *NonReservedContext) SESSION() antlr.TerminalNode { + return s.GetToken(DorisParserSESSION, 0) +} + +func (s *NonReservedContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(DorisParserSESSION_USER, 0) +} + +func (s *NonReservedContext) SHAPE() antlr.TerminalNode { + return s.GetToken(DorisParserSHAPE, 0) +} + +func (s *NonReservedContext) SKEW() antlr.TerminalNode { + return s.GetToken(DorisParserSKEW, 0) +} + +func (s *NonReservedContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOT, 0) +} + +func (s *NonReservedContext) SNAPSHOTS() antlr.TerminalNode { + return s.GetToken(DorisParserSNAPSHOTS, 0) +} + +func (s *NonReservedContext) SONAME() antlr.TerminalNode { + return s.GetToken(DorisParserSONAME, 0) +} + +func (s *NonReservedContext) SPLIT() antlr.TerminalNode { + return s.GetToken(DorisParserSPLIT, 0) +} + +func (s *NonReservedContext) SQL() antlr.TerminalNode { + return s.GetToken(DorisParserSQL, 0) +} + +func (s *NonReservedContext) STAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGE, 0) +} + +func (s *NonReservedContext) STAGES() antlr.TerminalNode { + return s.GetToken(DorisParserSTAGES, 0) +} + +func (s *NonReservedContext) START() antlr.TerminalNode { + return s.GetToken(DorisParserSTART, 0) +} + +func (s *NonReservedContext) STARTS() antlr.TerminalNode { + return s.GetToken(DorisParserSTARTS, 0) +} + +func (s *NonReservedContext) STATS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATS, 0) +} + +func (s *NonReservedContext) STATUS() antlr.TerminalNode { + return s.GetToken(DorisParserSTATUS, 0) +} + +func (s *NonReservedContext) STOP() antlr.TerminalNode { + return s.GetToken(DorisParserSTOP, 0) +} + +func (s *NonReservedContext) STORAGE() antlr.TerminalNode { + return s.GetToken(DorisParserSTORAGE, 0) +} + +func (s *NonReservedContext) STREAM() antlr.TerminalNode { + return s.GetToken(DorisParserSTREAM, 0) +} + +func (s *NonReservedContext) STREAMING() antlr.TerminalNode { + return s.GetToken(DorisParserSTREAMING, 0) +} + +func (s *NonReservedContext) STRING() antlr.TerminalNode { + return s.GetToken(DorisParserSTRING, 0) +} + +func (s *NonReservedContext) STRUCT() antlr.TerminalNode { + return s.GetToken(DorisParserSTRUCT, 0) +} + +func (s *NonReservedContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(DorisParserSUBSTR, 0) +} + +func (s *NonReservedContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(DorisParserSUBSTRING, 0) +} + +func (s *NonReservedContext) SUM() antlr.TerminalNode { + return s.GetToken(DorisParserSUM, 0) +} + +func (s *NonReservedContext) TABLES() antlr.TerminalNode { + return s.GetToken(DorisParserTABLES, 0) +} + +func (s *NonReservedContext) TAG() antlr.TerminalNode { + return s.GetToken(DorisParserTAG, 0) +} + +func (s *NonReservedContext) TASK() antlr.TerminalNode { + return s.GetToken(DorisParserTASK, 0) +} + +func (s *NonReservedContext) TASKS() antlr.TerminalNode { + return s.GetToken(DorisParserTASKS, 0) +} + +func (s *NonReservedContext) TDE() antlr.TerminalNode { + return s.GetToken(DorisParserTDE, 0) +} + +func (s *NonReservedContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(DorisParserTEMPORARY, 0) +} + +func (s *NonReservedContext) TEXT() antlr.TerminalNode { + return s.GetToken(DorisParserTEXT, 0) +} + +func (s *NonReservedContext) THAN() antlr.TerminalNode { + return s.GetToken(DorisParserTHAN, 0) +} + +func (s *NonReservedContext) TIME() antlr.TerminalNode { + return s.GetToken(DorisParserTIME, 0) +} + +func (s *NonReservedContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(DorisParserTIMESTAMP, 0) +} + +func (s *NonReservedContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(DorisParserTRANSACTION, 0) +} + +func (s *NonReservedContext) TREE() antlr.TerminalNode { + return s.GetToken(DorisParserTREE, 0) +} + +func (s *NonReservedContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(DorisParserTRIGGERS, 0) +} + +func (s *NonReservedContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(DorisParserTRUNCATE, 0) +} + +func (s *NonReservedContext) TYPE() antlr.TerminalNode { + return s.GetToken(DorisParserTYPE, 0) +} + +func (s *NonReservedContext) TYPES() antlr.TerminalNode { + return s.GetToken(DorisParserTYPES, 0) +} + +func (s *NonReservedContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(DorisParserUNCOMMITTED, 0) +} + +func (s *NonReservedContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(DorisParserUNLOCK, 0) +} + +func (s *NonReservedContext) UNSET() antlr.TerminalNode { + return s.GetToken(DorisParserUNSET, 0) +} + +func (s *NonReservedContext) UP() antlr.TerminalNode { + return s.GetToken(DorisParserUP, 0) +} + +func (s *NonReservedContext) USER() antlr.TerminalNode { + return s.GetToken(DorisParserUSER, 0) +} + +func (s *NonReservedContext) VALUE() antlr.TerminalNode { + return s.GetToken(DorisParserVALUE, 0) +} + +func (s *NonReservedContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(DorisParserVARBINARY, 0) +} + +func (s *NonReservedContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(DorisParserVARCHAR, 0) +} + +func (s *NonReservedContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(DorisParserVARIABLE, 0) +} + +func (s *NonReservedContext) VARIABLES() antlr.TerminalNode { + return s.GetToken(DorisParserVARIABLES, 0) +} + +func (s *NonReservedContext) VARIANT() antlr.TerminalNode { + return s.GetToken(DorisParserVARIANT, 0) +} + +func (s *NonReservedContext) VAULT() antlr.TerminalNode { + return s.GetToken(DorisParserVAULT, 0) +} + +func (s *NonReservedContext) VAULTS() antlr.TerminalNode { + return s.GetToken(DorisParserVAULTS, 0) +} + +func (s *NonReservedContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(DorisParserVERBOSE, 0) +} + +func (s *NonReservedContext) VERSION() antlr.TerminalNode { + return s.GetToken(DorisParserVERSION, 0) +} + +func (s *NonReservedContext) VIEW() antlr.TerminalNode { + return s.GetToken(DorisParserVIEW, 0) +} + +func (s *NonReservedContext) VIEWS() antlr.TerminalNode { + return s.GetToken(DorisParserVIEWS, 0) +} + +func (s *NonReservedContext) WARM() antlr.TerminalNode { + return s.GetToken(DorisParserWARM, 0) +} + +func (s *NonReservedContext) WARNINGS() antlr.TerminalNode { + return s.GetToken(DorisParserWARNINGS, 0) +} + +func (s *NonReservedContext) WEEK() antlr.TerminalNode { + return s.GetToken(DorisParserWEEK, 0) +} + +func (s *NonReservedContext) WORK() antlr.TerminalNode { + return s.GetToken(DorisParserWORK, 0) +} + +func (s *NonReservedContext) YEAR() antlr.TerminalNode { + return s.GetToken(DorisParserYEAR, 0) +} + +func (s *NonReservedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NonReservedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NonReservedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.EnterNonReserved(s) + } +} + +func (s *NonReservedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(DorisParserListener); ok { + listenerT.ExitNonReserved(s) + } +} + +func (s *NonReservedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case DorisParserVisitor: + return t.VisitNonReserved(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *DorisParser) NonReserved() (localctx INonReservedContext) { + localctx = NewNonReservedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, DorisParserRULE_nonReserved) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6771) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-9)) & ^0x3f) == 0 && ((int64(1)<<(_la-9))&-1017848816276584557) != 0) || ((int64((_la-73)) & ^0x3f) == 0 && ((int64(1)<<(_la-73))&3015146695164951477) != 0) || ((int64((_la-137)) & ^0x3f) == 0 && ((int64(1)<<(_la-137))&-7485078685954271025) != 0) || ((int64((_la-202)) & ^0x3f) == 0 && ((int64(1)<<(_la-202))&-7944499236065001827) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-3243164585857125581) != 0) || ((int64((_la-332)) & ^0x3f) == 0 && ((int64(1)<<(_la-332))&2170733439173515295) != 0) || ((int64((_la-398)) & ^0x3f) == 0 && ((int64(1)<<(_la-398))&-18408135544438801) != 0) || ((int64((_la-462)) & ^0x3f) == 0 && ((int64(1)<<(_la-462))&-205605760201160641) != 0) || ((int64((_la-526)) & ^0x3f) == 0 && ((int64(1)<<(_la-526))&1152923428752265471) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +func (p *DorisParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 117: + var t *QueryTermContext = nil + if localctx != nil { + t = localctx.(*QueryTermContext) + } + return p.QueryTerm_Sempred(t, predIndex) + + case 194: + var t *BooleanExpressionContext = nil + if localctx != nil { + t = localctx.(*BooleanExpressionContext) + } + return p.BooleanExpression_Sempred(t, predIndex) + + case 198: + var t *ValueExpressionContext = nil + if localctx != nil { + t = localctx.(*ValueExpressionContext) + } + return p.ValueExpression_Sempred(t, predIndex) + + case 199: + var t *PrimaryExpressionContext = nil + if localctx != nil { + t = localctx.(*PrimaryExpressionContext) + } + return p.PrimaryExpression_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *DorisParser) QueryTerm_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 1: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *DorisParser) BooleanExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 2: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 3: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 5: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *DorisParser) ValueExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 6: + return p.Precpred(p.GetParserRuleContext(), 6) + + case 7: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 8: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 9: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 10: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 11: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *DorisParser) PrimaryExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 12: + return p.Precpred(p.GetParserRuleContext(), 11) + + case 13: + return p.Precpred(p.GetParserRuleContext(), 10) + + case 14: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 15: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/doris/dorisparser_base_listener.go b/doris/dorisparser_base_listener.go new file mode 100644 index 0000000..6465b8e --- /dev/null +++ b/doris/dorisparser_base_listener.go @@ -0,0 +1,4139 @@ +// Code generated from DorisParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package doris // DorisParser +import "github.com/antlr4-go/antlr/v4" + +// BaseDorisParserListener is a complete listener for a parse tree produced by DorisParser. +type BaseDorisParserListener struct{} + +var _ DorisParserListener = &BaseDorisParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseDorisParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseDorisParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseDorisParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseDorisParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterMultiStatements is called when production multiStatements is entered. +func (s *BaseDorisParserListener) EnterMultiStatements(ctx *MultiStatementsContext) {} + +// ExitMultiStatements is called when production multiStatements is exited. +func (s *BaseDorisParserListener) ExitMultiStatements(ctx *MultiStatementsContext) {} + +// EnterSingleStatement is called when production singleStatement is entered. +func (s *BaseDorisParserListener) EnterSingleStatement(ctx *SingleStatementContext) {} + +// ExitSingleStatement is called when production singleStatement is exited. +func (s *BaseDorisParserListener) ExitSingleStatement(ctx *SingleStatementContext) {} + +// EnterExpressionWithEof is called when production expressionWithEof is entered. +func (s *BaseDorisParserListener) EnterExpressionWithEof(ctx *ExpressionWithEofContext) {} + +// ExitExpressionWithEof is called when production expressionWithEof is exited. +func (s *BaseDorisParserListener) ExitExpressionWithEof(ctx *ExpressionWithEofContext) {} + +// EnterStatementBaseAlias is called when production statementBaseAlias is entered. +func (s *BaseDorisParserListener) EnterStatementBaseAlias(ctx *StatementBaseAliasContext) {} + +// ExitStatementBaseAlias is called when production statementBaseAlias is exited. +func (s *BaseDorisParserListener) ExitStatementBaseAlias(ctx *StatementBaseAliasContext) {} + +// EnterCallProcedure is called when production callProcedure is entered. +func (s *BaseDorisParserListener) EnterCallProcedure(ctx *CallProcedureContext) {} + +// ExitCallProcedure is called when production callProcedure is exited. +func (s *BaseDorisParserListener) ExitCallProcedure(ctx *CallProcedureContext) {} + +// EnterCreateProcedure is called when production createProcedure is entered. +func (s *BaseDorisParserListener) EnterCreateProcedure(ctx *CreateProcedureContext) {} + +// ExitCreateProcedure is called when production createProcedure is exited. +func (s *BaseDorisParserListener) ExitCreateProcedure(ctx *CreateProcedureContext) {} + +// EnterDropProcedure is called when production dropProcedure is entered. +func (s *BaseDorisParserListener) EnterDropProcedure(ctx *DropProcedureContext) {} + +// ExitDropProcedure is called when production dropProcedure is exited. +func (s *BaseDorisParserListener) ExitDropProcedure(ctx *DropProcedureContext) {} + +// EnterShowProcedureStatus is called when production showProcedureStatus is entered. +func (s *BaseDorisParserListener) EnterShowProcedureStatus(ctx *ShowProcedureStatusContext) {} + +// ExitShowProcedureStatus is called when production showProcedureStatus is exited. +func (s *BaseDorisParserListener) ExitShowProcedureStatus(ctx *ShowProcedureStatusContext) {} + +// EnterShowCreateProcedure is called when production showCreateProcedure is entered. +func (s *BaseDorisParserListener) EnterShowCreateProcedure(ctx *ShowCreateProcedureContext) {} + +// ExitShowCreateProcedure is called when production showCreateProcedure is exited. +func (s *BaseDorisParserListener) ExitShowCreateProcedure(ctx *ShowCreateProcedureContext) {} + +// EnterShowConfig is called when production showConfig is entered. +func (s *BaseDorisParserListener) EnterShowConfig(ctx *ShowConfigContext) {} + +// ExitShowConfig is called when production showConfig is exited. +func (s *BaseDorisParserListener) ExitShowConfig(ctx *ShowConfigContext) {} + +// EnterStatementDefault is called when production statementDefault is entered. +func (s *BaseDorisParserListener) EnterStatementDefault(ctx *StatementDefaultContext) {} + +// ExitStatementDefault is called when production statementDefault is exited. +func (s *BaseDorisParserListener) ExitStatementDefault(ctx *StatementDefaultContext) {} + +// EnterSupportedDmlStatementAlias is called when production supportedDmlStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedDmlStatementAlias(ctx *SupportedDmlStatementAliasContext) { +} + +// ExitSupportedDmlStatementAlias is called when production supportedDmlStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedDmlStatementAlias(ctx *SupportedDmlStatementAliasContext) { +} + +// EnterSupportedCreateStatementAlias is called when production supportedCreateStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedCreateStatementAlias(ctx *SupportedCreateStatementAliasContext) { +} + +// ExitSupportedCreateStatementAlias is called when production supportedCreateStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedCreateStatementAlias(ctx *SupportedCreateStatementAliasContext) { +} + +// EnterSupportedAlterStatementAlias is called when production supportedAlterStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedAlterStatementAlias(ctx *SupportedAlterStatementAliasContext) { +} + +// ExitSupportedAlterStatementAlias is called when production supportedAlterStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedAlterStatementAlias(ctx *SupportedAlterStatementAliasContext) { +} + +// EnterMaterializedViewStatementAlias is called when production materializedViewStatementAlias is entered. +func (s *BaseDorisParserListener) EnterMaterializedViewStatementAlias(ctx *MaterializedViewStatementAliasContext) { +} + +// ExitMaterializedViewStatementAlias is called when production materializedViewStatementAlias is exited. +func (s *BaseDorisParserListener) ExitMaterializedViewStatementAlias(ctx *MaterializedViewStatementAliasContext) { +} + +// EnterSupportedJobStatementAlias is called when production supportedJobStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedJobStatementAlias(ctx *SupportedJobStatementAliasContext) { +} + +// ExitSupportedJobStatementAlias is called when production supportedJobStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedJobStatementAlias(ctx *SupportedJobStatementAliasContext) { +} + +// EnterConstraintStatementAlias is called when production constraintStatementAlias is entered. +func (s *BaseDorisParserListener) EnterConstraintStatementAlias(ctx *ConstraintStatementAliasContext) { +} + +// ExitConstraintStatementAlias is called when production constraintStatementAlias is exited. +func (s *BaseDorisParserListener) ExitConstraintStatementAlias(ctx *ConstraintStatementAliasContext) { +} + +// EnterSupportedCleanStatementAlias is called when production supportedCleanStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedCleanStatementAlias(ctx *SupportedCleanStatementAliasContext) { +} + +// ExitSupportedCleanStatementAlias is called when production supportedCleanStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedCleanStatementAlias(ctx *SupportedCleanStatementAliasContext) { +} + +// EnterSupportedDescribeStatementAlias is called when production supportedDescribeStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedDescribeStatementAlias(ctx *SupportedDescribeStatementAliasContext) { +} + +// ExitSupportedDescribeStatementAlias is called when production supportedDescribeStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedDescribeStatementAlias(ctx *SupportedDescribeStatementAliasContext) { +} + +// EnterSupportedDropStatementAlias is called when production supportedDropStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedDropStatementAlias(ctx *SupportedDropStatementAliasContext) { +} + +// ExitSupportedDropStatementAlias is called when production supportedDropStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedDropStatementAlias(ctx *SupportedDropStatementAliasContext) { +} + +// EnterSupportedSetStatementAlias is called when production supportedSetStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedSetStatementAlias(ctx *SupportedSetStatementAliasContext) { +} + +// ExitSupportedSetStatementAlias is called when production supportedSetStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedSetStatementAlias(ctx *SupportedSetStatementAliasContext) { +} + +// EnterSupportedUnsetStatementAlias is called when production supportedUnsetStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedUnsetStatementAlias(ctx *SupportedUnsetStatementAliasContext) { +} + +// ExitSupportedUnsetStatementAlias is called when production supportedUnsetStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedUnsetStatementAlias(ctx *SupportedUnsetStatementAliasContext) { +} + +// EnterSupportedRefreshStatementAlias is called when production supportedRefreshStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedRefreshStatementAlias(ctx *SupportedRefreshStatementAliasContext) { +} + +// ExitSupportedRefreshStatementAlias is called when production supportedRefreshStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedRefreshStatementAlias(ctx *SupportedRefreshStatementAliasContext) { +} + +// EnterSupportedShowStatementAlias is called when production supportedShowStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedShowStatementAlias(ctx *SupportedShowStatementAliasContext) { +} + +// ExitSupportedShowStatementAlias is called when production supportedShowStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedShowStatementAlias(ctx *SupportedShowStatementAliasContext) { +} + +// EnterSupportedLoadStatementAlias is called when production supportedLoadStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedLoadStatementAlias(ctx *SupportedLoadStatementAliasContext) { +} + +// ExitSupportedLoadStatementAlias is called when production supportedLoadStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedLoadStatementAlias(ctx *SupportedLoadStatementAliasContext) { +} + +// EnterSupportedCancelStatementAlias is called when production supportedCancelStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedCancelStatementAlias(ctx *SupportedCancelStatementAliasContext) { +} + +// ExitSupportedCancelStatementAlias is called when production supportedCancelStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedCancelStatementAlias(ctx *SupportedCancelStatementAliasContext) { +} + +// EnterSupportedRecoverStatementAlias is called when production supportedRecoverStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedRecoverStatementAlias(ctx *SupportedRecoverStatementAliasContext) { +} + +// ExitSupportedRecoverStatementAlias is called when production supportedRecoverStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedRecoverStatementAlias(ctx *SupportedRecoverStatementAliasContext) { +} + +// EnterSupportedAdminStatementAlias is called when production supportedAdminStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedAdminStatementAlias(ctx *SupportedAdminStatementAliasContext) { +} + +// ExitSupportedAdminStatementAlias is called when production supportedAdminStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedAdminStatementAlias(ctx *SupportedAdminStatementAliasContext) { +} + +// EnterSupportedUseStatementAlias is called when production supportedUseStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedUseStatementAlias(ctx *SupportedUseStatementAliasContext) { +} + +// ExitSupportedUseStatementAlias is called when production supportedUseStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedUseStatementAlias(ctx *SupportedUseStatementAliasContext) { +} + +// EnterSupportedOtherStatementAlias is called when production supportedOtherStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedOtherStatementAlias(ctx *SupportedOtherStatementAliasContext) { +} + +// ExitSupportedOtherStatementAlias is called when production supportedOtherStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedOtherStatementAlias(ctx *SupportedOtherStatementAliasContext) { +} + +// EnterSupportedKillStatementAlias is called when production supportedKillStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedKillStatementAlias(ctx *SupportedKillStatementAliasContext) { +} + +// ExitSupportedKillStatementAlias is called when production supportedKillStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedKillStatementAlias(ctx *SupportedKillStatementAliasContext) { +} + +// EnterSupportedStatsStatementAlias is called when production supportedStatsStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedStatsStatementAlias(ctx *SupportedStatsStatementAliasContext) { +} + +// ExitSupportedStatsStatementAlias is called when production supportedStatsStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedStatsStatementAlias(ctx *SupportedStatsStatementAliasContext) { +} + +// EnterSupportedTransactionStatementAlias is called when production supportedTransactionStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedTransactionStatementAlias(ctx *SupportedTransactionStatementAliasContext) { +} + +// ExitSupportedTransactionStatementAlias is called when production supportedTransactionStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedTransactionStatementAlias(ctx *SupportedTransactionStatementAliasContext) { +} + +// EnterSupportedGrantRevokeStatementAlias is called when production supportedGrantRevokeStatementAlias is entered. +func (s *BaseDorisParserListener) EnterSupportedGrantRevokeStatementAlias(ctx *SupportedGrantRevokeStatementAliasContext) { +} + +// ExitSupportedGrantRevokeStatementAlias is called when production supportedGrantRevokeStatementAlias is exited. +func (s *BaseDorisParserListener) ExitSupportedGrantRevokeStatementAlias(ctx *SupportedGrantRevokeStatementAliasContext) { +} + +// EnterCreateMTMV is called when production createMTMV is entered. +func (s *BaseDorisParserListener) EnterCreateMTMV(ctx *CreateMTMVContext) {} + +// ExitCreateMTMV is called when production createMTMV is exited. +func (s *BaseDorisParserListener) ExitCreateMTMV(ctx *CreateMTMVContext) {} + +// EnterRefreshMTMV is called when production refreshMTMV is entered. +func (s *BaseDorisParserListener) EnterRefreshMTMV(ctx *RefreshMTMVContext) {} + +// ExitRefreshMTMV is called when production refreshMTMV is exited. +func (s *BaseDorisParserListener) ExitRefreshMTMV(ctx *RefreshMTMVContext) {} + +// EnterAlterMTMV is called when production alterMTMV is entered. +func (s *BaseDorisParserListener) EnterAlterMTMV(ctx *AlterMTMVContext) {} + +// ExitAlterMTMV is called when production alterMTMV is exited. +func (s *BaseDorisParserListener) ExitAlterMTMV(ctx *AlterMTMVContext) {} + +// EnterDropMV is called when production dropMV is entered. +func (s *BaseDorisParserListener) EnterDropMV(ctx *DropMVContext) {} + +// ExitDropMV is called when production dropMV is exited. +func (s *BaseDorisParserListener) ExitDropMV(ctx *DropMVContext) {} + +// EnterPauseMTMV is called when production pauseMTMV is entered. +func (s *BaseDorisParserListener) EnterPauseMTMV(ctx *PauseMTMVContext) {} + +// ExitPauseMTMV is called when production pauseMTMV is exited. +func (s *BaseDorisParserListener) ExitPauseMTMV(ctx *PauseMTMVContext) {} + +// EnterResumeMTMV is called when production resumeMTMV is entered. +func (s *BaseDorisParserListener) EnterResumeMTMV(ctx *ResumeMTMVContext) {} + +// ExitResumeMTMV is called when production resumeMTMV is exited. +func (s *BaseDorisParserListener) ExitResumeMTMV(ctx *ResumeMTMVContext) {} + +// EnterCancelMTMVTask is called when production cancelMTMVTask is entered. +func (s *BaseDorisParserListener) EnterCancelMTMVTask(ctx *CancelMTMVTaskContext) {} + +// ExitCancelMTMVTask is called when production cancelMTMVTask is exited. +func (s *BaseDorisParserListener) ExitCancelMTMVTask(ctx *CancelMTMVTaskContext) {} + +// EnterShowCreateMTMV is called when production showCreateMTMV is entered. +func (s *BaseDorisParserListener) EnterShowCreateMTMV(ctx *ShowCreateMTMVContext) {} + +// ExitShowCreateMTMV is called when production showCreateMTMV is exited. +func (s *BaseDorisParserListener) ExitShowCreateMTMV(ctx *ShowCreateMTMVContext) {} + +// EnterCreateScheduledJob is called when production createScheduledJob is entered. +func (s *BaseDorisParserListener) EnterCreateScheduledJob(ctx *CreateScheduledJobContext) {} + +// ExitCreateScheduledJob is called when production createScheduledJob is exited. +func (s *BaseDorisParserListener) ExitCreateScheduledJob(ctx *CreateScheduledJobContext) {} + +// EnterPauseJob is called when production pauseJob is entered. +func (s *BaseDorisParserListener) EnterPauseJob(ctx *PauseJobContext) {} + +// ExitPauseJob is called when production pauseJob is exited. +func (s *BaseDorisParserListener) ExitPauseJob(ctx *PauseJobContext) {} + +// EnterAlterJob is called when production alterJob is entered. +func (s *BaseDorisParserListener) EnterAlterJob(ctx *AlterJobContext) {} + +// ExitAlterJob is called when production alterJob is exited. +func (s *BaseDorisParserListener) ExitAlterJob(ctx *AlterJobContext) {} + +// EnterDropJob is called when production dropJob is entered. +func (s *BaseDorisParserListener) EnterDropJob(ctx *DropJobContext) {} + +// ExitDropJob is called when production dropJob is exited. +func (s *BaseDorisParserListener) ExitDropJob(ctx *DropJobContext) {} + +// EnterResumeJob is called when production resumeJob is entered. +func (s *BaseDorisParserListener) EnterResumeJob(ctx *ResumeJobContext) {} + +// ExitResumeJob is called when production resumeJob is exited. +func (s *BaseDorisParserListener) ExitResumeJob(ctx *ResumeJobContext) {} + +// EnterCancelJobTask is called when production cancelJobTask is entered. +func (s *BaseDorisParserListener) EnterCancelJobTask(ctx *CancelJobTaskContext) {} + +// ExitCancelJobTask is called when production cancelJobTask is exited. +func (s *BaseDorisParserListener) ExitCancelJobTask(ctx *CancelJobTaskContext) {} + +// EnterAddConstraint is called when production addConstraint is entered. +func (s *BaseDorisParserListener) EnterAddConstraint(ctx *AddConstraintContext) {} + +// ExitAddConstraint is called when production addConstraint is exited. +func (s *BaseDorisParserListener) ExitAddConstraint(ctx *AddConstraintContext) {} + +// EnterDropConstraint is called when production dropConstraint is entered. +func (s *BaseDorisParserListener) EnterDropConstraint(ctx *DropConstraintContext) {} + +// ExitDropConstraint is called when production dropConstraint is exited. +func (s *BaseDorisParserListener) ExitDropConstraint(ctx *DropConstraintContext) {} + +// EnterShowConstraint is called when production showConstraint is entered. +func (s *BaseDorisParserListener) EnterShowConstraint(ctx *ShowConstraintContext) {} + +// ExitShowConstraint is called when production showConstraint is exited. +func (s *BaseDorisParserListener) ExitShowConstraint(ctx *ShowConstraintContext) {} + +// EnterOptSpecBranch is called when production optSpecBranch is entered. +func (s *BaseDorisParserListener) EnterOptSpecBranch(ctx *OptSpecBranchContext) {} + +// ExitOptSpecBranch is called when production optSpecBranch is exited. +func (s *BaseDorisParserListener) ExitOptSpecBranch(ctx *OptSpecBranchContext) {} + +// EnterInsertTable is called when production insertTable is entered. +func (s *BaseDorisParserListener) EnterInsertTable(ctx *InsertTableContext) {} + +// ExitInsertTable is called when production insertTable is exited. +func (s *BaseDorisParserListener) ExitInsertTable(ctx *InsertTableContext) {} + +// EnterUpdate is called when production update is entered. +func (s *BaseDorisParserListener) EnterUpdate(ctx *UpdateContext) {} + +// ExitUpdate is called when production update is exited. +func (s *BaseDorisParserListener) ExitUpdate(ctx *UpdateContext) {} + +// EnterDelete is called when production delete is entered. +func (s *BaseDorisParserListener) EnterDelete(ctx *DeleteContext) {} + +// ExitDelete is called when production delete is exited. +func (s *BaseDorisParserListener) ExitDelete(ctx *DeleteContext) {} + +// EnterMergeInto is called when production mergeInto is entered. +func (s *BaseDorisParserListener) EnterMergeInto(ctx *MergeIntoContext) {} + +// ExitMergeInto is called when production mergeInto is exited. +func (s *BaseDorisParserListener) ExitMergeInto(ctx *MergeIntoContext) {} + +// EnterLoad is called when production load is entered. +func (s *BaseDorisParserListener) EnterLoad(ctx *LoadContext) {} + +// ExitLoad is called when production load is exited. +func (s *BaseDorisParserListener) ExitLoad(ctx *LoadContext) {} + +// EnterExport is called when production export is entered. +func (s *BaseDorisParserListener) EnterExport(ctx *ExportContext) {} + +// ExitExport is called when production export is exited. +func (s *BaseDorisParserListener) ExitExport(ctx *ExportContext) {} + +// EnterReplay is called when production replay is entered. +func (s *BaseDorisParserListener) EnterReplay(ctx *ReplayContext) {} + +// ExitReplay is called when production replay is exited. +func (s *BaseDorisParserListener) ExitReplay(ctx *ReplayContext) {} + +// EnterCopyInto is called when production copyInto is entered. +func (s *BaseDorisParserListener) EnterCopyInto(ctx *CopyIntoContext) {} + +// ExitCopyInto is called when production copyInto is exited. +func (s *BaseDorisParserListener) ExitCopyInto(ctx *CopyIntoContext) {} + +// EnterTruncateTable is called when production truncateTable is entered. +func (s *BaseDorisParserListener) EnterTruncateTable(ctx *TruncateTableContext) {} + +// ExitTruncateTable is called when production truncateTable is exited. +func (s *BaseDorisParserListener) ExitTruncateTable(ctx *TruncateTableContext) {} + +// EnterMergeMatchedClause is called when production mergeMatchedClause is entered. +func (s *BaseDorisParserListener) EnterMergeMatchedClause(ctx *MergeMatchedClauseContext) {} + +// ExitMergeMatchedClause is called when production mergeMatchedClause is exited. +func (s *BaseDorisParserListener) ExitMergeMatchedClause(ctx *MergeMatchedClauseContext) {} + +// EnterMergeNotMatchedClause is called when production mergeNotMatchedClause is entered. +func (s *BaseDorisParserListener) EnterMergeNotMatchedClause(ctx *MergeNotMatchedClauseContext) {} + +// ExitMergeNotMatchedClause is called when production mergeNotMatchedClause is exited. +func (s *BaseDorisParserListener) ExitMergeNotMatchedClause(ctx *MergeNotMatchedClauseContext) {} + +// EnterCreateTable is called when production createTable is entered. +func (s *BaseDorisParserListener) EnterCreateTable(ctx *CreateTableContext) {} + +// ExitCreateTable is called when production createTable is exited. +func (s *BaseDorisParserListener) ExitCreateTable(ctx *CreateTableContext) {} + +// EnterCreateView is called when production createView is entered. +func (s *BaseDorisParserListener) EnterCreateView(ctx *CreateViewContext) {} + +// ExitCreateView is called when production createView is exited. +func (s *BaseDorisParserListener) ExitCreateView(ctx *CreateViewContext) {} + +// EnterCreateFile is called when production createFile is entered. +func (s *BaseDorisParserListener) EnterCreateFile(ctx *CreateFileContext) {} + +// ExitCreateFile is called when production createFile is exited. +func (s *BaseDorisParserListener) ExitCreateFile(ctx *CreateFileContext) {} + +// EnterCreateTableLike is called when production createTableLike is entered. +func (s *BaseDorisParserListener) EnterCreateTableLike(ctx *CreateTableLikeContext) {} + +// ExitCreateTableLike is called when production createTableLike is exited. +func (s *BaseDorisParserListener) ExitCreateTableLike(ctx *CreateTableLikeContext) {} + +// EnterCreateRole is called when production createRole is entered. +func (s *BaseDorisParserListener) EnterCreateRole(ctx *CreateRoleContext) {} + +// ExitCreateRole is called when production createRole is exited. +func (s *BaseDorisParserListener) ExitCreateRole(ctx *CreateRoleContext) {} + +// EnterCreateWorkloadGroup is called when production createWorkloadGroup is entered. +func (s *BaseDorisParserListener) EnterCreateWorkloadGroup(ctx *CreateWorkloadGroupContext) {} + +// ExitCreateWorkloadGroup is called when production createWorkloadGroup is exited. +func (s *BaseDorisParserListener) ExitCreateWorkloadGroup(ctx *CreateWorkloadGroupContext) {} + +// EnterCreateCatalog is called when production createCatalog is entered. +func (s *BaseDorisParserListener) EnterCreateCatalog(ctx *CreateCatalogContext) {} + +// ExitCreateCatalog is called when production createCatalog is exited. +func (s *BaseDorisParserListener) ExitCreateCatalog(ctx *CreateCatalogContext) {} + +// EnterCreateRowPolicy is called when production createRowPolicy is entered. +func (s *BaseDorisParserListener) EnterCreateRowPolicy(ctx *CreateRowPolicyContext) {} + +// ExitCreateRowPolicy is called when production createRowPolicy is exited. +func (s *BaseDorisParserListener) ExitCreateRowPolicy(ctx *CreateRowPolicyContext) {} + +// EnterCreateStoragePolicy is called when production createStoragePolicy is entered. +func (s *BaseDorisParserListener) EnterCreateStoragePolicy(ctx *CreateStoragePolicyContext) {} + +// ExitCreateStoragePolicy is called when production createStoragePolicy is exited. +func (s *BaseDorisParserListener) ExitCreateStoragePolicy(ctx *CreateStoragePolicyContext) {} + +// EnterBuildIndex is called when production buildIndex is entered. +func (s *BaseDorisParserListener) EnterBuildIndex(ctx *BuildIndexContext) {} + +// ExitBuildIndex is called when production buildIndex is exited. +func (s *BaseDorisParserListener) ExitBuildIndex(ctx *BuildIndexContext) {} + +// EnterCreateIndex is called when production createIndex is entered. +func (s *BaseDorisParserListener) EnterCreateIndex(ctx *CreateIndexContext) {} + +// ExitCreateIndex is called when production createIndex is exited. +func (s *BaseDorisParserListener) ExitCreateIndex(ctx *CreateIndexContext) {} + +// EnterCreateWorkloadPolicy is called when production createWorkloadPolicy is entered. +func (s *BaseDorisParserListener) EnterCreateWorkloadPolicy(ctx *CreateWorkloadPolicyContext) {} + +// ExitCreateWorkloadPolicy is called when production createWorkloadPolicy is exited. +func (s *BaseDorisParserListener) ExitCreateWorkloadPolicy(ctx *CreateWorkloadPolicyContext) {} + +// EnterCreateSqlBlockRule is called when production createSqlBlockRule is entered. +func (s *BaseDorisParserListener) EnterCreateSqlBlockRule(ctx *CreateSqlBlockRuleContext) {} + +// ExitCreateSqlBlockRule is called when production createSqlBlockRule is exited. +func (s *BaseDorisParserListener) ExitCreateSqlBlockRule(ctx *CreateSqlBlockRuleContext) {} + +// EnterCreateEncryptkey is called when production createEncryptkey is entered. +func (s *BaseDorisParserListener) EnterCreateEncryptkey(ctx *CreateEncryptkeyContext) {} + +// ExitCreateEncryptkey is called when production createEncryptkey is exited. +func (s *BaseDorisParserListener) ExitCreateEncryptkey(ctx *CreateEncryptkeyContext) {} + +// EnterCreateUserDefineFunction is called when production createUserDefineFunction is entered. +func (s *BaseDorisParserListener) EnterCreateUserDefineFunction(ctx *CreateUserDefineFunctionContext) { +} + +// ExitCreateUserDefineFunction is called when production createUserDefineFunction is exited. +func (s *BaseDorisParserListener) ExitCreateUserDefineFunction(ctx *CreateUserDefineFunctionContext) { +} + +// EnterCreateAliasFunction is called when production createAliasFunction is entered. +func (s *BaseDorisParserListener) EnterCreateAliasFunction(ctx *CreateAliasFunctionContext) {} + +// ExitCreateAliasFunction is called when production createAliasFunction is exited. +func (s *BaseDorisParserListener) ExitCreateAliasFunction(ctx *CreateAliasFunctionContext) {} + +// EnterCreateUser is called when production createUser is entered. +func (s *BaseDorisParserListener) EnterCreateUser(ctx *CreateUserContext) {} + +// ExitCreateUser is called when production createUser is exited. +func (s *BaseDorisParserListener) ExitCreateUser(ctx *CreateUserContext) {} + +// EnterCreateDatabase is called when production createDatabase is entered. +func (s *BaseDorisParserListener) EnterCreateDatabase(ctx *CreateDatabaseContext) {} + +// ExitCreateDatabase is called when production createDatabase is exited. +func (s *BaseDorisParserListener) ExitCreateDatabase(ctx *CreateDatabaseContext) {} + +// EnterCreateRepository is called when production createRepository is entered. +func (s *BaseDorisParserListener) EnterCreateRepository(ctx *CreateRepositoryContext) {} + +// ExitCreateRepository is called when production createRepository is exited. +func (s *BaseDorisParserListener) ExitCreateRepository(ctx *CreateRepositoryContext) {} + +// EnterCreateResource is called when production createResource is entered. +func (s *BaseDorisParserListener) EnterCreateResource(ctx *CreateResourceContext) {} + +// ExitCreateResource is called when production createResource is exited. +func (s *BaseDorisParserListener) ExitCreateResource(ctx *CreateResourceContext) {} + +// EnterCreateDictionary is called when production createDictionary is entered. +func (s *BaseDorisParserListener) EnterCreateDictionary(ctx *CreateDictionaryContext) {} + +// ExitCreateDictionary is called when production createDictionary is exited. +func (s *BaseDorisParserListener) ExitCreateDictionary(ctx *CreateDictionaryContext) {} + +// EnterCreateStage is called when production createStage is entered. +func (s *BaseDorisParserListener) EnterCreateStage(ctx *CreateStageContext) {} + +// ExitCreateStage is called when production createStage is exited. +func (s *BaseDorisParserListener) ExitCreateStage(ctx *CreateStageContext) {} + +// EnterCreateStorageVault is called when production createStorageVault is entered. +func (s *BaseDorisParserListener) EnterCreateStorageVault(ctx *CreateStorageVaultContext) {} + +// ExitCreateStorageVault is called when production createStorageVault is exited. +func (s *BaseDorisParserListener) ExitCreateStorageVault(ctx *CreateStorageVaultContext) {} + +// EnterCreateIndexAnalyzer is called when production createIndexAnalyzer is entered. +func (s *BaseDorisParserListener) EnterCreateIndexAnalyzer(ctx *CreateIndexAnalyzerContext) {} + +// ExitCreateIndexAnalyzer is called when production createIndexAnalyzer is exited. +func (s *BaseDorisParserListener) ExitCreateIndexAnalyzer(ctx *CreateIndexAnalyzerContext) {} + +// EnterCreateIndexTokenizer is called when production createIndexTokenizer is entered. +func (s *BaseDorisParserListener) EnterCreateIndexTokenizer(ctx *CreateIndexTokenizerContext) {} + +// ExitCreateIndexTokenizer is called when production createIndexTokenizer is exited. +func (s *BaseDorisParserListener) ExitCreateIndexTokenizer(ctx *CreateIndexTokenizerContext) {} + +// EnterCreateIndexTokenFilter is called when production createIndexTokenFilter is entered. +func (s *BaseDorisParserListener) EnterCreateIndexTokenFilter(ctx *CreateIndexTokenFilterContext) {} + +// ExitCreateIndexTokenFilter is called when production createIndexTokenFilter is exited. +func (s *BaseDorisParserListener) ExitCreateIndexTokenFilter(ctx *CreateIndexTokenFilterContext) {} + +// EnterCreateIndexCharFilter is called when production createIndexCharFilter is entered. +func (s *BaseDorisParserListener) EnterCreateIndexCharFilter(ctx *CreateIndexCharFilterContext) {} + +// ExitCreateIndexCharFilter is called when production createIndexCharFilter is exited. +func (s *BaseDorisParserListener) ExitCreateIndexCharFilter(ctx *CreateIndexCharFilterContext) {} + +// EnterDictionaryColumnDefs is called when production dictionaryColumnDefs is entered. +func (s *BaseDorisParserListener) EnterDictionaryColumnDefs(ctx *DictionaryColumnDefsContext) {} + +// ExitDictionaryColumnDefs is called when production dictionaryColumnDefs is exited. +func (s *BaseDorisParserListener) ExitDictionaryColumnDefs(ctx *DictionaryColumnDefsContext) {} + +// EnterDictionaryColumnDef is called when production dictionaryColumnDef is entered. +func (s *BaseDorisParserListener) EnterDictionaryColumnDef(ctx *DictionaryColumnDefContext) {} + +// ExitDictionaryColumnDef is called when production dictionaryColumnDef is exited. +func (s *BaseDorisParserListener) ExitDictionaryColumnDef(ctx *DictionaryColumnDefContext) {} + +// EnterAlterSystem is called when production alterSystem is entered. +func (s *BaseDorisParserListener) EnterAlterSystem(ctx *AlterSystemContext) {} + +// ExitAlterSystem is called when production alterSystem is exited. +func (s *BaseDorisParserListener) ExitAlterSystem(ctx *AlterSystemContext) {} + +// EnterAlterView is called when production alterView is entered. +func (s *BaseDorisParserListener) EnterAlterView(ctx *AlterViewContext) {} + +// ExitAlterView is called when production alterView is exited. +func (s *BaseDorisParserListener) ExitAlterView(ctx *AlterViewContext) {} + +// EnterAlterCatalogRename is called when production alterCatalogRename is entered. +func (s *BaseDorisParserListener) EnterAlterCatalogRename(ctx *AlterCatalogRenameContext) {} + +// ExitAlterCatalogRename is called when production alterCatalogRename is exited. +func (s *BaseDorisParserListener) ExitAlterCatalogRename(ctx *AlterCatalogRenameContext) {} + +// EnterAlterRole is called when production alterRole is entered. +func (s *BaseDorisParserListener) EnterAlterRole(ctx *AlterRoleContext) {} + +// ExitAlterRole is called when production alterRole is exited. +func (s *BaseDorisParserListener) ExitAlterRole(ctx *AlterRoleContext) {} + +// EnterAlterStorageVault is called when production alterStorageVault is entered. +func (s *BaseDorisParserListener) EnterAlterStorageVault(ctx *AlterStorageVaultContext) {} + +// ExitAlterStorageVault is called when production alterStorageVault is exited. +func (s *BaseDorisParserListener) ExitAlterStorageVault(ctx *AlterStorageVaultContext) {} + +// EnterAlterWorkloadGroup is called when production alterWorkloadGroup is entered. +func (s *BaseDorisParserListener) EnterAlterWorkloadGroup(ctx *AlterWorkloadGroupContext) {} + +// ExitAlterWorkloadGroup is called when production alterWorkloadGroup is exited. +func (s *BaseDorisParserListener) ExitAlterWorkloadGroup(ctx *AlterWorkloadGroupContext) {} + +// EnterAlterComputeGroup is called when production alterComputeGroup is entered. +func (s *BaseDorisParserListener) EnterAlterComputeGroup(ctx *AlterComputeGroupContext) {} + +// ExitAlterComputeGroup is called when production alterComputeGroup is exited. +func (s *BaseDorisParserListener) ExitAlterComputeGroup(ctx *AlterComputeGroupContext) {} + +// EnterAlterCatalogProperties is called when production alterCatalogProperties is entered. +func (s *BaseDorisParserListener) EnterAlterCatalogProperties(ctx *AlterCatalogPropertiesContext) {} + +// ExitAlterCatalogProperties is called when production alterCatalogProperties is exited. +func (s *BaseDorisParserListener) ExitAlterCatalogProperties(ctx *AlterCatalogPropertiesContext) {} + +// EnterAlterWorkloadPolicy is called when production alterWorkloadPolicy is entered. +func (s *BaseDorisParserListener) EnterAlterWorkloadPolicy(ctx *AlterWorkloadPolicyContext) {} + +// ExitAlterWorkloadPolicy is called when production alterWorkloadPolicy is exited. +func (s *BaseDorisParserListener) ExitAlterWorkloadPolicy(ctx *AlterWorkloadPolicyContext) {} + +// EnterAlterSqlBlockRule is called when production alterSqlBlockRule is entered. +func (s *BaseDorisParserListener) EnterAlterSqlBlockRule(ctx *AlterSqlBlockRuleContext) {} + +// ExitAlterSqlBlockRule is called when production alterSqlBlockRule is exited. +func (s *BaseDorisParserListener) ExitAlterSqlBlockRule(ctx *AlterSqlBlockRuleContext) {} + +// EnterAlterCatalogComment is called when production alterCatalogComment is entered. +func (s *BaseDorisParserListener) EnterAlterCatalogComment(ctx *AlterCatalogCommentContext) {} + +// ExitAlterCatalogComment is called when production alterCatalogComment is exited. +func (s *BaseDorisParserListener) ExitAlterCatalogComment(ctx *AlterCatalogCommentContext) {} + +// EnterAlterDatabaseRename is called when production alterDatabaseRename is entered. +func (s *BaseDorisParserListener) EnterAlterDatabaseRename(ctx *AlterDatabaseRenameContext) {} + +// ExitAlterDatabaseRename is called when production alterDatabaseRename is exited. +func (s *BaseDorisParserListener) ExitAlterDatabaseRename(ctx *AlterDatabaseRenameContext) {} + +// EnterAlterStoragePolicy is called when production alterStoragePolicy is entered. +func (s *BaseDorisParserListener) EnterAlterStoragePolicy(ctx *AlterStoragePolicyContext) {} + +// ExitAlterStoragePolicy is called when production alterStoragePolicy is exited. +func (s *BaseDorisParserListener) ExitAlterStoragePolicy(ctx *AlterStoragePolicyContext) {} + +// EnterAlterTable is called when production alterTable is entered. +func (s *BaseDorisParserListener) EnterAlterTable(ctx *AlterTableContext) {} + +// ExitAlterTable is called when production alterTable is exited. +func (s *BaseDorisParserListener) ExitAlterTable(ctx *AlterTableContext) {} + +// EnterAlterTableExecute is called when production alterTableExecute is entered. +func (s *BaseDorisParserListener) EnterAlterTableExecute(ctx *AlterTableExecuteContext) {} + +// ExitAlterTableExecute is called when production alterTableExecute is exited. +func (s *BaseDorisParserListener) ExitAlterTableExecute(ctx *AlterTableExecuteContext) {} + +// EnterAlterTableAddRollup is called when production alterTableAddRollup is entered. +func (s *BaseDorisParserListener) EnterAlterTableAddRollup(ctx *AlterTableAddRollupContext) {} + +// ExitAlterTableAddRollup is called when production alterTableAddRollup is exited. +func (s *BaseDorisParserListener) ExitAlterTableAddRollup(ctx *AlterTableAddRollupContext) {} + +// EnterAlterTableDropRollup is called when production alterTableDropRollup is entered. +func (s *BaseDorisParserListener) EnterAlterTableDropRollup(ctx *AlterTableDropRollupContext) {} + +// ExitAlterTableDropRollup is called when production alterTableDropRollup is exited. +func (s *BaseDorisParserListener) ExitAlterTableDropRollup(ctx *AlterTableDropRollupContext) {} + +// EnterAlterTableProperties is called when production alterTableProperties is entered. +func (s *BaseDorisParserListener) EnterAlterTableProperties(ctx *AlterTablePropertiesContext) {} + +// ExitAlterTableProperties is called when production alterTableProperties is exited. +func (s *BaseDorisParserListener) ExitAlterTableProperties(ctx *AlterTablePropertiesContext) {} + +// EnterAlterDatabaseSetQuota is called when production alterDatabaseSetQuota is entered. +func (s *BaseDorisParserListener) EnterAlterDatabaseSetQuota(ctx *AlterDatabaseSetQuotaContext) {} + +// ExitAlterDatabaseSetQuota is called when production alterDatabaseSetQuota is exited. +func (s *BaseDorisParserListener) ExitAlterDatabaseSetQuota(ctx *AlterDatabaseSetQuotaContext) {} + +// EnterAlterDatabaseProperties is called when production alterDatabaseProperties is entered. +func (s *BaseDorisParserListener) EnterAlterDatabaseProperties(ctx *AlterDatabasePropertiesContext) {} + +// ExitAlterDatabaseProperties is called when production alterDatabaseProperties is exited. +func (s *BaseDorisParserListener) ExitAlterDatabaseProperties(ctx *AlterDatabasePropertiesContext) {} + +// EnterAlterSystemRenameComputeGroup is called when production alterSystemRenameComputeGroup is entered. +func (s *BaseDorisParserListener) EnterAlterSystemRenameComputeGroup(ctx *AlterSystemRenameComputeGroupContext) { +} + +// ExitAlterSystemRenameComputeGroup is called when production alterSystemRenameComputeGroup is exited. +func (s *BaseDorisParserListener) ExitAlterSystemRenameComputeGroup(ctx *AlterSystemRenameComputeGroupContext) { +} + +// EnterAlterResource is called when production alterResource is entered. +func (s *BaseDorisParserListener) EnterAlterResource(ctx *AlterResourceContext) {} + +// ExitAlterResource is called when production alterResource is exited. +func (s *BaseDorisParserListener) ExitAlterResource(ctx *AlterResourceContext) {} + +// EnterAlterRepository is called when production alterRepository is entered. +func (s *BaseDorisParserListener) EnterAlterRepository(ctx *AlterRepositoryContext) {} + +// ExitAlterRepository is called when production alterRepository is exited. +func (s *BaseDorisParserListener) ExitAlterRepository(ctx *AlterRepositoryContext) {} + +// EnterAlterRoutineLoad is called when production alterRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterAlterRoutineLoad(ctx *AlterRoutineLoadContext) {} + +// ExitAlterRoutineLoad is called when production alterRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitAlterRoutineLoad(ctx *AlterRoutineLoadContext) {} + +// EnterAlterColocateGroup is called when production alterColocateGroup is entered. +func (s *BaseDorisParserListener) EnterAlterColocateGroup(ctx *AlterColocateGroupContext) {} + +// ExitAlterColocateGroup is called when production alterColocateGroup is exited. +func (s *BaseDorisParserListener) ExitAlterColocateGroup(ctx *AlterColocateGroupContext) {} + +// EnterAlterUser is called when production alterUser is entered. +func (s *BaseDorisParserListener) EnterAlterUser(ctx *AlterUserContext) {} + +// ExitAlterUser is called when production alterUser is exited. +func (s *BaseDorisParserListener) ExitAlterUser(ctx *AlterUserContext) {} + +// EnterDropCatalogRecycleBin is called when production dropCatalogRecycleBin is entered. +func (s *BaseDorisParserListener) EnterDropCatalogRecycleBin(ctx *DropCatalogRecycleBinContext) {} + +// ExitDropCatalogRecycleBin is called when production dropCatalogRecycleBin is exited. +func (s *BaseDorisParserListener) ExitDropCatalogRecycleBin(ctx *DropCatalogRecycleBinContext) {} + +// EnterDropEncryptkey is called when production dropEncryptkey is entered. +func (s *BaseDorisParserListener) EnterDropEncryptkey(ctx *DropEncryptkeyContext) {} + +// ExitDropEncryptkey is called when production dropEncryptkey is exited. +func (s *BaseDorisParserListener) ExitDropEncryptkey(ctx *DropEncryptkeyContext) {} + +// EnterDropRole is called when production dropRole is entered. +func (s *BaseDorisParserListener) EnterDropRole(ctx *DropRoleContext) {} + +// ExitDropRole is called when production dropRole is exited. +func (s *BaseDorisParserListener) ExitDropRole(ctx *DropRoleContext) {} + +// EnterDropSqlBlockRule is called when production dropSqlBlockRule is entered. +func (s *BaseDorisParserListener) EnterDropSqlBlockRule(ctx *DropSqlBlockRuleContext) {} + +// ExitDropSqlBlockRule is called when production dropSqlBlockRule is exited. +func (s *BaseDorisParserListener) ExitDropSqlBlockRule(ctx *DropSqlBlockRuleContext) {} + +// EnterDropUser is called when production dropUser is entered. +func (s *BaseDorisParserListener) EnterDropUser(ctx *DropUserContext) {} + +// ExitDropUser is called when production dropUser is exited. +func (s *BaseDorisParserListener) ExitDropUser(ctx *DropUserContext) {} + +// EnterDropStoragePolicy is called when production dropStoragePolicy is entered. +func (s *BaseDorisParserListener) EnterDropStoragePolicy(ctx *DropStoragePolicyContext) {} + +// ExitDropStoragePolicy is called when production dropStoragePolicy is exited. +func (s *BaseDorisParserListener) ExitDropStoragePolicy(ctx *DropStoragePolicyContext) {} + +// EnterDropWorkloadGroup is called when production dropWorkloadGroup is entered. +func (s *BaseDorisParserListener) EnterDropWorkloadGroup(ctx *DropWorkloadGroupContext) {} + +// ExitDropWorkloadGroup is called when production dropWorkloadGroup is exited. +func (s *BaseDorisParserListener) ExitDropWorkloadGroup(ctx *DropWorkloadGroupContext) {} + +// EnterDropCatalog is called when production dropCatalog is entered. +func (s *BaseDorisParserListener) EnterDropCatalog(ctx *DropCatalogContext) {} + +// ExitDropCatalog is called when production dropCatalog is exited. +func (s *BaseDorisParserListener) ExitDropCatalog(ctx *DropCatalogContext) {} + +// EnterDropFile is called when production dropFile is entered. +func (s *BaseDorisParserListener) EnterDropFile(ctx *DropFileContext) {} + +// ExitDropFile is called when production dropFile is exited. +func (s *BaseDorisParserListener) ExitDropFile(ctx *DropFileContext) {} + +// EnterDropWorkloadPolicy is called when production dropWorkloadPolicy is entered. +func (s *BaseDorisParserListener) EnterDropWorkloadPolicy(ctx *DropWorkloadPolicyContext) {} + +// ExitDropWorkloadPolicy is called when production dropWorkloadPolicy is exited. +func (s *BaseDorisParserListener) ExitDropWorkloadPolicy(ctx *DropWorkloadPolicyContext) {} + +// EnterDropRepository is called when production dropRepository is entered. +func (s *BaseDorisParserListener) EnterDropRepository(ctx *DropRepositoryContext) {} + +// ExitDropRepository is called when production dropRepository is exited. +func (s *BaseDorisParserListener) ExitDropRepository(ctx *DropRepositoryContext) {} + +// EnterDropTable is called when production dropTable is entered. +func (s *BaseDorisParserListener) EnterDropTable(ctx *DropTableContext) {} + +// ExitDropTable is called when production dropTable is exited. +func (s *BaseDorisParserListener) ExitDropTable(ctx *DropTableContext) {} + +// EnterDropDatabase is called when production dropDatabase is entered. +func (s *BaseDorisParserListener) EnterDropDatabase(ctx *DropDatabaseContext) {} + +// ExitDropDatabase is called when production dropDatabase is exited. +func (s *BaseDorisParserListener) ExitDropDatabase(ctx *DropDatabaseContext) {} + +// EnterDropFunction is called when production dropFunction is entered. +func (s *BaseDorisParserListener) EnterDropFunction(ctx *DropFunctionContext) {} + +// ExitDropFunction is called when production dropFunction is exited. +func (s *BaseDorisParserListener) ExitDropFunction(ctx *DropFunctionContext) {} + +// EnterDropIndex is called when production dropIndex is entered. +func (s *BaseDorisParserListener) EnterDropIndex(ctx *DropIndexContext) {} + +// ExitDropIndex is called when production dropIndex is exited. +func (s *BaseDorisParserListener) ExitDropIndex(ctx *DropIndexContext) {} + +// EnterDropResource is called when production dropResource is entered. +func (s *BaseDorisParserListener) EnterDropResource(ctx *DropResourceContext) {} + +// ExitDropResource is called when production dropResource is exited. +func (s *BaseDorisParserListener) ExitDropResource(ctx *DropResourceContext) {} + +// EnterDropRowPolicy is called when production dropRowPolicy is entered. +func (s *BaseDorisParserListener) EnterDropRowPolicy(ctx *DropRowPolicyContext) {} + +// ExitDropRowPolicy is called when production dropRowPolicy is exited. +func (s *BaseDorisParserListener) ExitDropRowPolicy(ctx *DropRowPolicyContext) {} + +// EnterDropDictionary is called when production dropDictionary is entered. +func (s *BaseDorisParserListener) EnterDropDictionary(ctx *DropDictionaryContext) {} + +// ExitDropDictionary is called when production dropDictionary is exited. +func (s *BaseDorisParserListener) ExitDropDictionary(ctx *DropDictionaryContext) {} + +// EnterDropStage is called when production dropStage is entered. +func (s *BaseDorisParserListener) EnterDropStage(ctx *DropStageContext) {} + +// ExitDropStage is called when production dropStage is exited. +func (s *BaseDorisParserListener) ExitDropStage(ctx *DropStageContext) {} + +// EnterDropView is called when production dropView is entered. +func (s *BaseDorisParserListener) EnterDropView(ctx *DropViewContext) {} + +// ExitDropView is called when production dropView is exited. +func (s *BaseDorisParserListener) ExitDropView(ctx *DropViewContext) {} + +// EnterDropIndexAnalyzer is called when production dropIndexAnalyzer is entered. +func (s *BaseDorisParserListener) EnterDropIndexAnalyzer(ctx *DropIndexAnalyzerContext) {} + +// ExitDropIndexAnalyzer is called when production dropIndexAnalyzer is exited. +func (s *BaseDorisParserListener) ExitDropIndexAnalyzer(ctx *DropIndexAnalyzerContext) {} + +// EnterDropIndexTokenizer is called when production dropIndexTokenizer is entered. +func (s *BaseDorisParserListener) EnterDropIndexTokenizer(ctx *DropIndexTokenizerContext) {} + +// ExitDropIndexTokenizer is called when production dropIndexTokenizer is exited. +func (s *BaseDorisParserListener) ExitDropIndexTokenizer(ctx *DropIndexTokenizerContext) {} + +// EnterDropIndexTokenFilter is called when production dropIndexTokenFilter is entered. +func (s *BaseDorisParserListener) EnterDropIndexTokenFilter(ctx *DropIndexTokenFilterContext) {} + +// ExitDropIndexTokenFilter is called when production dropIndexTokenFilter is exited. +func (s *BaseDorisParserListener) ExitDropIndexTokenFilter(ctx *DropIndexTokenFilterContext) {} + +// EnterDropIndexCharFilter is called when production dropIndexCharFilter is entered. +func (s *BaseDorisParserListener) EnterDropIndexCharFilter(ctx *DropIndexCharFilterContext) {} + +// ExitDropIndexCharFilter is called when production dropIndexCharFilter is exited. +func (s *BaseDorisParserListener) ExitDropIndexCharFilter(ctx *DropIndexCharFilterContext) {} + +// EnterShowVariables is called when production showVariables is entered. +func (s *BaseDorisParserListener) EnterShowVariables(ctx *ShowVariablesContext) {} + +// ExitShowVariables is called when production showVariables is exited. +func (s *BaseDorisParserListener) ExitShowVariables(ctx *ShowVariablesContext) {} + +// EnterShowAuthors is called when production showAuthors is entered. +func (s *BaseDorisParserListener) EnterShowAuthors(ctx *ShowAuthorsContext) {} + +// ExitShowAuthors is called when production showAuthors is exited. +func (s *BaseDorisParserListener) ExitShowAuthors(ctx *ShowAuthorsContext) {} + +// EnterShowAlterTable is called when production showAlterTable is entered. +func (s *BaseDorisParserListener) EnterShowAlterTable(ctx *ShowAlterTableContext) {} + +// ExitShowAlterTable is called when production showAlterTable is exited. +func (s *BaseDorisParserListener) ExitShowAlterTable(ctx *ShowAlterTableContext) {} + +// EnterShowCreateDatabase is called when production showCreateDatabase is entered. +func (s *BaseDorisParserListener) EnterShowCreateDatabase(ctx *ShowCreateDatabaseContext) {} + +// ExitShowCreateDatabase is called when production showCreateDatabase is exited. +func (s *BaseDorisParserListener) ExitShowCreateDatabase(ctx *ShowCreateDatabaseContext) {} + +// EnterShowBackup is called when production showBackup is entered. +func (s *BaseDorisParserListener) EnterShowBackup(ctx *ShowBackupContext) {} + +// ExitShowBackup is called when production showBackup is exited. +func (s *BaseDorisParserListener) ExitShowBackup(ctx *ShowBackupContext) {} + +// EnterShowBroker is called when production showBroker is entered. +func (s *BaseDorisParserListener) EnterShowBroker(ctx *ShowBrokerContext) {} + +// ExitShowBroker is called when production showBroker is exited. +func (s *BaseDorisParserListener) ExitShowBroker(ctx *ShowBrokerContext) {} + +// EnterShowBuildIndex is called when production showBuildIndex is entered. +func (s *BaseDorisParserListener) EnterShowBuildIndex(ctx *ShowBuildIndexContext) {} + +// ExitShowBuildIndex is called when production showBuildIndex is exited. +func (s *BaseDorisParserListener) ExitShowBuildIndex(ctx *ShowBuildIndexContext) {} + +// EnterShowDynamicPartition is called when production showDynamicPartition is entered. +func (s *BaseDorisParserListener) EnterShowDynamicPartition(ctx *ShowDynamicPartitionContext) {} + +// ExitShowDynamicPartition is called when production showDynamicPartition is exited. +func (s *BaseDorisParserListener) ExitShowDynamicPartition(ctx *ShowDynamicPartitionContext) {} + +// EnterShowEvents is called when production showEvents is entered. +func (s *BaseDorisParserListener) EnterShowEvents(ctx *ShowEventsContext) {} + +// ExitShowEvents is called when production showEvents is exited. +func (s *BaseDorisParserListener) ExitShowEvents(ctx *ShowEventsContext) {} + +// EnterShowExport is called when production showExport is entered. +func (s *BaseDorisParserListener) EnterShowExport(ctx *ShowExportContext) {} + +// ExitShowExport is called when production showExport is exited. +func (s *BaseDorisParserListener) ExitShowExport(ctx *ShowExportContext) {} + +// EnterShowLastInsert is called when production showLastInsert is entered. +func (s *BaseDorisParserListener) EnterShowLastInsert(ctx *ShowLastInsertContext) {} + +// ExitShowLastInsert is called when production showLastInsert is exited. +func (s *BaseDorisParserListener) ExitShowLastInsert(ctx *ShowLastInsertContext) {} + +// EnterShowCharset is called when production showCharset is entered. +func (s *BaseDorisParserListener) EnterShowCharset(ctx *ShowCharsetContext) {} + +// ExitShowCharset is called when production showCharset is exited. +func (s *BaseDorisParserListener) ExitShowCharset(ctx *ShowCharsetContext) {} + +// EnterShowDelete is called when production showDelete is entered. +func (s *BaseDorisParserListener) EnterShowDelete(ctx *ShowDeleteContext) {} + +// ExitShowDelete is called when production showDelete is exited. +func (s *BaseDorisParserListener) ExitShowDelete(ctx *ShowDeleteContext) {} + +// EnterShowCreateFunction is called when production showCreateFunction is entered. +func (s *BaseDorisParserListener) EnterShowCreateFunction(ctx *ShowCreateFunctionContext) {} + +// ExitShowCreateFunction is called when production showCreateFunction is exited. +func (s *BaseDorisParserListener) ExitShowCreateFunction(ctx *ShowCreateFunctionContext) {} + +// EnterShowFunctions is called when production showFunctions is entered. +func (s *BaseDorisParserListener) EnterShowFunctions(ctx *ShowFunctionsContext) {} + +// ExitShowFunctions is called when production showFunctions is exited. +func (s *BaseDorisParserListener) ExitShowFunctions(ctx *ShowFunctionsContext) {} + +// EnterShowGlobalFunctions is called when production showGlobalFunctions is entered. +func (s *BaseDorisParserListener) EnterShowGlobalFunctions(ctx *ShowGlobalFunctionsContext) {} + +// ExitShowGlobalFunctions is called when production showGlobalFunctions is exited. +func (s *BaseDorisParserListener) ExitShowGlobalFunctions(ctx *ShowGlobalFunctionsContext) {} + +// EnterShowGrants is called when production showGrants is entered. +func (s *BaseDorisParserListener) EnterShowGrants(ctx *ShowGrantsContext) {} + +// ExitShowGrants is called when production showGrants is exited. +func (s *BaseDorisParserListener) ExitShowGrants(ctx *ShowGrantsContext) {} + +// EnterShowGrantsForUser is called when production showGrantsForUser is entered. +func (s *BaseDorisParserListener) EnterShowGrantsForUser(ctx *ShowGrantsForUserContext) {} + +// ExitShowGrantsForUser is called when production showGrantsForUser is exited. +func (s *BaseDorisParserListener) ExitShowGrantsForUser(ctx *ShowGrantsForUserContext) {} + +// EnterShowCreateUser is called when production showCreateUser is entered. +func (s *BaseDorisParserListener) EnterShowCreateUser(ctx *ShowCreateUserContext) {} + +// ExitShowCreateUser is called when production showCreateUser is exited. +func (s *BaseDorisParserListener) ExitShowCreateUser(ctx *ShowCreateUserContext) {} + +// EnterShowSnapshot is called when production showSnapshot is entered. +func (s *BaseDorisParserListener) EnterShowSnapshot(ctx *ShowSnapshotContext) {} + +// ExitShowSnapshot is called when production showSnapshot is exited. +func (s *BaseDorisParserListener) ExitShowSnapshot(ctx *ShowSnapshotContext) {} + +// EnterShowLoadProfile is called when production showLoadProfile is entered. +func (s *BaseDorisParserListener) EnterShowLoadProfile(ctx *ShowLoadProfileContext) {} + +// ExitShowLoadProfile is called when production showLoadProfile is exited. +func (s *BaseDorisParserListener) ExitShowLoadProfile(ctx *ShowLoadProfileContext) {} + +// EnterShowCreateRepository is called when production showCreateRepository is entered. +func (s *BaseDorisParserListener) EnterShowCreateRepository(ctx *ShowCreateRepositoryContext) {} + +// ExitShowCreateRepository is called when production showCreateRepository is exited. +func (s *BaseDorisParserListener) ExitShowCreateRepository(ctx *ShowCreateRepositoryContext) {} + +// EnterShowView is called when production showView is entered. +func (s *BaseDorisParserListener) EnterShowView(ctx *ShowViewContext) {} + +// ExitShowView is called when production showView is exited. +func (s *BaseDorisParserListener) ExitShowView(ctx *ShowViewContext) {} + +// EnterShowPlugins is called when production showPlugins is entered. +func (s *BaseDorisParserListener) EnterShowPlugins(ctx *ShowPluginsContext) {} + +// ExitShowPlugins is called when production showPlugins is exited. +func (s *BaseDorisParserListener) ExitShowPlugins(ctx *ShowPluginsContext) {} + +// EnterShowStorageVault is called when production showStorageVault is entered. +func (s *BaseDorisParserListener) EnterShowStorageVault(ctx *ShowStorageVaultContext) {} + +// ExitShowStorageVault is called when production showStorageVault is exited. +func (s *BaseDorisParserListener) ExitShowStorageVault(ctx *ShowStorageVaultContext) {} + +// EnterShowRepositories is called when production showRepositories is entered. +func (s *BaseDorisParserListener) EnterShowRepositories(ctx *ShowRepositoriesContext) {} + +// ExitShowRepositories is called when production showRepositories is exited. +func (s *BaseDorisParserListener) ExitShowRepositories(ctx *ShowRepositoriesContext) {} + +// EnterShowEncryptKeys is called when production showEncryptKeys is entered. +func (s *BaseDorisParserListener) EnterShowEncryptKeys(ctx *ShowEncryptKeysContext) {} + +// ExitShowEncryptKeys is called when production showEncryptKeys is exited. +func (s *BaseDorisParserListener) ExitShowEncryptKeys(ctx *ShowEncryptKeysContext) {} + +// EnterShowCreateTable is called when production showCreateTable is entered. +func (s *BaseDorisParserListener) EnterShowCreateTable(ctx *ShowCreateTableContext) {} + +// ExitShowCreateTable is called when production showCreateTable is exited. +func (s *BaseDorisParserListener) ExitShowCreateTable(ctx *ShowCreateTableContext) {} + +// EnterShowProcessList is called when production showProcessList is entered. +func (s *BaseDorisParserListener) EnterShowProcessList(ctx *ShowProcessListContext) {} + +// ExitShowProcessList is called when production showProcessList is exited. +func (s *BaseDorisParserListener) ExitShowProcessList(ctx *ShowProcessListContext) {} + +// EnterShowPartitions is called when production showPartitions is entered. +func (s *BaseDorisParserListener) EnterShowPartitions(ctx *ShowPartitionsContext) {} + +// ExitShowPartitions is called when production showPartitions is exited. +func (s *BaseDorisParserListener) ExitShowPartitions(ctx *ShowPartitionsContext) {} + +// EnterShowRestore is called when production showRestore is entered. +func (s *BaseDorisParserListener) EnterShowRestore(ctx *ShowRestoreContext) {} + +// ExitShowRestore is called when production showRestore is exited. +func (s *BaseDorisParserListener) ExitShowRestore(ctx *ShowRestoreContext) {} + +// EnterShowRoles is called when production showRoles is entered. +func (s *BaseDorisParserListener) EnterShowRoles(ctx *ShowRolesContext) {} + +// ExitShowRoles is called when production showRoles is exited. +func (s *BaseDorisParserListener) ExitShowRoles(ctx *ShowRolesContext) {} + +// EnterShowPartitionId is called when production showPartitionId is entered. +func (s *BaseDorisParserListener) EnterShowPartitionId(ctx *ShowPartitionIdContext) {} + +// ExitShowPartitionId is called when production showPartitionId is exited. +func (s *BaseDorisParserListener) ExitShowPartitionId(ctx *ShowPartitionIdContext) {} + +// EnterShowPrivileges is called when production showPrivileges is entered. +func (s *BaseDorisParserListener) EnterShowPrivileges(ctx *ShowPrivilegesContext) {} + +// ExitShowPrivileges is called when production showPrivileges is exited. +func (s *BaseDorisParserListener) ExitShowPrivileges(ctx *ShowPrivilegesContext) {} + +// EnterShowProc is called when production showProc is entered. +func (s *BaseDorisParserListener) EnterShowProc(ctx *ShowProcContext) {} + +// ExitShowProc is called when production showProc is exited. +func (s *BaseDorisParserListener) ExitShowProc(ctx *ShowProcContext) {} + +// EnterShowSmallFiles is called when production showSmallFiles is entered. +func (s *BaseDorisParserListener) EnterShowSmallFiles(ctx *ShowSmallFilesContext) {} + +// ExitShowSmallFiles is called when production showSmallFiles is exited. +func (s *BaseDorisParserListener) ExitShowSmallFiles(ctx *ShowSmallFilesContext) {} + +// EnterShowStorageEngines is called when production showStorageEngines is entered. +func (s *BaseDorisParserListener) EnterShowStorageEngines(ctx *ShowStorageEnginesContext) {} + +// ExitShowStorageEngines is called when production showStorageEngines is exited. +func (s *BaseDorisParserListener) ExitShowStorageEngines(ctx *ShowStorageEnginesContext) {} + +// EnterShowCreateCatalog is called when production showCreateCatalog is entered. +func (s *BaseDorisParserListener) EnterShowCreateCatalog(ctx *ShowCreateCatalogContext) {} + +// ExitShowCreateCatalog is called when production showCreateCatalog is exited. +func (s *BaseDorisParserListener) ExitShowCreateCatalog(ctx *ShowCreateCatalogContext) {} + +// EnterShowCatalog is called when production showCatalog is entered. +func (s *BaseDorisParserListener) EnterShowCatalog(ctx *ShowCatalogContext) {} + +// ExitShowCatalog is called when production showCatalog is exited. +func (s *BaseDorisParserListener) ExitShowCatalog(ctx *ShowCatalogContext) {} + +// EnterShowCatalogs is called when production showCatalogs is entered. +func (s *BaseDorisParserListener) EnterShowCatalogs(ctx *ShowCatalogsContext) {} + +// ExitShowCatalogs is called when production showCatalogs is exited. +func (s *BaseDorisParserListener) ExitShowCatalogs(ctx *ShowCatalogsContext) {} + +// EnterShowUserProperties is called when production showUserProperties is entered. +func (s *BaseDorisParserListener) EnterShowUserProperties(ctx *ShowUserPropertiesContext) {} + +// ExitShowUserProperties is called when production showUserProperties is exited. +func (s *BaseDorisParserListener) ExitShowUserProperties(ctx *ShowUserPropertiesContext) {} + +// EnterShowAllProperties is called when production showAllProperties is entered. +func (s *BaseDorisParserListener) EnterShowAllProperties(ctx *ShowAllPropertiesContext) {} + +// ExitShowAllProperties is called when production showAllProperties is exited. +func (s *BaseDorisParserListener) ExitShowAllProperties(ctx *ShowAllPropertiesContext) {} + +// EnterShowCollation is called when production showCollation is entered. +func (s *BaseDorisParserListener) EnterShowCollation(ctx *ShowCollationContext) {} + +// ExitShowCollation is called when production showCollation is exited. +func (s *BaseDorisParserListener) ExitShowCollation(ctx *ShowCollationContext) {} + +// EnterShowRowPolicy is called when production showRowPolicy is entered. +func (s *BaseDorisParserListener) EnterShowRowPolicy(ctx *ShowRowPolicyContext) {} + +// ExitShowRowPolicy is called when production showRowPolicy is exited. +func (s *BaseDorisParserListener) ExitShowRowPolicy(ctx *ShowRowPolicyContext) {} + +// EnterShowStoragePolicy is called when production showStoragePolicy is entered. +func (s *BaseDorisParserListener) EnterShowStoragePolicy(ctx *ShowStoragePolicyContext) {} + +// ExitShowStoragePolicy is called when production showStoragePolicy is exited. +func (s *BaseDorisParserListener) ExitShowStoragePolicy(ctx *ShowStoragePolicyContext) {} + +// EnterShowSqlBlockRule is called when production showSqlBlockRule is entered. +func (s *BaseDorisParserListener) EnterShowSqlBlockRule(ctx *ShowSqlBlockRuleContext) {} + +// ExitShowSqlBlockRule is called when production showSqlBlockRule is exited. +func (s *BaseDorisParserListener) ExitShowSqlBlockRule(ctx *ShowSqlBlockRuleContext) {} + +// EnterShowCreateView is called when production showCreateView is entered. +func (s *BaseDorisParserListener) EnterShowCreateView(ctx *ShowCreateViewContext) {} + +// ExitShowCreateView is called when production showCreateView is exited. +func (s *BaseDorisParserListener) ExitShowCreateView(ctx *ShowCreateViewContext) {} + +// EnterShowCreateStorageVault is called when production showCreateStorageVault is entered. +func (s *BaseDorisParserListener) EnterShowCreateStorageVault(ctx *ShowCreateStorageVaultContext) {} + +// ExitShowCreateStorageVault is called when production showCreateStorageVault is exited. +func (s *BaseDorisParserListener) ExitShowCreateStorageVault(ctx *ShowCreateStorageVaultContext) {} + +// EnterShowDataTypes is called when production showDataTypes is entered. +func (s *BaseDorisParserListener) EnterShowDataTypes(ctx *ShowDataTypesContext) {} + +// ExitShowDataTypes is called when production showDataTypes is exited. +func (s *BaseDorisParserListener) ExitShowDataTypes(ctx *ShowDataTypesContext) {} + +// EnterShowData is called when production showData is entered. +func (s *BaseDorisParserListener) EnterShowData(ctx *ShowDataContext) {} + +// ExitShowData is called when production showData is exited. +func (s *BaseDorisParserListener) ExitShowData(ctx *ShowDataContext) {} + +// EnterShowCreateMaterializedView is called when production showCreateMaterializedView is entered. +func (s *BaseDorisParserListener) EnterShowCreateMaterializedView(ctx *ShowCreateMaterializedViewContext) { +} + +// ExitShowCreateMaterializedView is called when production showCreateMaterializedView is exited. +func (s *BaseDorisParserListener) ExitShowCreateMaterializedView(ctx *ShowCreateMaterializedViewContext) { +} + +// EnterShowWarningErrors is called when production showWarningErrors is entered. +func (s *BaseDorisParserListener) EnterShowWarningErrors(ctx *ShowWarningErrorsContext) {} + +// ExitShowWarningErrors is called when production showWarningErrors is exited. +func (s *BaseDorisParserListener) ExitShowWarningErrors(ctx *ShowWarningErrorsContext) {} + +// EnterShowWarningErrorCount is called when production showWarningErrorCount is entered. +func (s *BaseDorisParserListener) EnterShowWarningErrorCount(ctx *ShowWarningErrorCountContext) {} + +// ExitShowWarningErrorCount is called when production showWarningErrorCount is exited. +func (s *BaseDorisParserListener) ExitShowWarningErrorCount(ctx *ShowWarningErrorCountContext) {} + +// EnterShowBackends is called when production showBackends is entered. +func (s *BaseDorisParserListener) EnterShowBackends(ctx *ShowBackendsContext) {} + +// ExitShowBackends is called when production showBackends is exited. +func (s *BaseDorisParserListener) ExitShowBackends(ctx *ShowBackendsContext) {} + +// EnterShowStages is called when production showStages is entered. +func (s *BaseDorisParserListener) EnterShowStages(ctx *ShowStagesContext) {} + +// ExitShowStages is called when production showStages is exited. +func (s *BaseDorisParserListener) ExitShowStages(ctx *ShowStagesContext) {} + +// EnterShowReplicaDistribution is called when production showReplicaDistribution is entered. +func (s *BaseDorisParserListener) EnterShowReplicaDistribution(ctx *ShowReplicaDistributionContext) {} + +// ExitShowReplicaDistribution is called when production showReplicaDistribution is exited. +func (s *BaseDorisParserListener) ExitShowReplicaDistribution(ctx *ShowReplicaDistributionContext) {} + +// EnterShowResources is called when production showResources is entered. +func (s *BaseDorisParserListener) EnterShowResources(ctx *ShowResourcesContext) {} + +// ExitShowResources is called when production showResources is exited. +func (s *BaseDorisParserListener) ExitShowResources(ctx *ShowResourcesContext) {} + +// EnterShowLoad is called when production showLoad is entered. +func (s *BaseDorisParserListener) EnterShowLoad(ctx *ShowLoadContext) {} + +// ExitShowLoad is called when production showLoad is exited. +func (s *BaseDorisParserListener) ExitShowLoad(ctx *ShowLoadContext) {} + +// EnterShowLoadWarings is called when production showLoadWarings is entered. +func (s *BaseDorisParserListener) EnterShowLoadWarings(ctx *ShowLoadWaringsContext) {} + +// ExitShowLoadWarings is called when production showLoadWarings is exited. +func (s *BaseDorisParserListener) ExitShowLoadWarings(ctx *ShowLoadWaringsContext) {} + +// EnterShowTriggers is called when production showTriggers is entered. +func (s *BaseDorisParserListener) EnterShowTriggers(ctx *ShowTriggersContext) {} + +// ExitShowTriggers is called when production showTriggers is exited. +func (s *BaseDorisParserListener) ExitShowTriggers(ctx *ShowTriggersContext) {} + +// EnterShowDiagnoseTablet is called when production showDiagnoseTablet is entered. +func (s *BaseDorisParserListener) EnterShowDiagnoseTablet(ctx *ShowDiagnoseTabletContext) {} + +// ExitShowDiagnoseTablet is called when production showDiagnoseTablet is exited. +func (s *BaseDorisParserListener) ExitShowDiagnoseTablet(ctx *ShowDiagnoseTabletContext) {} + +// EnterShowOpenTables is called when production showOpenTables is entered. +func (s *BaseDorisParserListener) EnterShowOpenTables(ctx *ShowOpenTablesContext) {} + +// ExitShowOpenTables is called when production showOpenTables is exited. +func (s *BaseDorisParserListener) ExitShowOpenTables(ctx *ShowOpenTablesContext) {} + +// EnterShowFrontends is called when production showFrontends is entered. +func (s *BaseDorisParserListener) EnterShowFrontends(ctx *ShowFrontendsContext) {} + +// ExitShowFrontends is called when production showFrontends is exited. +func (s *BaseDorisParserListener) ExitShowFrontends(ctx *ShowFrontendsContext) {} + +// EnterShowDatabaseId is called when production showDatabaseId is entered. +func (s *BaseDorisParserListener) EnterShowDatabaseId(ctx *ShowDatabaseIdContext) {} + +// ExitShowDatabaseId is called when production showDatabaseId is exited. +func (s *BaseDorisParserListener) ExitShowDatabaseId(ctx *ShowDatabaseIdContext) {} + +// EnterShowColumns is called when production showColumns is entered. +func (s *BaseDorisParserListener) EnterShowColumns(ctx *ShowColumnsContext) {} + +// ExitShowColumns is called when production showColumns is exited. +func (s *BaseDorisParserListener) ExitShowColumns(ctx *ShowColumnsContext) {} + +// EnterShowTableId is called when production showTableId is entered. +func (s *BaseDorisParserListener) EnterShowTableId(ctx *ShowTableIdContext) {} + +// ExitShowTableId is called when production showTableId is exited. +func (s *BaseDorisParserListener) ExitShowTableId(ctx *ShowTableIdContext) {} + +// EnterShowTrash is called when production showTrash is entered. +func (s *BaseDorisParserListener) EnterShowTrash(ctx *ShowTrashContext) {} + +// ExitShowTrash is called when production showTrash is exited. +func (s *BaseDorisParserListener) ExitShowTrash(ctx *ShowTrashContext) {} + +// EnterShowTypeCast is called when production showTypeCast is entered. +func (s *BaseDorisParserListener) EnterShowTypeCast(ctx *ShowTypeCastContext) {} + +// ExitShowTypeCast is called when production showTypeCast is exited. +func (s *BaseDorisParserListener) ExitShowTypeCast(ctx *ShowTypeCastContext) {} + +// EnterShowClusters is called when production showClusters is entered. +func (s *BaseDorisParserListener) EnterShowClusters(ctx *ShowClustersContext) {} + +// ExitShowClusters is called when production showClusters is exited. +func (s *BaseDorisParserListener) ExitShowClusters(ctx *ShowClustersContext) {} + +// EnterShowStatus is called when production showStatus is entered. +func (s *BaseDorisParserListener) EnterShowStatus(ctx *ShowStatusContext) {} + +// ExitShowStatus is called when production showStatus is exited. +func (s *BaseDorisParserListener) ExitShowStatus(ctx *ShowStatusContext) {} + +// EnterShowWhitelist is called when production showWhitelist is entered. +func (s *BaseDorisParserListener) EnterShowWhitelist(ctx *ShowWhitelistContext) {} + +// ExitShowWhitelist is called when production showWhitelist is exited. +func (s *BaseDorisParserListener) ExitShowWhitelist(ctx *ShowWhitelistContext) {} + +// EnterShowTabletsBelong is called when production showTabletsBelong is entered. +func (s *BaseDorisParserListener) EnterShowTabletsBelong(ctx *ShowTabletsBelongContext) {} + +// ExitShowTabletsBelong is called when production showTabletsBelong is exited. +func (s *BaseDorisParserListener) ExitShowTabletsBelong(ctx *ShowTabletsBelongContext) {} + +// EnterShowDataSkew is called when production showDataSkew is entered. +func (s *BaseDorisParserListener) EnterShowDataSkew(ctx *ShowDataSkewContext) {} + +// ExitShowDataSkew is called when production showDataSkew is exited. +func (s *BaseDorisParserListener) ExitShowDataSkew(ctx *ShowDataSkewContext) {} + +// EnterShowTableCreation is called when production showTableCreation is entered. +func (s *BaseDorisParserListener) EnterShowTableCreation(ctx *ShowTableCreationContext) {} + +// ExitShowTableCreation is called when production showTableCreation is exited. +func (s *BaseDorisParserListener) ExitShowTableCreation(ctx *ShowTableCreationContext) {} + +// EnterShowTabletStorageFormat is called when production showTabletStorageFormat is entered. +func (s *BaseDorisParserListener) EnterShowTabletStorageFormat(ctx *ShowTabletStorageFormatContext) {} + +// ExitShowTabletStorageFormat is called when production showTabletStorageFormat is exited. +func (s *BaseDorisParserListener) ExitShowTabletStorageFormat(ctx *ShowTabletStorageFormatContext) {} + +// EnterShowQueryProfile is called when production showQueryProfile is entered. +func (s *BaseDorisParserListener) EnterShowQueryProfile(ctx *ShowQueryProfileContext) {} + +// ExitShowQueryProfile is called when production showQueryProfile is exited. +func (s *BaseDorisParserListener) ExitShowQueryProfile(ctx *ShowQueryProfileContext) {} + +// EnterShowConvertLsc is called when production showConvertLsc is entered. +func (s *BaseDorisParserListener) EnterShowConvertLsc(ctx *ShowConvertLscContext) {} + +// ExitShowConvertLsc is called when production showConvertLsc is exited. +func (s *BaseDorisParserListener) ExitShowConvertLsc(ctx *ShowConvertLscContext) {} + +// EnterShowTables is called when production showTables is entered. +func (s *BaseDorisParserListener) EnterShowTables(ctx *ShowTablesContext) {} + +// ExitShowTables is called when production showTables is exited. +func (s *BaseDorisParserListener) ExitShowTables(ctx *ShowTablesContext) {} + +// EnterShowViews is called when production showViews is entered. +func (s *BaseDorisParserListener) EnterShowViews(ctx *ShowViewsContext) {} + +// ExitShowViews is called when production showViews is exited. +func (s *BaseDorisParserListener) ExitShowViews(ctx *ShowViewsContext) {} + +// EnterShowTableStatus is called when production showTableStatus is entered. +func (s *BaseDorisParserListener) EnterShowTableStatus(ctx *ShowTableStatusContext) {} + +// ExitShowTableStatus is called when production showTableStatus is exited. +func (s *BaseDorisParserListener) ExitShowTableStatus(ctx *ShowTableStatusContext) {} + +// EnterShowDatabases is called when production showDatabases is entered. +func (s *BaseDorisParserListener) EnterShowDatabases(ctx *ShowDatabasesContext) {} + +// ExitShowDatabases is called when production showDatabases is exited. +func (s *BaseDorisParserListener) ExitShowDatabases(ctx *ShowDatabasesContext) {} + +// EnterShowTabletsFromTable is called when production showTabletsFromTable is entered. +func (s *BaseDorisParserListener) EnterShowTabletsFromTable(ctx *ShowTabletsFromTableContext) {} + +// ExitShowTabletsFromTable is called when production showTabletsFromTable is exited. +func (s *BaseDorisParserListener) ExitShowTabletsFromTable(ctx *ShowTabletsFromTableContext) {} + +// EnterShowCatalogRecycleBin is called when production showCatalogRecycleBin is entered. +func (s *BaseDorisParserListener) EnterShowCatalogRecycleBin(ctx *ShowCatalogRecycleBinContext) {} + +// ExitShowCatalogRecycleBin is called when production showCatalogRecycleBin is exited. +func (s *BaseDorisParserListener) ExitShowCatalogRecycleBin(ctx *ShowCatalogRecycleBinContext) {} + +// EnterShowTabletId is called when production showTabletId is entered. +func (s *BaseDorisParserListener) EnterShowTabletId(ctx *ShowTabletIdContext) {} + +// ExitShowTabletId is called when production showTabletId is exited. +func (s *BaseDorisParserListener) ExitShowTabletId(ctx *ShowTabletIdContext) {} + +// EnterShowDictionaries is called when production showDictionaries is entered. +func (s *BaseDorisParserListener) EnterShowDictionaries(ctx *ShowDictionariesContext) {} + +// ExitShowDictionaries is called when production showDictionaries is exited. +func (s *BaseDorisParserListener) ExitShowDictionaries(ctx *ShowDictionariesContext) {} + +// EnterShowTransaction is called when production showTransaction is entered. +func (s *BaseDorisParserListener) EnterShowTransaction(ctx *ShowTransactionContext) {} + +// ExitShowTransaction is called when production showTransaction is exited. +func (s *BaseDorisParserListener) ExitShowTransaction(ctx *ShowTransactionContext) {} + +// EnterShowReplicaStatus is called when production showReplicaStatus is entered. +func (s *BaseDorisParserListener) EnterShowReplicaStatus(ctx *ShowReplicaStatusContext) {} + +// ExitShowReplicaStatus is called when production showReplicaStatus is exited. +func (s *BaseDorisParserListener) ExitShowReplicaStatus(ctx *ShowReplicaStatusContext) {} + +// EnterShowWorkloadGroups is called when production showWorkloadGroups is entered. +func (s *BaseDorisParserListener) EnterShowWorkloadGroups(ctx *ShowWorkloadGroupsContext) {} + +// ExitShowWorkloadGroups is called when production showWorkloadGroups is exited. +func (s *BaseDorisParserListener) ExitShowWorkloadGroups(ctx *ShowWorkloadGroupsContext) {} + +// EnterShowCopy is called when production showCopy is entered. +func (s *BaseDorisParserListener) EnterShowCopy(ctx *ShowCopyContext) {} + +// ExitShowCopy is called when production showCopy is exited. +func (s *BaseDorisParserListener) ExitShowCopy(ctx *ShowCopyContext) {} + +// EnterShowQueryStats is called when production showQueryStats is entered. +func (s *BaseDorisParserListener) EnterShowQueryStats(ctx *ShowQueryStatsContext) {} + +// ExitShowQueryStats is called when production showQueryStats is exited. +func (s *BaseDorisParserListener) ExitShowQueryStats(ctx *ShowQueryStatsContext) {} + +// EnterShowIndex is called when production showIndex is entered. +func (s *BaseDorisParserListener) EnterShowIndex(ctx *ShowIndexContext) {} + +// ExitShowIndex is called when production showIndex is exited. +func (s *BaseDorisParserListener) ExitShowIndex(ctx *ShowIndexContext) {} + +// EnterShowWarmUpJob is called when production showWarmUpJob is entered. +func (s *BaseDorisParserListener) EnterShowWarmUpJob(ctx *ShowWarmUpJobContext) {} + +// ExitShowWarmUpJob is called when production showWarmUpJob is exited. +func (s *BaseDorisParserListener) ExitShowWarmUpJob(ctx *ShowWarmUpJobContext) {} + +// EnterSync is called when production sync is entered. +func (s *BaseDorisParserListener) EnterSync(ctx *SyncContext) {} + +// ExitSync is called when production sync is exited. +func (s *BaseDorisParserListener) ExitSync(ctx *SyncContext) {} + +// EnterShowCreateLoad is called when production showCreateLoad is entered. +func (s *BaseDorisParserListener) EnterShowCreateLoad(ctx *ShowCreateLoadContext) {} + +// ExitShowCreateLoad is called when production showCreateLoad is exited. +func (s *BaseDorisParserListener) ExitShowCreateLoad(ctx *ShowCreateLoadContext) {} + +// EnterCreateRoutineLoadAlias is called when production createRoutineLoadAlias is entered. +func (s *BaseDorisParserListener) EnterCreateRoutineLoadAlias(ctx *CreateRoutineLoadAliasContext) {} + +// ExitCreateRoutineLoadAlias is called when production createRoutineLoadAlias is exited. +func (s *BaseDorisParserListener) ExitCreateRoutineLoadAlias(ctx *CreateRoutineLoadAliasContext) {} + +// EnterMysqlLoad is called when production mysqlLoad is entered. +func (s *BaseDorisParserListener) EnterMysqlLoad(ctx *MysqlLoadContext) {} + +// ExitMysqlLoad is called when production mysqlLoad is exited. +func (s *BaseDorisParserListener) ExitMysqlLoad(ctx *MysqlLoadContext) {} + +// EnterShowCreateRoutineLoad is called when production showCreateRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterShowCreateRoutineLoad(ctx *ShowCreateRoutineLoadContext) {} + +// ExitShowCreateRoutineLoad is called when production showCreateRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitShowCreateRoutineLoad(ctx *ShowCreateRoutineLoadContext) {} + +// EnterPauseRoutineLoad is called when production pauseRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterPauseRoutineLoad(ctx *PauseRoutineLoadContext) {} + +// ExitPauseRoutineLoad is called when production pauseRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitPauseRoutineLoad(ctx *PauseRoutineLoadContext) {} + +// EnterPauseAllRoutineLoad is called when production pauseAllRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterPauseAllRoutineLoad(ctx *PauseAllRoutineLoadContext) {} + +// ExitPauseAllRoutineLoad is called when production pauseAllRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitPauseAllRoutineLoad(ctx *PauseAllRoutineLoadContext) {} + +// EnterResumeRoutineLoad is called when production resumeRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterResumeRoutineLoad(ctx *ResumeRoutineLoadContext) {} + +// ExitResumeRoutineLoad is called when production resumeRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitResumeRoutineLoad(ctx *ResumeRoutineLoadContext) {} + +// EnterResumeAllRoutineLoad is called when production resumeAllRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterResumeAllRoutineLoad(ctx *ResumeAllRoutineLoadContext) {} + +// ExitResumeAllRoutineLoad is called when production resumeAllRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitResumeAllRoutineLoad(ctx *ResumeAllRoutineLoadContext) {} + +// EnterStopRoutineLoad is called when production stopRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterStopRoutineLoad(ctx *StopRoutineLoadContext) {} + +// ExitStopRoutineLoad is called when production stopRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitStopRoutineLoad(ctx *StopRoutineLoadContext) {} + +// EnterShowRoutineLoad is called when production showRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterShowRoutineLoad(ctx *ShowRoutineLoadContext) {} + +// ExitShowRoutineLoad is called when production showRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitShowRoutineLoad(ctx *ShowRoutineLoadContext) {} + +// EnterShowRoutineLoadTask is called when production showRoutineLoadTask is entered. +func (s *BaseDorisParserListener) EnterShowRoutineLoadTask(ctx *ShowRoutineLoadTaskContext) {} + +// ExitShowRoutineLoadTask is called when production showRoutineLoadTask is exited. +func (s *BaseDorisParserListener) ExitShowRoutineLoadTask(ctx *ShowRoutineLoadTaskContext) {} + +// EnterShowIndexAnalyzer is called when production showIndexAnalyzer is entered. +func (s *BaseDorisParserListener) EnterShowIndexAnalyzer(ctx *ShowIndexAnalyzerContext) {} + +// ExitShowIndexAnalyzer is called when production showIndexAnalyzer is exited. +func (s *BaseDorisParserListener) ExitShowIndexAnalyzer(ctx *ShowIndexAnalyzerContext) {} + +// EnterShowIndexTokenizer is called when production showIndexTokenizer is entered. +func (s *BaseDorisParserListener) EnterShowIndexTokenizer(ctx *ShowIndexTokenizerContext) {} + +// ExitShowIndexTokenizer is called when production showIndexTokenizer is exited. +func (s *BaseDorisParserListener) ExitShowIndexTokenizer(ctx *ShowIndexTokenizerContext) {} + +// EnterShowIndexTokenFilter is called when production showIndexTokenFilter is entered. +func (s *BaseDorisParserListener) EnterShowIndexTokenFilter(ctx *ShowIndexTokenFilterContext) {} + +// ExitShowIndexTokenFilter is called when production showIndexTokenFilter is exited. +func (s *BaseDorisParserListener) ExitShowIndexTokenFilter(ctx *ShowIndexTokenFilterContext) {} + +// EnterShowIndexCharFilter is called when production showIndexCharFilter is entered. +func (s *BaseDorisParserListener) EnterShowIndexCharFilter(ctx *ShowIndexCharFilterContext) {} + +// ExitShowIndexCharFilter is called when production showIndexCharFilter is exited. +func (s *BaseDorisParserListener) ExitShowIndexCharFilter(ctx *ShowIndexCharFilterContext) {} + +// EnterKillConnection is called when production killConnection is entered. +func (s *BaseDorisParserListener) EnterKillConnection(ctx *KillConnectionContext) {} + +// ExitKillConnection is called when production killConnection is exited. +func (s *BaseDorisParserListener) ExitKillConnection(ctx *KillConnectionContext) {} + +// EnterKillQuery is called when production killQuery is entered. +func (s *BaseDorisParserListener) EnterKillQuery(ctx *KillQueryContext) {} + +// ExitKillQuery is called when production killQuery is exited. +func (s *BaseDorisParserListener) ExitKillQuery(ctx *KillQueryContext) {} + +// EnterHelp is called when production help is entered. +func (s *BaseDorisParserListener) EnterHelp(ctx *HelpContext) {} + +// ExitHelp is called when production help is exited. +func (s *BaseDorisParserListener) ExitHelp(ctx *HelpContext) {} + +// EnterUnlockTables is called when production unlockTables is entered. +func (s *BaseDorisParserListener) EnterUnlockTables(ctx *UnlockTablesContext) {} + +// ExitUnlockTables is called when production unlockTables is exited. +func (s *BaseDorisParserListener) ExitUnlockTables(ctx *UnlockTablesContext) {} + +// EnterInstallPlugin is called when production installPlugin is entered. +func (s *BaseDorisParserListener) EnterInstallPlugin(ctx *InstallPluginContext) {} + +// ExitInstallPlugin is called when production installPlugin is exited. +func (s *BaseDorisParserListener) ExitInstallPlugin(ctx *InstallPluginContext) {} + +// EnterUninstallPlugin is called when production uninstallPlugin is entered. +func (s *BaseDorisParserListener) EnterUninstallPlugin(ctx *UninstallPluginContext) {} + +// ExitUninstallPlugin is called when production uninstallPlugin is exited. +func (s *BaseDorisParserListener) ExitUninstallPlugin(ctx *UninstallPluginContext) {} + +// EnterLockTables is called when production lockTables is entered. +func (s *BaseDorisParserListener) EnterLockTables(ctx *LockTablesContext) {} + +// ExitLockTables is called when production lockTables is exited. +func (s *BaseDorisParserListener) ExitLockTables(ctx *LockTablesContext) {} + +// EnterRestore is called when production restore is entered. +func (s *BaseDorisParserListener) EnterRestore(ctx *RestoreContext) {} + +// ExitRestore is called when production restore is exited. +func (s *BaseDorisParserListener) ExitRestore(ctx *RestoreContext) {} + +// EnterWarmUpCluster is called when production warmUpCluster is entered. +func (s *BaseDorisParserListener) EnterWarmUpCluster(ctx *WarmUpClusterContext) {} + +// ExitWarmUpCluster is called when production warmUpCluster is exited. +func (s *BaseDorisParserListener) ExitWarmUpCluster(ctx *WarmUpClusterContext) {} + +// EnterWarmUpSelect is called when production warmUpSelect is entered. +func (s *BaseDorisParserListener) EnterWarmUpSelect(ctx *WarmUpSelectContext) {} + +// ExitWarmUpSelect is called when production warmUpSelect is exited. +func (s *BaseDorisParserListener) ExitWarmUpSelect(ctx *WarmUpSelectContext) {} + +// EnterBackup is called when production backup is entered. +func (s *BaseDorisParserListener) EnterBackup(ctx *BackupContext) {} + +// ExitBackup is called when production backup is exited. +func (s *BaseDorisParserListener) ExitBackup(ctx *BackupContext) {} + +// EnterUnsupportedStartTransaction is called when production unsupportedStartTransaction is entered. +func (s *BaseDorisParserListener) EnterUnsupportedStartTransaction(ctx *UnsupportedStartTransactionContext) { +} + +// ExitUnsupportedStartTransaction is called when production unsupportedStartTransaction is exited. +func (s *BaseDorisParserListener) ExitUnsupportedStartTransaction(ctx *UnsupportedStartTransactionContext) { +} + +// EnterWarmUpItem is called when production warmUpItem is entered. +func (s *BaseDorisParserListener) EnterWarmUpItem(ctx *WarmUpItemContext) {} + +// ExitWarmUpItem is called when production warmUpItem is exited. +func (s *BaseDorisParserListener) ExitWarmUpItem(ctx *WarmUpItemContext) {} + +// EnterWarmUpSingleTableRef is called when production warmUpSingleTableRef is entered. +func (s *BaseDorisParserListener) EnterWarmUpSingleTableRef(ctx *WarmUpSingleTableRefContext) {} + +// ExitWarmUpSingleTableRef is called when production warmUpSingleTableRef is exited. +func (s *BaseDorisParserListener) ExitWarmUpSingleTableRef(ctx *WarmUpSingleTableRefContext) {} + +// EnterLockTable is called when production lockTable is entered. +func (s *BaseDorisParserListener) EnterLockTable(ctx *LockTableContext) {} + +// ExitLockTable is called when production lockTable is exited. +func (s *BaseDorisParserListener) ExitLockTable(ctx *LockTableContext) {} + +// EnterCreateRoutineLoad is called when production createRoutineLoad is entered. +func (s *BaseDorisParserListener) EnterCreateRoutineLoad(ctx *CreateRoutineLoadContext) {} + +// ExitCreateRoutineLoad is called when production createRoutineLoad is exited. +func (s *BaseDorisParserListener) ExitCreateRoutineLoad(ctx *CreateRoutineLoadContext) {} + +// EnterSeparator is called when production separator is entered. +func (s *BaseDorisParserListener) EnterSeparator(ctx *SeparatorContext) {} + +// ExitSeparator is called when production separator is exited. +func (s *BaseDorisParserListener) ExitSeparator(ctx *SeparatorContext) {} + +// EnterImportColumns is called when production importColumns is entered. +func (s *BaseDorisParserListener) EnterImportColumns(ctx *ImportColumnsContext) {} + +// ExitImportColumns is called when production importColumns is exited. +func (s *BaseDorisParserListener) ExitImportColumns(ctx *ImportColumnsContext) {} + +// EnterImportPrecedingFilter is called when production importPrecedingFilter is entered. +func (s *BaseDorisParserListener) EnterImportPrecedingFilter(ctx *ImportPrecedingFilterContext) {} + +// ExitImportPrecedingFilter is called when production importPrecedingFilter is exited. +func (s *BaseDorisParserListener) ExitImportPrecedingFilter(ctx *ImportPrecedingFilterContext) {} + +// EnterImportWhere is called when production importWhere is entered. +func (s *BaseDorisParserListener) EnterImportWhere(ctx *ImportWhereContext) {} + +// ExitImportWhere is called when production importWhere is exited. +func (s *BaseDorisParserListener) ExitImportWhere(ctx *ImportWhereContext) {} + +// EnterImportDeleteOn is called when production importDeleteOn is entered. +func (s *BaseDorisParserListener) EnterImportDeleteOn(ctx *ImportDeleteOnContext) {} + +// ExitImportDeleteOn is called when production importDeleteOn is exited. +func (s *BaseDorisParserListener) ExitImportDeleteOn(ctx *ImportDeleteOnContext) {} + +// EnterImportSequence is called when production importSequence is entered. +func (s *BaseDorisParserListener) EnterImportSequence(ctx *ImportSequenceContext) {} + +// ExitImportSequence is called when production importSequence is exited. +func (s *BaseDorisParserListener) ExitImportSequence(ctx *ImportSequenceContext) {} + +// EnterImportPartitions is called when production importPartitions is entered. +func (s *BaseDorisParserListener) EnterImportPartitions(ctx *ImportPartitionsContext) {} + +// ExitImportPartitions is called when production importPartitions is exited. +func (s *BaseDorisParserListener) ExitImportPartitions(ctx *ImportPartitionsContext) {} + +// EnterImportSequenceStatement is called when production importSequenceStatement is entered. +func (s *BaseDorisParserListener) EnterImportSequenceStatement(ctx *ImportSequenceStatementContext) {} + +// ExitImportSequenceStatement is called when production importSequenceStatement is exited. +func (s *BaseDorisParserListener) ExitImportSequenceStatement(ctx *ImportSequenceStatementContext) {} + +// EnterImportDeleteOnStatement is called when production importDeleteOnStatement is entered. +func (s *BaseDorisParserListener) EnterImportDeleteOnStatement(ctx *ImportDeleteOnStatementContext) {} + +// ExitImportDeleteOnStatement is called when production importDeleteOnStatement is exited. +func (s *BaseDorisParserListener) ExitImportDeleteOnStatement(ctx *ImportDeleteOnStatementContext) {} + +// EnterImportWhereStatement is called when production importWhereStatement is entered. +func (s *BaseDorisParserListener) EnterImportWhereStatement(ctx *ImportWhereStatementContext) {} + +// ExitImportWhereStatement is called when production importWhereStatement is exited. +func (s *BaseDorisParserListener) ExitImportWhereStatement(ctx *ImportWhereStatementContext) {} + +// EnterImportPrecedingFilterStatement is called when production importPrecedingFilterStatement is entered. +func (s *BaseDorisParserListener) EnterImportPrecedingFilterStatement(ctx *ImportPrecedingFilterStatementContext) { +} + +// ExitImportPrecedingFilterStatement is called when production importPrecedingFilterStatement is exited. +func (s *BaseDorisParserListener) ExitImportPrecedingFilterStatement(ctx *ImportPrecedingFilterStatementContext) { +} + +// EnterImportColumnsStatement is called when production importColumnsStatement is entered. +func (s *BaseDorisParserListener) EnterImportColumnsStatement(ctx *ImportColumnsStatementContext) {} + +// ExitImportColumnsStatement is called when production importColumnsStatement is exited. +func (s *BaseDorisParserListener) ExitImportColumnsStatement(ctx *ImportColumnsStatementContext) {} + +// EnterImportColumnDesc is called when production importColumnDesc is entered. +func (s *BaseDorisParserListener) EnterImportColumnDesc(ctx *ImportColumnDescContext) {} + +// ExitImportColumnDesc is called when production importColumnDesc is exited. +func (s *BaseDorisParserListener) ExitImportColumnDesc(ctx *ImportColumnDescContext) {} + +// EnterRefreshCatalog is called when production refreshCatalog is entered. +func (s *BaseDorisParserListener) EnterRefreshCatalog(ctx *RefreshCatalogContext) {} + +// ExitRefreshCatalog is called when production refreshCatalog is exited. +func (s *BaseDorisParserListener) ExitRefreshCatalog(ctx *RefreshCatalogContext) {} + +// EnterRefreshDatabase is called when production refreshDatabase is entered. +func (s *BaseDorisParserListener) EnterRefreshDatabase(ctx *RefreshDatabaseContext) {} + +// ExitRefreshDatabase is called when production refreshDatabase is exited. +func (s *BaseDorisParserListener) ExitRefreshDatabase(ctx *RefreshDatabaseContext) {} + +// EnterRefreshTable is called when production refreshTable is entered. +func (s *BaseDorisParserListener) EnterRefreshTable(ctx *RefreshTableContext) {} + +// ExitRefreshTable is called when production refreshTable is exited. +func (s *BaseDorisParserListener) ExitRefreshTable(ctx *RefreshTableContext) {} + +// EnterRefreshDictionary is called when production refreshDictionary is entered. +func (s *BaseDorisParserListener) EnterRefreshDictionary(ctx *RefreshDictionaryContext) {} + +// ExitRefreshDictionary is called when production refreshDictionary is exited. +func (s *BaseDorisParserListener) ExitRefreshDictionary(ctx *RefreshDictionaryContext) {} + +// EnterRefreshLdap is called when production refreshLdap is entered. +func (s *BaseDorisParserListener) EnterRefreshLdap(ctx *RefreshLdapContext) {} + +// ExitRefreshLdap is called when production refreshLdap is exited. +func (s *BaseDorisParserListener) ExitRefreshLdap(ctx *RefreshLdapContext) {} + +// EnterCleanAllProfile is called when production cleanAllProfile is entered. +func (s *BaseDorisParserListener) EnterCleanAllProfile(ctx *CleanAllProfileContext) {} + +// ExitCleanAllProfile is called when production cleanAllProfile is exited. +func (s *BaseDorisParserListener) ExitCleanAllProfile(ctx *CleanAllProfileContext) {} + +// EnterCleanLabel is called when production cleanLabel is entered. +func (s *BaseDorisParserListener) EnterCleanLabel(ctx *CleanLabelContext) {} + +// ExitCleanLabel is called when production cleanLabel is exited. +func (s *BaseDorisParserListener) ExitCleanLabel(ctx *CleanLabelContext) {} + +// EnterCleanQueryStats is called when production cleanQueryStats is entered. +func (s *BaseDorisParserListener) EnterCleanQueryStats(ctx *CleanQueryStatsContext) {} + +// ExitCleanQueryStats is called when production cleanQueryStats is exited. +func (s *BaseDorisParserListener) ExitCleanQueryStats(ctx *CleanQueryStatsContext) {} + +// EnterCleanAllQueryStats is called when production cleanAllQueryStats is entered. +func (s *BaseDorisParserListener) EnterCleanAllQueryStats(ctx *CleanAllQueryStatsContext) {} + +// ExitCleanAllQueryStats is called when production cleanAllQueryStats is exited. +func (s *BaseDorisParserListener) ExitCleanAllQueryStats(ctx *CleanAllQueryStatsContext) {} + +// EnterCancelLoad is called when production cancelLoad is entered. +func (s *BaseDorisParserListener) EnterCancelLoad(ctx *CancelLoadContext) {} + +// ExitCancelLoad is called when production cancelLoad is exited. +func (s *BaseDorisParserListener) ExitCancelLoad(ctx *CancelLoadContext) {} + +// EnterCancelExport is called when production cancelExport is entered. +func (s *BaseDorisParserListener) EnterCancelExport(ctx *CancelExportContext) {} + +// ExitCancelExport is called when production cancelExport is exited. +func (s *BaseDorisParserListener) ExitCancelExport(ctx *CancelExportContext) {} + +// EnterCancelWarmUpJob is called when production cancelWarmUpJob is entered. +func (s *BaseDorisParserListener) EnterCancelWarmUpJob(ctx *CancelWarmUpJobContext) {} + +// ExitCancelWarmUpJob is called when production cancelWarmUpJob is exited. +func (s *BaseDorisParserListener) ExitCancelWarmUpJob(ctx *CancelWarmUpJobContext) {} + +// EnterCancelDecommisionBackend is called when production cancelDecommisionBackend is entered. +func (s *BaseDorisParserListener) EnterCancelDecommisionBackend(ctx *CancelDecommisionBackendContext) { +} + +// ExitCancelDecommisionBackend is called when production cancelDecommisionBackend is exited. +func (s *BaseDorisParserListener) ExitCancelDecommisionBackend(ctx *CancelDecommisionBackendContext) { +} + +// EnterCancelBackup is called when production cancelBackup is entered. +func (s *BaseDorisParserListener) EnterCancelBackup(ctx *CancelBackupContext) {} + +// ExitCancelBackup is called when production cancelBackup is exited. +func (s *BaseDorisParserListener) ExitCancelBackup(ctx *CancelBackupContext) {} + +// EnterCancelRestore is called when production cancelRestore is entered. +func (s *BaseDorisParserListener) EnterCancelRestore(ctx *CancelRestoreContext) {} + +// ExitCancelRestore is called when production cancelRestore is exited. +func (s *BaseDorisParserListener) ExitCancelRestore(ctx *CancelRestoreContext) {} + +// EnterCancelBuildIndex is called when production cancelBuildIndex is entered. +func (s *BaseDorisParserListener) EnterCancelBuildIndex(ctx *CancelBuildIndexContext) {} + +// ExitCancelBuildIndex is called when production cancelBuildIndex is exited. +func (s *BaseDorisParserListener) ExitCancelBuildIndex(ctx *CancelBuildIndexContext) {} + +// EnterCancelAlterTable is called when production cancelAlterTable is entered. +func (s *BaseDorisParserListener) EnterCancelAlterTable(ctx *CancelAlterTableContext) {} + +// ExitCancelAlterTable is called when production cancelAlterTable is exited. +func (s *BaseDorisParserListener) ExitCancelAlterTable(ctx *CancelAlterTableContext) {} + +// EnterAdminShowReplicaDistribution is called when production adminShowReplicaDistribution is entered. +func (s *BaseDorisParserListener) EnterAdminShowReplicaDistribution(ctx *AdminShowReplicaDistributionContext) { +} + +// ExitAdminShowReplicaDistribution is called when production adminShowReplicaDistribution is exited. +func (s *BaseDorisParserListener) ExitAdminShowReplicaDistribution(ctx *AdminShowReplicaDistributionContext) { +} + +// EnterAdminRebalanceDisk is called when production adminRebalanceDisk is entered. +func (s *BaseDorisParserListener) EnterAdminRebalanceDisk(ctx *AdminRebalanceDiskContext) {} + +// ExitAdminRebalanceDisk is called when production adminRebalanceDisk is exited. +func (s *BaseDorisParserListener) ExitAdminRebalanceDisk(ctx *AdminRebalanceDiskContext) {} + +// EnterAdminCancelRebalanceDisk is called when production adminCancelRebalanceDisk is entered. +func (s *BaseDorisParserListener) EnterAdminCancelRebalanceDisk(ctx *AdminCancelRebalanceDiskContext) { +} + +// ExitAdminCancelRebalanceDisk is called when production adminCancelRebalanceDisk is exited. +func (s *BaseDorisParserListener) ExitAdminCancelRebalanceDisk(ctx *AdminCancelRebalanceDiskContext) { +} + +// EnterAdminDiagnoseTablet is called when production adminDiagnoseTablet is entered. +func (s *BaseDorisParserListener) EnterAdminDiagnoseTablet(ctx *AdminDiagnoseTabletContext) {} + +// ExitAdminDiagnoseTablet is called when production adminDiagnoseTablet is exited. +func (s *BaseDorisParserListener) ExitAdminDiagnoseTablet(ctx *AdminDiagnoseTabletContext) {} + +// EnterAdminShowReplicaStatus is called when production adminShowReplicaStatus is entered. +func (s *BaseDorisParserListener) EnterAdminShowReplicaStatus(ctx *AdminShowReplicaStatusContext) {} + +// ExitAdminShowReplicaStatus is called when production adminShowReplicaStatus is exited. +func (s *BaseDorisParserListener) ExitAdminShowReplicaStatus(ctx *AdminShowReplicaStatusContext) {} + +// EnterAdminCompactTable is called when production adminCompactTable is entered. +func (s *BaseDorisParserListener) EnterAdminCompactTable(ctx *AdminCompactTableContext) {} + +// ExitAdminCompactTable is called when production adminCompactTable is exited. +func (s *BaseDorisParserListener) ExitAdminCompactTable(ctx *AdminCompactTableContext) {} + +// EnterAdminCheckTablets is called when production adminCheckTablets is entered. +func (s *BaseDorisParserListener) EnterAdminCheckTablets(ctx *AdminCheckTabletsContext) {} + +// ExitAdminCheckTablets is called when production adminCheckTablets is exited. +func (s *BaseDorisParserListener) ExitAdminCheckTablets(ctx *AdminCheckTabletsContext) {} + +// EnterAdminShowTabletStorageFormat is called when production adminShowTabletStorageFormat is entered. +func (s *BaseDorisParserListener) EnterAdminShowTabletStorageFormat(ctx *AdminShowTabletStorageFormatContext) { +} + +// ExitAdminShowTabletStorageFormat is called when production adminShowTabletStorageFormat is exited. +func (s *BaseDorisParserListener) ExitAdminShowTabletStorageFormat(ctx *AdminShowTabletStorageFormatContext) { +} + +// EnterAdminSetFrontendConfig is called when production adminSetFrontendConfig is entered. +func (s *BaseDorisParserListener) EnterAdminSetFrontendConfig(ctx *AdminSetFrontendConfigContext) {} + +// ExitAdminSetFrontendConfig is called when production adminSetFrontendConfig is exited. +func (s *BaseDorisParserListener) ExitAdminSetFrontendConfig(ctx *AdminSetFrontendConfigContext) {} + +// EnterAdminCleanTrash is called when production adminCleanTrash is entered. +func (s *BaseDorisParserListener) EnterAdminCleanTrash(ctx *AdminCleanTrashContext) {} + +// ExitAdminCleanTrash is called when production adminCleanTrash is exited. +func (s *BaseDorisParserListener) ExitAdminCleanTrash(ctx *AdminCleanTrashContext) {} + +// EnterAdminSetReplicaVersion is called when production adminSetReplicaVersion is entered. +func (s *BaseDorisParserListener) EnterAdminSetReplicaVersion(ctx *AdminSetReplicaVersionContext) {} + +// ExitAdminSetReplicaVersion is called when production adminSetReplicaVersion is exited. +func (s *BaseDorisParserListener) ExitAdminSetReplicaVersion(ctx *AdminSetReplicaVersionContext) {} + +// EnterAdminSetTableStatus is called when production adminSetTableStatus is entered. +func (s *BaseDorisParserListener) EnterAdminSetTableStatus(ctx *AdminSetTableStatusContext) {} + +// ExitAdminSetTableStatus is called when production adminSetTableStatus is exited. +func (s *BaseDorisParserListener) ExitAdminSetTableStatus(ctx *AdminSetTableStatusContext) {} + +// EnterAdminSetReplicaStatus is called when production adminSetReplicaStatus is entered. +func (s *BaseDorisParserListener) EnterAdminSetReplicaStatus(ctx *AdminSetReplicaStatusContext) {} + +// ExitAdminSetReplicaStatus is called when production adminSetReplicaStatus is exited. +func (s *BaseDorisParserListener) ExitAdminSetReplicaStatus(ctx *AdminSetReplicaStatusContext) {} + +// EnterAdminRepairTable is called when production adminRepairTable is entered. +func (s *BaseDorisParserListener) EnterAdminRepairTable(ctx *AdminRepairTableContext) {} + +// ExitAdminRepairTable is called when production adminRepairTable is exited. +func (s *BaseDorisParserListener) ExitAdminRepairTable(ctx *AdminRepairTableContext) {} + +// EnterAdminCancelRepairTable is called when production adminCancelRepairTable is entered. +func (s *BaseDorisParserListener) EnterAdminCancelRepairTable(ctx *AdminCancelRepairTableContext) {} + +// ExitAdminCancelRepairTable is called when production adminCancelRepairTable is exited. +func (s *BaseDorisParserListener) ExitAdminCancelRepairTable(ctx *AdminCancelRepairTableContext) {} + +// EnterAdminCopyTablet is called when production adminCopyTablet is entered. +func (s *BaseDorisParserListener) EnterAdminCopyTablet(ctx *AdminCopyTabletContext) {} + +// ExitAdminCopyTablet is called when production adminCopyTablet is exited. +func (s *BaseDorisParserListener) ExitAdminCopyTablet(ctx *AdminCopyTabletContext) {} + +// EnterAdminSetEncryptionRootKey is called when production adminSetEncryptionRootKey is entered. +func (s *BaseDorisParserListener) EnterAdminSetEncryptionRootKey(ctx *AdminSetEncryptionRootKeyContext) { +} + +// ExitAdminSetEncryptionRootKey is called when production adminSetEncryptionRootKey is exited. +func (s *BaseDorisParserListener) ExitAdminSetEncryptionRootKey(ctx *AdminSetEncryptionRootKeyContext) { +} + +// EnterAdminSetPartitionVersion is called when production adminSetPartitionVersion is entered. +func (s *BaseDorisParserListener) EnterAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) { +} + +// ExitAdminSetPartitionVersion is called when production adminSetPartitionVersion is exited. +func (s *BaseDorisParserListener) ExitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) { +} + +// EnterAdminCreateClusterSnapshot is called when production adminCreateClusterSnapshot is entered. +func (s *BaseDorisParserListener) EnterAdminCreateClusterSnapshot(ctx *AdminCreateClusterSnapshotContext) { +} + +// ExitAdminCreateClusterSnapshot is called when production adminCreateClusterSnapshot is exited. +func (s *BaseDorisParserListener) ExitAdminCreateClusterSnapshot(ctx *AdminCreateClusterSnapshotContext) { +} + +// EnterAdminSetAutoClusterSnapshot is called when production adminSetAutoClusterSnapshot is entered. +func (s *BaseDorisParserListener) EnterAdminSetAutoClusterSnapshot(ctx *AdminSetAutoClusterSnapshotContext) { +} + +// ExitAdminSetAutoClusterSnapshot is called when production adminSetAutoClusterSnapshot is exited. +func (s *BaseDorisParserListener) ExitAdminSetAutoClusterSnapshot(ctx *AdminSetAutoClusterSnapshotContext) { +} + +// EnterAdminDropClusterSnapshot is called when production adminDropClusterSnapshot is entered. +func (s *BaseDorisParserListener) EnterAdminDropClusterSnapshot(ctx *AdminDropClusterSnapshotContext) { +} + +// ExitAdminDropClusterSnapshot is called when production adminDropClusterSnapshot is exited. +func (s *BaseDorisParserListener) ExitAdminDropClusterSnapshot(ctx *AdminDropClusterSnapshotContext) { +} + +// EnterAdminSetClusterSnapshotFeatureSwitch is called when production adminSetClusterSnapshotFeatureSwitch is entered. +func (s *BaseDorisParserListener) EnterAdminSetClusterSnapshotFeatureSwitch(ctx *AdminSetClusterSnapshotFeatureSwitchContext) { +} + +// ExitAdminSetClusterSnapshotFeatureSwitch is called when production adminSetClusterSnapshotFeatureSwitch is exited. +func (s *BaseDorisParserListener) ExitAdminSetClusterSnapshotFeatureSwitch(ctx *AdminSetClusterSnapshotFeatureSwitchContext) { +} + +// EnterAdminRotateTdeRootKey is called when production adminRotateTdeRootKey is entered. +func (s *BaseDorisParserListener) EnterAdminRotateTdeRootKey(ctx *AdminRotateTdeRootKeyContext) {} + +// ExitAdminRotateTdeRootKey is called when production adminRotateTdeRootKey is exited. +func (s *BaseDorisParserListener) ExitAdminRotateTdeRootKey(ctx *AdminRotateTdeRootKeyContext) {} + +// EnterRecoverDatabase is called when production recoverDatabase is entered. +func (s *BaseDorisParserListener) EnterRecoverDatabase(ctx *RecoverDatabaseContext) {} + +// ExitRecoverDatabase is called when production recoverDatabase is exited. +func (s *BaseDorisParserListener) ExitRecoverDatabase(ctx *RecoverDatabaseContext) {} + +// EnterRecoverTable is called when production recoverTable is entered. +func (s *BaseDorisParserListener) EnterRecoverTable(ctx *RecoverTableContext) {} + +// ExitRecoverTable is called when production recoverTable is exited. +func (s *BaseDorisParserListener) ExitRecoverTable(ctx *RecoverTableContext) {} + +// EnterRecoverPartition is called when production recoverPartition is entered. +func (s *BaseDorisParserListener) EnterRecoverPartition(ctx *RecoverPartitionContext) {} + +// ExitRecoverPartition is called when production recoverPartition is exited. +func (s *BaseDorisParserListener) ExitRecoverPartition(ctx *RecoverPartitionContext) {} + +// EnterBaseTableRef is called when production baseTableRef is entered. +func (s *BaseDorisParserListener) EnterBaseTableRef(ctx *BaseTableRefContext) {} + +// ExitBaseTableRef is called when production baseTableRef is exited. +func (s *BaseDorisParserListener) ExitBaseTableRef(ctx *BaseTableRefContext) {} + +// EnterWildWhere is called when production wildWhere is entered. +func (s *BaseDorisParserListener) EnterWildWhere(ctx *WildWhereContext) {} + +// ExitWildWhere is called when production wildWhere is exited. +func (s *BaseDorisParserListener) ExitWildWhere(ctx *WildWhereContext) {} + +// EnterTransactionBegin is called when production transactionBegin is entered. +func (s *BaseDorisParserListener) EnterTransactionBegin(ctx *TransactionBeginContext) {} + +// ExitTransactionBegin is called when production transactionBegin is exited. +func (s *BaseDorisParserListener) ExitTransactionBegin(ctx *TransactionBeginContext) {} + +// EnterTranscationCommit is called when production transcationCommit is entered. +func (s *BaseDorisParserListener) EnterTranscationCommit(ctx *TranscationCommitContext) {} + +// ExitTranscationCommit is called when production transcationCommit is exited. +func (s *BaseDorisParserListener) ExitTranscationCommit(ctx *TranscationCommitContext) {} + +// EnterTransactionRollback is called when production transactionRollback is entered. +func (s *BaseDorisParserListener) EnterTransactionRollback(ctx *TransactionRollbackContext) {} + +// ExitTransactionRollback is called when production transactionRollback is exited. +func (s *BaseDorisParserListener) ExitTransactionRollback(ctx *TransactionRollbackContext) {} + +// EnterGrantTablePrivilege is called when production grantTablePrivilege is entered. +func (s *BaseDorisParserListener) EnterGrantTablePrivilege(ctx *GrantTablePrivilegeContext) {} + +// ExitGrantTablePrivilege is called when production grantTablePrivilege is exited. +func (s *BaseDorisParserListener) ExitGrantTablePrivilege(ctx *GrantTablePrivilegeContext) {} + +// EnterGrantResourcePrivilege is called when production grantResourcePrivilege is entered. +func (s *BaseDorisParserListener) EnterGrantResourcePrivilege(ctx *GrantResourcePrivilegeContext) {} + +// ExitGrantResourcePrivilege is called when production grantResourcePrivilege is exited. +func (s *BaseDorisParserListener) ExitGrantResourcePrivilege(ctx *GrantResourcePrivilegeContext) {} + +// EnterGrantRole is called when production grantRole is entered. +func (s *BaseDorisParserListener) EnterGrantRole(ctx *GrantRoleContext) {} + +// ExitGrantRole is called when production grantRole is exited. +func (s *BaseDorisParserListener) ExitGrantRole(ctx *GrantRoleContext) {} + +// EnterRevokeRole is called when production revokeRole is entered. +func (s *BaseDorisParserListener) EnterRevokeRole(ctx *RevokeRoleContext) {} + +// ExitRevokeRole is called when production revokeRole is exited. +func (s *BaseDorisParserListener) ExitRevokeRole(ctx *RevokeRoleContext) {} + +// EnterRevokeResourcePrivilege is called when production revokeResourcePrivilege is entered. +func (s *BaseDorisParserListener) EnterRevokeResourcePrivilege(ctx *RevokeResourcePrivilegeContext) {} + +// ExitRevokeResourcePrivilege is called when production revokeResourcePrivilege is exited. +func (s *BaseDorisParserListener) ExitRevokeResourcePrivilege(ctx *RevokeResourcePrivilegeContext) {} + +// EnterRevokeTablePrivilege is called when production revokeTablePrivilege is entered. +func (s *BaseDorisParserListener) EnterRevokeTablePrivilege(ctx *RevokeTablePrivilegeContext) {} + +// ExitRevokeTablePrivilege is called when production revokeTablePrivilege is exited. +func (s *BaseDorisParserListener) ExitRevokeTablePrivilege(ctx *RevokeTablePrivilegeContext) {} + +// EnterPrivilege is called when production privilege is entered. +func (s *BaseDorisParserListener) EnterPrivilege(ctx *PrivilegeContext) {} + +// ExitPrivilege is called when production privilege is exited. +func (s *BaseDorisParserListener) ExitPrivilege(ctx *PrivilegeContext) {} + +// EnterPrivilegeList is called when production privilegeList is entered. +func (s *BaseDorisParserListener) EnterPrivilegeList(ctx *PrivilegeListContext) {} + +// ExitPrivilegeList is called when production privilegeList is exited. +func (s *BaseDorisParserListener) ExitPrivilegeList(ctx *PrivilegeListContext) {} + +// EnterAddBackendClause is called when production addBackendClause is entered. +func (s *BaseDorisParserListener) EnterAddBackendClause(ctx *AddBackendClauseContext) {} + +// ExitAddBackendClause is called when production addBackendClause is exited. +func (s *BaseDorisParserListener) ExitAddBackendClause(ctx *AddBackendClauseContext) {} + +// EnterDropBackendClause is called when production dropBackendClause is entered. +func (s *BaseDorisParserListener) EnterDropBackendClause(ctx *DropBackendClauseContext) {} + +// ExitDropBackendClause is called when production dropBackendClause is exited. +func (s *BaseDorisParserListener) ExitDropBackendClause(ctx *DropBackendClauseContext) {} + +// EnterDecommissionBackendClause is called when production decommissionBackendClause is entered. +func (s *BaseDorisParserListener) EnterDecommissionBackendClause(ctx *DecommissionBackendClauseContext) { +} + +// ExitDecommissionBackendClause is called when production decommissionBackendClause is exited. +func (s *BaseDorisParserListener) ExitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) { +} + +// EnterAddObserverClause is called when production addObserverClause is entered. +func (s *BaseDorisParserListener) EnterAddObserverClause(ctx *AddObserverClauseContext) {} + +// ExitAddObserverClause is called when production addObserverClause is exited. +func (s *BaseDorisParserListener) ExitAddObserverClause(ctx *AddObserverClauseContext) {} + +// EnterDropObserverClause is called when production dropObserverClause is entered. +func (s *BaseDorisParserListener) EnterDropObserverClause(ctx *DropObserverClauseContext) {} + +// ExitDropObserverClause is called when production dropObserverClause is exited. +func (s *BaseDorisParserListener) ExitDropObserverClause(ctx *DropObserverClauseContext) {} + +// EnterAddFollowerClause is called when production addFollowerClause is entered. +func (s *BaseDorisParserListener) EnterAddFollowerClause(ctx *AddFollowerClauseContext) {} + +// ExitAddFollowerClause is called when production addFollowerClause is exited. +func (s *BaseDorisParserListener) ExitAddFollowerClause(ctx *AddFollowerClauseContext) {} + +// EnterDropFollowerClause is called when production dropFollowerClause is entered. +func (s *BaseDorisParserListener) EnterDropFollowerClause(ctx *DropFollowerClauseContext) {} + +// ExitDropFollowerClause is called when production dropFollowerClause is exited. +func (s *BaseDorisParserListener) ExitDropFollowerClause(ctx *DropFollowerClauseContext) {} + +// EnterAddBrokerClause is called when production addBrokerClause is entered. +func (s *BaseDorisParserListener) EnterAddBrokerClause(ctx *AddBrokerClauseContext) {} + +// ExitAddBrokerClause is called when production addBrokerClause is exited. +func (s *BaseDorisParserListener) ExitAddBrokerClause(ctx *AddBrokerClauseContext) {} + +// EnterDropBrokerClause is called when production dropBrokerClause is entered. +func (s *BaseDorisParserListener) EnterDropBrokerClause(ctx *DropBrokerClauseContext) {} + +// ExitDropBrokerClause is called when production dropBrokerClause is exited. +func (s *BaseDorisParserListener) ExitDropBrokerClause(ctx *DropBrokerClauseContext) {} + +// EnterDropAllBrokerClause is called when production dropAllBrokerClause is entered. +func (s *BaseDorisParserListener) EnterDropAllBrokerClause(ctx *DropAllBrokerClauseContext) {} + +// ExitDropAllBrokerClause is called when production dropAllBrokerClause is exited. +func (s *BaseDorisParserListener) ExitDropAllBrokerClause(ctx *DropAllBrokerClauseContext) {} + +// EnterAlterLoadErrorUrlClause is called when production alterLoadErrorUrlClause is entered. +func (s *BaseDorisParserListener) EnterAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) {} + +// ExitAlterLoadErrorUrlClause is called when production alterLoadErrorUrlClause is exited. +func (s *BaseDorisParserListener) ExitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) {} + +// EnterModifyBackendClause is called when production modifyBackendClause is entered. +func (s *BaseDorisParserListener) EnterModifyBackendClause(ctx *ModifyBackendClauseContext) {} + +// ExitModifyBackendClause is called when production modifyBackendClause is exited. +func (s *BaseDorisParserListener) ExitModifyBackendClause(ctx *ModifyBackendClauseContext) {} + +// EnterModifyFrontendOrBackendHostNameClause is called when production modifyFrontendOrBackendHostNameClause is entered. +func (s *BaseDorisParserListener) EnterModifyFrontendOrBackendHostNameClause(ctx *ModifyFrontendOrBackendHostNameClauseContext) { +} + +// ExitModifyFrontendOrBackendHostNameClause is called when production modifyFrontendOrBackendHostNameClause is exited. +func (s *BaseDorisParserListener) ExitModifyFrontendOrBackendHostNameClause(ctx *ModifyFrontendOrBackendHostNameClauseContext) { +} + +// EnterDropRollupClause is called when production dropRollupClause is entered. +func (s *BaseDorisParserListener) EnterDropRollupClause(ctx *DropRollupClauseContext) {} + +// ExitDropRollupClause is called when production dropRollupClause is exited. +func (s *BaseDorisParserListener) ExitDropRollupClause(ctx *DropRollupClauseContext) {} + +// EnterAddRollupClause is called when production addRollupClause is entered. +func (s *BaseDorisParserListener) EnterAddRollupClause(ctx *AddRollupClauseContext) {} + +// ExitAddRollupClause is called when production addRollupClause is exited. +func (s *BaseDorisParserListener) ExitAddRollupClause(ctx *AddRollupClauseContext) {} + +// EnterAddColumnClause is called when production addColumnClause is entered. +func (s *BaseDorisParserListener) EnterAddColumnClause(ctx *AddColumnClauseContext) {} + +// ExitAddColumnClause is called when production addColumnClause is exited. +func (s *BaseDorisParserListener) ExitAddColumnClause(ctx *AddColumnClauseContext) {} + +// EnterAddColumnsClause is called when production addColumnsClause is entered. +func (s *BaseDorisParserListener) EnterAddColumnsClause(ctx *AddColumnsClauseContext) {} + +// ExitAddColumnsClause is called when production addColumnsClause is exited. +func (s *BaseDorisParserListener) ExitAddColumnsClause(ctx *AddColumnsClauseContext) {} + +// EnterDropColumnClause is called when production dropColumnClause is entered. +func (s *BaseDorisParserListener) EnterDropColumnClause(ctx *DropColumnClauseContext) {} + +// ExitDropColumnClause is called when production dropColumnClause is exited. +func (s *BaseDorisParserListener) ExitDropColumnClause(ctx *DropColumnClauseContext) {} + +// EnterModifyColumnClause is called when production modifyColumnClause is entered. +func (s *BaseDorisParserListener) EnterModifyColumnClause(ctx *ModifyColumnClauseContext) {} + +// ExitModifyColumnClause is called when production modifyColumnClause is exited. +func (s *BaseDorisParserListener) ExitModifyColumnClause(ctx *ModifyColumnClauseContext) {} + +// EnterReorderColumnsClause is called when production reorderColumnsClause is entered. +func (s *BaseDorisParserListener) EnterReorderColumnsClause(ctx *ReorderColumnsClauseContext) {} + +// ExitReorderColumnsClause is called when production reorderColumnsClause is exited. +func (s *BaseDorisParserListener) ExitReorderColumnsClause(ctx *ReorderColumnsClauseContext) {} + +// EnterAddPartitionClause is called when production addPartitionClause is entered. +func (s *BaseDorisParserListener) EnterAddPartitionClause(ctx *AddPartitionClauseContext) {} + +// ExitAddPartitionClause is called when production addPartitionClause is exited. +func (s *BaseDorisParserListener) ExitAddPartitionClause(ctx *AddPartitionClauseContext) {} + +// EnterDropPartitionClause is called when production dropPartitionClause is entered. +func (s *BaseDorisParserListener) EnterDropPartitionClause(ctx *DropPartitionClauseContext) {} + +// ExitDropPartitionClause is called when production dropPartitionClause is exited. +func (s *BaseDorisParserListener) ExitDropPartitionClause(ctx *DropPartitionClauseContext) {} + +// EnterModifyPartitionClause is called when production modifyPartitionClause is entered. +func (s *BaseDorisParserListener) EnterModifyPartitionClause(ctx *ModifyPartitionClauseContext) {} + +// ExitModifyPartitionClause is called when production modifyPartitionClause is exited. +func (s *BaseDorisParserListener) ExitModifyPartitionClause(ctx *ModifyPartitionClauseContext) {} + +// EnterReplacePartitionClause is called when production replacePartitionClause is entered. +func (s *BaseDorisParserListener) EnterReplacePartitionClause(ctx *ReplacePartitionClauseContext) {} + +// ExitReplacePartitionClause is called when production replacePartitionClause is exited. +func (s *BaseDorisParserListener) ExitReplacePartitionClause(ctx *ReplacePartitionClauseContext) {} + +// EnterReplaceTableClause is called when production replaceTableClause is entered. +func (s *BaseDorisParserListener) EnterReplaceTableClause(ctx *ReplaceTableClauseContext) {} + +// ExitReplaceTableClause is called when production replaceTableClause is exited. +func (s *BaseDorisParserListener) ExitReplaceTableClause(ctx *ReplaceTableClauseContext) {} + +// EnterRenameClause is called when production renameClause is entered. +func (s *BaseDorisParserListener) EnterRenameClause(ctx *RenameClauseContext) {} + +// ExitRenameClause is called when production renameClause is exited. +func (s *BaseDorisParserListener) ExitRenameClause(ctx *RenameClauseContext) {} + +// EnterRenameRollupClause is called when production renameRollupClause is entered. +func (s *BaseDorisParserListener) EnterRenameRollupClause(ctx *RenameRollupClauseContext) {} + +// ExitRenameRollupClause is called when production renameRollupClause is exited. +func (s *BaseDorisParserListener) ExitRenameRollupClause(ctx *RenameRollupClauseContext) {} + +// EnterRenamePartitionClause is called when production renamePartitionClause is entered. +func (s *BaseDorisParserListener) EnterRenamePartitionClause(ctx *RenamePartitionClauseContext) {} + +// ExitRenamePartitionClause is called when production renamePartitionClause is exited. +func (s *BaseDorisParserListener) ExitRenamePartitionClause(ctx *RenamePartitionClauseContext) {} + +// EnterRenameColumnClause is called when production renameColumnClause is entered. +func (s *BaseDorisParserListener) EnterRenameColumnClause(ctx *RenameColumnClauseContext) {} + +// ExitRenameColumnClause is called when production renameColumnClause is exited. +func (s *BaseDorisParserListener) ExitRenameColumnClause(ctx *RenameColumnClauseContext) {} + +// EnterAddIndexClause is called when production addIndexClause is entered. +func (s *BaseDorisParserListener) EnterAddIndexClause(ctx *AddIndexClauseContext) {} + +// ExitAddIndexClause is called when production addIndexClause is exited. +func (s *BaseDorisParserListener) ExitAddIndexClause(ctx *AddIndexClauseContext) {} + +// EnterDropIndexClause is called when production dropIndexClause is entered. +func (s *BaseDorisParserListener) EnterDropIndexClause(ctx *DropIndexClauseContext) {} + +// ExitDropIndexClause is called when production dropIndexClause is exited. +func (s *BaseDorisParserListener) ExitDropIndexClause(ctx *DropIndexClauseContext) {} + +// EnterEnableFeatureClause is called when production enableFeatureClause is entered. +func (s *BaseDorisParserListener) EnterEnableFeatureClause(ctx *EnableFeatureClauseContext) {} + +// ExitEnableFeatureClause is called when production enableFeatureClause is exited. +func (s *BaseDorisParserListener) ExitEnableFeatureClause(ctx *EnableFeatureClauseContext) {} + +// EnterModifyDistributionClause is called when production modifyDistributionClause is entered. +func (s *BaseDorisParserListener) EnterModifyDistributionClause(ctx *ModifyDistributionClauseContext) { +} + +// ExitModifyDistributionClause is called when production modifyDistributionClause is exited. +func (s *BaseDorisParserListener) ExitModifyDistributionClause(ctx *ModifyDistributionClauseContext) { +} + +// EnterModifyTableCommentClause is called when production modifyTableCommentClause is entered. +func (s *BaseDorisParserListener) EnterModifyTableCommentClause(ctx *ModifyTableCommentClauseContext) { +} + +// ExitModifyTableCommentClause is called when production modifyTableCommentClause is exited. +func (s *BaseDorisParserListener) ExitModifyTableCommentClause(ctx *ModifyTableCommentClauseContext) { +} + +// EnterModifyColumnCommentClause is called when production modifyColumnCommentClause is entered. +func (s *BaseDorisParserListener) EnterModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) { +} + +// ExitModifyColumnCommentClause is called when production modifyColumnCommentClause is exited. +func (s *BaseDorisParserListener) ExitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) { +} + +// EnterModifyEngineClause is called when production modifyEngineClause is entered. +func (s *BaseDorisParserListener) EnterModifyEngineClause(ctx *ModifyEngineClauseContext) {} + +// ExitModifyEngineClause is called when production modifyEngineClause is exited. +func (s *BaseDorisParserListener) ExitModifyEngineClause(ctx *ModifyEngineClauseContext) {} + +// EnterAlterMultiPartitionClause is called when production alterMultiPartitionClause is entered. +func (s *BaseDorisParserListener) EnterAlterMultiPartitionClause(ctx *AlterMultiPartitionClauseContext) { +} + +// ExitAlterMultiPartitionClause is called when production alterMultiPartitionClause is exited. +func (s *BaseDorisParserListener) ExitAlterMultiPartitionClause(ctx *AlterMultiPartitionClauseContext) { +} + +// EnterCreateOrReplaceTagClauses is called when production createOrReplaceTagClauses is entered. +func (s *BaseDorisParserListener) EnterCreateOrReplaceTagClauses(ctx *CreateOrReplaceTagClausesContext) { +} + +// ExitCreateOrReplaceTagClauses is called when production createOrReplaceTagClauses is exited. +func (s *BaseDorisParserListener) ExitCreateOrReplaceTagClauses(ctx *CreateOrReplaceTagClausesContext) { +} + +// EnterCreateOrReplaceBranchClauses is called when production createOrReplaceBranchClauses is entered. +func (s *BaseDorisParserListener) EnterCreateOrReplaceBranchClauses(ctx *CreateOrReplaceBranchClausesContext) { +} + +// ExitCreateOrReplaceBranchClauses is called when production createOrReplaceBranchClauses is exited. +func (s *BaseDorisParserListener) ExitCreateOrReplaceBranchClauses(ctx *CreateOrReplaceBranchClausesContext) { +} + +// EnterDropBranchClauses is called when production dropBranchClauses is entered. +func (s *BaseDorisParserListener) EnterDropBranchClauses(ctx *DropBranchClausesContext) {} + +// ExitDropBranchClauses is called when production dropBranchClauses is exited. +func (s *BaseDorisParserListener) ExitDropBranchClauses(ctx *DropBranchClausesContext) {} + +// EnterDropTagClauses is called when production dropTagClauses is entered. +func (s *BaseDorisParserListener) EnterDropTagClauses(ctx *DropTagClausesContext) {} + +// ExitDropTagClauses is called when production dropTagClauses is exited. +func (s *BaseDorisParserListener) ExitDropTagClauses(ctx *DropTagClausesContext) {} + +// EnterAddPartitionFieldClause is called when production addPartitionFieldClause is entered. +func (s *BaseDorisParserListener) EnterAddPartitionFieldClause(ctx *AddPartitionFieldClauseContext) {} + +// ExitAddPartitionFieldClause is called when production addPartitionFieldClause is exited. +func (s *BaseDorisParserListener) ExitAddPartitionFieldClause(ctx *AddPartitionFieldClauseContext) {} + +// EnterDropPartitionFieldClause is called when production dropPartitionFieldClause is entered. +func (s *BaseDorisParserListener) EnterDropPartitionFieldClause(ctx *DropPartitionFieldClauseContext) { +} + +// ExitDropPartitionFieldClause is called when production dropPartitionFieldClause is exited. +func (s *BaseDorisParserListener) ExitDropPartitionFieldClause(ctx *DropPartitionFieldClauseContext) { +} + +// EnterReplacePartitionFieldClause is called when production replacePartitionFieldClause is entered. +func (s *BaseDorisParserListener) EnterReplacePartitionFieldClause(ctx *ReplacePartitionFieldClauseContext) { +} + +// ExitReplacePartitionFieldClause is called when production replacePartitionFieldClause is exited. +func (s *BaseDorisParserListener) ExitReplacePartitionFieldClause(ctx *ReplacePartitionFieldClauseContext) { +} + +// EnterCreateOrReplaceTagClause is called when production createOrReplaceTagClause is entered. +func (s *BaseDorisParserListener) EnterCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) { +} + +// ExitCreateOrReplaceTagClause is called when production createOrReplaceTagClause is exited. +func (s *BaseDorisParserListener) ExitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) { +} + +// EnterCreateOrReplaceBranchClause is called when production createOrReplaceBranchClause is entered. +func (s *BaseDorisParserListener) EnterCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) { +} + +// ExitCreateOrReplaceBranchClause is called when production createOrReplaceBranchClause is exited. +func (s *BaseDorisParserListener) ExitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) { +} + +// EnterTagOptions is called when production tagOptions is entered. +func (s *BaseDorisParserListener) EnterTagOptions(ctx *TagOptionsContext) {} + +// ExitTagOptions is called when production tagOptions is exited. +func (s *BaseDorisParserListener) ExitTagOptions(ctx *TagOptionsContext) {} + +// EnterBranchOptions is called when production branchOptions is entered. +func (s *BaseDorisParserListener) EnterBranchOptions(ctx *BranchOptionsContext) {} + +// ExitBranchOptions is called when production branchOptions is exited. +func (s *BaseDorisParserListener) ExitBranchOptions(ctx *BranchOptionsContext) {} + +// EnterRetainTime is called when production retainTime is entered. +func (s *BaseDorisParserListener) EnterRetainTime(ctx *RetainTimeContext) {} + +// ExitRetainTime is called when production retainTime is exited. +func (s *BaseDorisParserListener) ExitRetainTime(ctx *RetainTimeContext) {} + +// EnterRetentionSnapshot is called when production retentionSnapshot is entered. +func (s *BaseDorisParserListener) EnterRetentionSnapshot(ctx *RetentionSnapshotContext) {} + +// ExitRetentionSnapshot is called when production retentionSnapshot is exited. +func (s *BaseDorisParserListener) ExitRetentionSnapshot(ctx *RetentionSnapshotContext) {} + +// EnterMinSnapshotsToKeep is called when production minSnapshotsToKeep is entered. +func (s *BaseDorisParserListener) EnterMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) {} + +// ExitMinSnapshotsToKeep is called when production minSnapshotsToKeep is exited. +func (s *BaseDorisParserListener) ExitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) {} + +// EnterTimeValueWithUnit is called when production timeValueWithUnit is entered. +func (s *BaseDorisParserListener) EnterTimeValueWithUnit(ctx *TimeValueWithUnitContext) {} + +// ExitTimeValueWithUnit is called when production timeValueWithUnit is exited. +func (s *BaseDorisParserListener) ExitTimeValueWithUnit(ctx *TimeValueWithUnitContext) {} + +// EnterDropBranchClause is called when production dropBranchClause is entered. +func (s *BaseDorisParserListener) EnterDropBranchClause(ctx *DropBranchClauseContext) {} + +// ExitDropBranchClause is called when production dropBranchClause is exited. +func (s *BaseDorisParserListener) ExitDropBranchClause(ctx *DropBranchClauseContext) {} + +// EnterDropTagClause is called when production dropTagClause is entered. +func (s *BaseDorisParserListener) EnterDropTagClause(ctx *DropTagClauseContext) {} + +// ExitDropTagClause is called when production dropTagClause is exited. +func (s *BaseDorisParserListener) ExitDropTagClause(ctx *DropTagClauseContext) {} + +// EnterPartitionTransformWithArgs is called when production partitionTransformWithArgs is entered. +func (s *BaseDorisParserListener) EnterPartitionTransformWithArgs(ctx *PartitionTransformWithArgsContext) { +} + +// ExitPartitionTransformWithArgs is called when production partitionTransformWithArgs is exited. +func (s *BaseDorisParserListener) ExitPartitionTransformWithArgs(ctx *PartitionTransformWithArgsContext) { +} + +// EnterPartitionTransformWithColumn is called when production partitionTransformWithColumn is entered. +func (s *BaseDorisParserListener) EnterPartitionTransformWithColumn(ctx *PartitionTransformWithColumnContext) { +} + +// ExitPartitionTransformWithColumn is called when production partitionTransformWithColumn is exited. +func (s *BaseDorisParserListener) ExitPartitionTransformWithColumn(ctx *PartitionTransformWithColumnContext) { +} + +// EnterPartitionTransformIdentity is called when production partitionTransformIdentity is entered. +func (s *BaseDorisParserListener) EnterPartitionTransformIdentity(ctx *PartitionTransformIdentityContext) { +} + +// ExitPartitionTransformIdentity is called when production partitionTransformIdentity is exited. +func (s *BaseDorisParserListener) ExitPartitionTransformIdentity(ctx *PartitionTransformIdentityContext) { +} + +// EnterColumnPosition is called when production columnPosition is entered. +func (s *BaseDorisParserListener) EnterColumnPosition(ctx *ColumnPositionContext) {} + +// ExitColumnPosition is called when production columnPosition is exited. +func (s *BaseDorisParserListener) ExitColumnPosition(ctx *ColumnPositionContext) {} + +// EnterToRollup is called when production toRollup is entered. +func (s *BaseDorisParserListener) EnterToRollup(ctx *ToRollupContext) {} + +// ExitToRollup is called when production toRollup is exited. +func (s *BaseDorisParserListener) ExitToRollup(ctx *ToRollupContext) {} + +// EnterFromRollup is called when production fromRollup is entered. +func (s *BaseDorisParserListener) EnterFromRollup(ctx *FromRollupContext) {} + +// ExitFromRollup is called when production fromRollup is exited. +func (s *BaseDorisParserListener) ExitFromRollup(ctx *FromRollupContext) {} + +// EnterShowAnalyze is called when production showAnalyze is entered. +func (s *BaseDorisParserListener) EnterShowAnalyze(ctx *ShowAnalyzeContext) {} + +// ExitShowAnalyze is called when production showAnalyze is exited. +func (s *BaseDorisParserListener) ExitShowAnalyze(ctx *ShowAnalyzeContext) {} + +// EnterShowQueuedAnalyzeJobs is called when production showQueuedAnalyzeJobs is entered. +func (s *BaseDorisParserListener) EnterShowQueuedAnalyzeJobs(ctx *ShowQueuedAnalyzeJobsContext) {} + +// ExitShowQueuedAnalyzeJobs is called when production showQueuedAnalyzeJobs is exited. +func (s *BaseDorisParserListener) ExitShowQueuedAnalyzeJobs(ctx *ShowQueuedAnalyzeJobsContext) {} + +// EnterShowColumnHistogramStats is called when production showColumnHistogramStats is entered. +func (s *BaseDorisParserListener) EnterShowColumnHistogramStats(ctx *ShowColumnHistogramStatsContext) { +} + +// ExitShowColumnHistogramStats is called when production showColumnHistogramStats is exited. +func (s *BaseDorisParserListener) ExitShowColumnHistogramStats(ctx *ShowColumnHistogramStatsContext) { +} + +// EnterShowColumnStats is called when production showColumnStats is entered. +func (s *BaseDorisParserListener) EnterShowColumnStats(ctx *ShowColumnStatsContext) {} + +// ExitShowColumnStats is called when production showColumnStats is exited. +func (s *BaseDorisParserListener) ExitShowColumnStats(ctx *ShowColumnStatsContext) {} + +// EnterShowAnalyzeTask is called when production showAnalyzeTask is entered. +func (s *BaseDorisParserListener) EnterShowAnalyzeTask(ctx *ShowAnalyzeTaskContext) {} + +// ExitShowAnalyzeTask is called when production showAnalyzeTask is exited. +func (s *BaseDorisParserListener) ExitShowAnalyzeTask(ctx *ShowAnalyzeTaskContext) {} + +// EnterAnalyzeDatabase is called when production analyzeDatabase is entered. +func (s *BaseDorisParserListener) EnterAnalyzeDatabase(ctx *AnalyzeDatabaseContext) {} + +// ExitAnalyzeDatabase is called when production analyzeDatabase is exited. +func (s *BaseDorisParserListener) ExitAnalyzeDatabase(ctx *AnalyzeDatabaseContext) {} + +// EnterAnalyzeTable is called when production analyzeTable is entered. +func (s *BaseDorisParserListener) EnterAnalyzeTable(ctx *AnalyzeTableContext) {} + +// ExitAnalyzeTable is called when production analyzeTable is exited. +func (s *BaseDorisParserListener) ExitAnalyzeTable(ctx *AnalyzeTableContext) {} + +// EnterAlterTableStats is called when production alterTableStats is entered. +func (s *BaseDorisParserListener) EnterAlterTableStats(ctx *AlterTableStatsContext) {} + +// ExitAlterTableStats is called when production alterTableStats is exited. +func (s *BaseDorisParserListener) ExitAlterTableStats(ctx *AlterTableStatsContext) {} + +// EnterAlterColumnStats is called when production alterColumnStats is entered. +func (s *BaseDorisParserListener) EnterAlterColumnStats(ctx *AlterColumnStatsContext) {} + +// ExitAlterColumnStats is called when production alterColumnStats is exited. +func (s *BaseDorisParserListener) ExitAlterColumnStats(ctx *AlterColumnStatsContext) {} + +// EnterShowIndexStats is called when production showIndexStats is entered. +func (s *BaseDorisParserListener) EnterShowIndexStats(ctx *ShowIndexStatsContext) {} + +// ExitShowIndexStats is called when production showIndexStats is exited. +func (s *BaseDorisParserListener) ExitShowIndexStats(ctx *ShowIndexStatsContext) {} + +// EnterDropStats is called when production dropStats is entered. +func (s *BaseDorisParserListener) EnterDropStats(ctx *DropStatsContext) {} + +// ExitDropStats is called when production dropStats is exited. +func (s *BaseDorisParserListener) ExitDropStats(ctx *DropStatsContext) {} + +// EnterDropCachedStats is called when production dropCachedStats is entered. +func (s *BaseDorisParserListener) EnterDropCachedStats(ctx *DropCachedStatsContext) {} + +// ExitDropCachedStats is called when production dropCachedStats is exited. +func (s *BaseDorisParserListener) ExitDropCachedStats(ctx *DropCachedStatsContext) {} + +// EnterDropExpiredStats is called when production dropExpiredStats is entered. +func (s *BaseDorisParserListener) EnterDropExpiredStats(ctx *DropExpiredStatsContext) {} + +// ExitDropExpiredStats is called when production dropExpiredStats is exited. +func (s *BaseDorisParserListener) ExitDropExpiredStats(ctx *DropExpiredStatsContext) {} + +// EnterKillAnalyzeJob is called when production killAnalyzeJob is entered. +func (s *BaseDorisParserListener) EnterKillAnalyzeJob(ctx *KillAnalyzeJobContext) {} + +// ExitKillAnalyzeJob is called when production killAnalyzeJob is exited. +func (s *BaseDorisParserListener) ExitKillAnalyzeJob(ctx *KillAnalyzeJobContext) {} + +// EnterDropAnalyzeJob is called when production dropAnalyzeJob is entered. +func (s *BaseDorisParserListener) EnterDropAnalyzeJob(ctx *DropAnalyzeJobContext) {} + +// ExitDropAnalyzeJob is called when production dropAnalyzeJob is exited. +func (s *BaseDorisParserListener) ExitDropAnalyzeJob(ctx *DropAnalyzeJobContext) {} + +// EnterShowTableStats is called when production showTableStats is entered. +func (s *BaseDorisParserListener) EnterShowTableStats(ctx *ShowTableStatsContext) {} + +// ExitShowTableStats is called when production showTableStats is exited. +func (s *BaseDorisParserListener) ExitShowTableStats(ctx *ShowTableStatsContext) {} + +// EnterAnalyzeProperties is called when production analyzeProperties is entered. +func (s *BaseDorisParserListener) EnterAnalyzeProperties(ctx *AnalyzePropertiesContext) {} + +// ExitAnalyzeProperties is called when production analyzeProperties is exited. +func (s *BaseDorisParserListener) ExitAnalyzeProperties(ctx *AnalyzePropertiesContext) {} + +// EnterWorkloadPolicyActions is called when production workloadPolicyActions is entered. +func (s *BaseDorisParserListener) EnterWorkloadPolicyActions(ctx *WorkloadPolicyActionsContext) {} + +// ExitWorkloadPolicyActions is called when production workloadPolicyActions is exited. +func (s *BaseDorisParserListener) ExitWorkloadPolicyActions(ctx *WorkloadPolicyActionsContext) {} + +// EnterWorkloadPolicyAction is called when production workloadPolicyAction is entered. +func (s *BaseDorisParserListener) EnterWorkloadPolicyAction(ctx *WorkloadPolicyActionContext) {} + +// ExitWorkloadPolicyAction is called when production workloadPolicyAction is exited. +func (s *BaseDorisParserListener) ExitWorkloadPolicyAction(ctx *WorkloadPolicyActionContext) {} + +// EnterWorkloadPolicyConditions is called when production workloadPolicyConditions is entered. +func (s *BaseDorisParserListener) EnterWorkloadPolicyConditions(ctx *WorkloadPolicyConditionsContext) { +} + +// ExitWorkloadPolicyConditions is called when production workloadPolicyConditions is exited. +func (s *BaseDorisParserListener) ExitWorkloadPolicyConditions(ctx *WorkloadPolicyConditionsContext) { +} + +// EnterWorkloadPolicyCondition is called when production workloadPolicyCondition is entered. +func (s *BaseDorisParserListener) EnterWorkloadPolicyCondition(ctx *WorkloadPolicyConditionContext) {} + +// ExitWorkloadPolicyCondition is called when production workloadPolicyCondition is exited. +func (s *BaseDorisParserListener) ExitWorkloadPolicyCondition(ctx *WorkloadPolicyConditionContext) {} + +// EnterStorageBackend is called when production storageBackend is entered. +func (s *BaseDorisParserListener) EnterStorageBackend(ctx *StorageBackendContext) {} + +// ExitStorageBackend is called when production storageBackend is exited. +func (s *BaseDorisParserListener) ExitStorageBackend(ctx *StorageBackendContext) {} + +// EnterPasswordOption is called when production passwordOption is entered. +func (s *BaseDorisParserListener) EnterPasswordOption(ctx *PasswordOptionContext) {} + +// ExitPasswordOption is called when production passwordOption is exited. +func (s *BaseDorisParserListener) ExitPasswordOption(ctx *PasswordOptionContext) {} + +// EnterFunctionArguments is called when production functionArguments is entered. +func (s *BaseDorisParserListener) EnterFunctionArguments(ctx *FunctionArgumentsContext) {} + +// ExitFunctionArguments is called when production functionArguments is exited. +func (s *BaseDorisParserListener) ExitFunctionArguments(ctx *FunctionArgumentsContext) {} + +// EnterDataTypeList is called when production dataTypeList is entered. +func (s *BaseDorisParserListener) EnterDataTypeList(ctx *DataTypeListContext) {} + +// ExitDataTypeList is called when production dataTypeList is exited. +func (s *BaseDorisParserListener) ExitDataTypeList(ctx *DataTypeListContext) {} + +// EnterSetOptions is called when production setOptions is entered. +func (s *BaseDorisParserListener) EnterSetOptions(ctx *SetOptionsContext) {} + +// ExitSetOptions is called when production setOptions is exited. +func (s *BaseDorisParserListener) ExitSetOptions(ctx *SetOptionsContext) {} + +// EnterSetDefaultStorageVault is called when production setDefaultStorageVault is entered. +func (s *BaseDorisParserListener) EnterSetDefaultStorageVault(ctx *SetDefaultStorageVaultContext) {} + +// ExitSetDefaultStorageVault is called when production setDefaultStorageVault is exited. +func (s *BaseDorisParserListener) ExitSetDefaultStorageVault(ctx *SetDefaultStorageVaultContext) {} + +// EnterSetUserProperties is called when production setUserProperties is entered. +func (s *BaseDorisParserListener) EnterSetUserProperties(ctx *SetUserPropertiesContext) {} + +// ExitSetUserProperties is called when production setUserProperties is exited. +func (s *BaseDorisParserListener) ExitSetUserProperties(ctx *SetUserPropertiesContext) {} + +// EnterSetTransaction is called when production setTransaction is entered. +func (s *BaseDorisParserListener) EnterSetTransaction(ctx *SetTransactionContext) {} + +// ExitSetTransaction is called when production setTransaction is exited. +func (s *BaseDorisParserListener) ExitSetTransaction(ctx *SetTransactionContext) {} + +// EnterSetVariableWithType is called when production setVariableWithType is entered. +func (s *BaseDorisParserListener) EnterSetVariableWithType(ctx *SetVariableWithTypeContext) {} + +// ExitSetVariableWithType is called when production setVariableWithType is exited. +func (s *BaseDorisParserListener) ExitSetVariableWithType(ctx *SetVariableWithTypeContext) {} + +// EnterSetNames is called when production setNames is entered. +func (s *BaseDorisParserListener) EnterSetNames(ctx *SetNamesContext) {} + +// ExitSetNames is called when production setNames is exited. +func (s *BaseDorisParserListener) ExitSetNames(ctx *SetNamesContext) {} + +// EnterSetCharset is called when production setCharset is entered. +func (s *BaseDorisParserListener) EnterSetCharset(ctx *SetCharsetContext) {} + +// ExitSetCharset is called when production setCharset is exited. +func (s *BaseDorisParserListener) ExitSetCharset(ctx *SetCharsetContext) {} + +// EnterSetCollate is called when production setCollate is entered. +func (s *BaseDorisParserListener) EnterSetCollate(ctx *SetCollateContext) {} + +// ExitSetCollate is called when production setCollate is exited. +func (s *BaseDorisParserListener) ExitSetCollate(ctx *SetCollateContext) {} + +// EnterSetPassword is called when production setPassword is entered. +func (s *BaseDorisParserListener) EnterSetPassword(ctx *SetPasswordContext) {} + +// ExitSetPassword is called when production setPassword is exited. +func (s *BaseDorisParserListener) ExitSetPassword(ctx *SetPasswordContext) {} + +// EnterSetLdapAdminPassword is called when production setLdapAdminPassword is entered. +func (s *BaseDorisParserListener) EnterSetLdapAdminPassword(ctx *SetLdapAdminPasswordContext) {} + +// ExitSetLdapAdminPassword is called when production setLdapAdminPassword is exited. +func (s *BaseDorisParserListener) ExitSetLdapAdminPassword(ctx *SetLdapAdminPasswordContext) {} + +// EnterSetVariableWithoutType is called when production setVariableWithoutType is entered. +func (s *BaseDorisParserListener) EnterSetVariableWithoutType(ctx *SetVariableWithoutTypeContext) {} + +// ExitSetVariableWithoutType is called when production setVariableWithoutType is exited. +func (s *BaseDorisParserListener) ExitSetVariableWithoutType(ctx *SetVariableWithoutTypeContext) {} + +// EnterSetSystemVariable is called when production setSystemVariable is entered. +func (s *BaseDorisParserListener) EnterSetSystemVariable(ctx *SetSystemVariableContext) {} + +// ExitSetSystemVariable is called when production setSystemVariable is exited. +func (s *BaseDorisParserListener) ExitSetSystemVariable(ctx *SetSystemVariableContext) {} + +// EnterSetUserVariable is called when production setUserVariable is entered. +func (s *BaseDorisParserListener) EnterSetUserVariable(ctx *SetUserVariableContext) {} + +// ExitSetUserVariable is called when production setUserVariable is exited. +func (s *BaseDorisParserListener) ExitSetUserVariable(ctx *SetUserVariableContext) {} + +// EnterTransactionAccessMode is called when production transactionAccessMode is entered. +func (s *BaseDorisParserListener) EnterTransactionAccessMode(ctx *TransactionAccessModeContext) {} + +// ExitTransactionAccessMode is called when production transactionAccessMode is exited. +func (s *BaseDorisParserListener) ExitTransactionAccessMode(ctx *TransactionAccessModeContext) {} + +// EnterIsolationLevel is called when production isolationLevel is entered. +func (s *BaseDorisParserListener) EnterIsolationLevel(ctx *IsolationLevelContext) {} + +// ExitIsolationLevel is called when production isolationLevel is exited. +func (s *BaseDorisParserListener) ExitIsolationLevel(ctx *IsolationLevelContext) {} + +// EnterSupportedUnsetStatement is called when production supportedUnsetStatement is entered. +func (s *BaseDorisParserListener) EnterSupportedUnsetStatement(ctx *SupportedUnsetStatementContext) {} + +// ExitSupportedUnsetStatement is called when production supportedUnsetStatement is exited. +func (s *BaseDorisParserListener) ExitSupportedUnsetStatement(ctx *SupportedUnsetStatementContext) {} + +// EnterSwitchCatalog is called when production switchCatalog is entered. +func (s *BaseDorisParserListener) EnterSwitchCatalog(ctx *SwitchCatalogContext) {} + +// ExitSwitchCatalog is called when production switchCatalog is exited. +func (s *BaseDorisParserListener) ExitSwitchCatalog(ctx *SwitchCatalogContext) {} + +// EnterUseDatabase is called when production useDatabase is entered. +func (s *BaseDorisParserListener) EnterUseDatabase(ctx *UseDatabaseContext) {} + +// ExitUseDatabase is called when production useDatabase is exited. +func (s *BaseDorisParserListener) ExitUseDatabase(ctx *UseDatabaseContext) {} + +// EnterUseCloudCluster is called when production useCloudCluster is entered. +func (s *BaseDorisParserListener) EnterUseCloudCluster(ctx *UseCloudClusterContext) {} + +// ExitUseCloudCluster is called when production useCloudCluster is exited. +func (s *BaseDorisParserListener) ExitUseCloudCluster(ctx *UseCloudClusterContext) {} + +// EnterStageAndPattern is called when production stageAndPattern is entered. +func (s *BaseDorisParserListener) EnterStageAndPattern(ctx *StageAndPatternContext) {} + +// ExitStageAndPattern is called when production stageAndPattern is exited. +func (s *BaseDorisParserListener) ExitStageAndPattern(ctx *StageAndPatternContext) {} + +// EnterDescribeTableValuedFunction is called when production describeTableValuedFunction is entered. +func (s *BaseDorisParserListener) EnterDescribeTableValuedFunction(ctx *DescribeTableValuedFunctionContext) { +} + +// ExitDescribeTableValuedFunction is called when production describeTableValuedFunction is exited. +func (s *BaseDorisParserListener) ExitDescribeTableValuedFunction(ctx *DescribeTableValuedFunctionContext) { +} + +// EnterDescribeTableAll is called when production describeTableAll is entered. +func (s *BaseDorisParserListener) EnterDescribeTableAll(ctx *DescribeTableAllContext) {} + +// ExitDescribeTableAll is called when production describeTableAll is exited. +func (s *BaseDorisParserListener) ExitDescribeTableAll(ctx *DescribeTableAllContext) {} + +// EnterDescribeTable is called when production describeTable is entered. +func (s *BaseDorisParserListener) EnterDescribeTable(ctx *DescribeTableContext) {} + +// ExitDescribeTable is called when production describeTable is exited. +func (s *BaseDorisParserListener) ExitDescribeTable(ctx *DescribeTableContext) {} + +// EnterDescribeDictionary is called when production describeDictionary is entered. +func (s *BaseDorisParserListener) EnterDescribeDictionary(ctx *DescribeDictionaryContext) {} + +// ExitDescribeDictionary is called when production describeDictionary is exited. +func (s *BaseDorisParserListener) ExitDescribeDictionary(ctx *DescribeDictionaryContext) {} + +// EnterConstraint is called when production constraint is entered. +func (s *BaseDorisParserListener) EnterConstraint(ctx *ConstraintContext) {} + +// ExitConstraint is called when production constraint is exited. +func (s *BaseDorisParserListener) ExitConstraint(ctx *ConstraintContext) {} + +// EnterPartitionSpec is called when production partitionSpec is entered. +func (s *BaseDorisParserListener) EnterPartitionSpec(ctx *PartitionSpecContext) {} + +// ExitPartitionSpec is called when production partitionSpec is exited. +func (s *BaseDorisParserListener) ExitPartitionSpec(ctx *PartitionSpecContext) {} + +// EnterPartitionTable is called when production partitionTable is entered. +func (s *BaseDorisParserListener) EnterPartitionTable(ctx *PartitionTableContext) {} + +// ExitPartitionTable is called when production partitionTable is exited. +func (s *BaseDorisParserListener) ExitPartitionTable(ctx *PartitionTableContext) {} + +// EnterIdentityOrFunctionList is called when production identityOrFunctionList is entered. +func (s *BaseDorisParserListener) EnterIdentityOrFunctionList(ctx *IdentityOrFunctionListContext) {} + +// ExitIdentityOrFunctionList is called when production identityOrFunctionList is exited. +func (s *BaseDorisParserListener) ExitIdentityOrFunctionList(ctx *IdentityOrFunctionListContext) {} + +// EnterIdentityOrFunction is called when production identityOrFunction is entered. +func (s *BaseDorisParserListener) EnterIdentityOrFunction(ctx *IdentityOrFunctionContext) {} + +// ExitIdentityOrFunction is called when production identityOrFunction is exited. +func (s *BaseDorisParserListener) ExitIdentityOrFunction(ctx *IdentityOrFunctionContext) {} + +// EnterDataDesc is called when production dataDesc is entered. +func (s *BaseDorisParserListener) EnterDataDesc(ctx *DataDescContext) {} + +// ExitDataDesc is called when production dataDesc is exited. +func (s *BaseDorisParserListener) ExitDataDesc(ctx *DataDescContext) {} + +// EnterStatementScope is called when production statementScope is entered. +func (s *BaseDorisParserListener) EnterStatementScope(ctx *StatementScopeContext) {} + +// ExitStatementScope is called when production statementScope is exited. +func (s *BaseDorisParserListener) ExitStatementScope(ctx *StatementScopeContext) {} + +// EnterBuildMode is called when production buildMode is entered. +func (s *BaseDorisParserListener) EnterBuildMode(ctx *BuildModeContext) {} + +// ExitBuildMode is called when production buildMode is exited. +func (s *BaseDorisParserListener) ExitBuildMode(ctx *BuildModeContext) {} + +// EnterRefreshTrigger is called when production refreshTrigger is entered. +func (s *BaseDorisParserListener) EnterRefreshTrigger(ctx *RefreshTriggerContext) {} + +// ExitRefreshTrigger is called when production refreshTrigger is exited. +func (s *BaseDorisParserListener) ExitRefreshTrigger(ctx *RefreshTriggerContext) {} + +// EnterRefreshSchedule is called when production refreshSchedule is entered. +func (s *BaseDorisParserListener) EnterRefreshSchedule(ctx *RefreshScheduleContext) {} + +// ExitRefreshSchedule is called when production refreshSchedule is exited. +func (s *BaseDorisParserListener) ExitRefreshSchedule(ctx *RefreshScheduleContext) {} + +// EnterRefreshMethod is called when production refreshMethod is entered. +func (s *BaseDorisParserListener) EnterRefreshMethod(ctx *RefreshMethodContext) {} + +// ExitRefreshMethod is called when production refreshMethod is exited. +func (s *BaseDorisParserListener) ExitRefreshMethod(ctx *RefreshMethodContext) {} + +// EnterMvPartition is called when production mvPartition is entered. +func (s *BaseDorisParserListener) EnterMvPartition(ctx *MvPartitionContext) {} + +// ExitMvPartition is called when production mvPartition is exited. +func (s *BaseDorisParserListener) ExitMvPartition(ctx *MvPartitionContext) {} + +// EnterIdentifierOrText is called when production identifierOrText is entered. +func (s *BaseDorisParserListener) EnterIdentifierOrText(ctx *IdentifierOrTextContext) {} + +// ExitIdentifierOrText is called when production identifierOrText is exited. +func (s *BaseDorisParserListener) ExitIdentifierOrText(ctx *IdentifierOrTextContext) {} + +// EnterIdentifierOrTextOrAsterisk is called when production identifierOrTextOrAsterisk is entered. +func (s *BaseDorisParserListener) EnterIdentifierOrTextOrAsterisk(ctx *IdentifierOrTextOrAsteriskContext) { +} + +// ExitIdentifierOrTextOrAsterisk is called when production identifierOrTextOrAsterisk is exited. +func (s *BaseDorisParserListener) ExitIdentifierOrTextOrAsterisk(ctx *IdentifierOrTextOrAsteriskContext) { +} + +// EnterMultipartIdentifierOrAsterisk is called when production multipartIdentifierOrAsterisk is entered. +func (s *BaseDorisParserListener) EnterMultipartIdentifierOrAsterisk(ctx *MultipartIdentifierOrAsteriskContext) { +} + +// ExitMultipartIdentifierOrAsterisk is called when production multipartIdentifierOrAsterisk is exited. +func (s *BaseDorisParserListener) ExitMultipartIdentifierOrAsterisk(ctx *MultipartIdentifierOrAsteriskContext) { +} + +// EnterIdentifierOrAsterisk is called when production identifierOrAsterisk is entered. +func (s *BaseDorisParserListener) EnterIdentifierOrAsterisk(ctx *IdentifierOrAsteriskContext) {} + +// ExitIdentifierOrAsterisk is called when production identifierOrAsterisk is exited. +func (s *BaseDorisParserListener) ExitIdentifierOrAsterisk(ctx *IdentifierOrAsteriskContext) {} + +// EnterUserIdentify is called when production userIdentify is entered. +func (s *BaseDorisParserListener) EnterUserIdentify(ctx *UserIdentifyContext) {} + +// ExitUserIdentify is called when production userIdentify is exited. +func (s *BaseDorisParserListener) ExitUserIdentify(ctx *UserIdentifyContext) {} + +// EnterGrantUserIdentify is called when production grantUserIdentify is entered. +func (s *BaseDorisParserListener) EnterGrantUserIdentify(ctx *GrantUserIdentifyContext) {} + +// ExitGrantUserIdentify is called when production grantUserIdentify is exited. +func (s *BaseDorisParserListener) ExitGrantUserIdentify(ctx *GrantUserIdentifyContext) {} + +// EnterExplain is called when production explain is entered. +func (s *BaseDorisParserListener) EnterExplain(ctx *ExplainContext) {} + +// ExitExplain is called when production explain is exited. +func (s *BaseDorisParserListener) ExitExplain(ctx *ExplainContext) {} + +// EnterExplainCommand is called when production explainCommand is entered. +func (s *BaseDorisParserListener) EnterExplainCommand(ctx *ExplainCommandContext) {} + +// ExitExplainCommand is called when production explainCommand is exited. +func (s *BaseDorisParserListener) ExitExplainCommand(ctx *ExplainCommandContext) {} + +// EnterPlanType is called when production planType is entered. +func (s *BaseDorisParserListener) EnterPlanType(ctx *PlanTypeContext) {} + +// ExitPlanType is called when production planType is exited. +func (s *BaseDorisParserListener) ExitPlanType(ctx *PlanTypeContext) {} + +// EnterReplayCommand is called when production replayCommand is entered. +func (s *BaseDorisParserListener) EnterReplayCommand(ctx *ReplayCommandContext) {} + +// ExitReplayCommand is called when production replayCommand is exited. +func (s *BaseDorisParserListener) ExitReplayCommand(ctx *ReplayCommandContext) {} + +// EnterReplayType is called when production replayType is entered. +func (s *BaseDorisParserListener) EnterReplayType(ctx *ReplayTypeContext) {} + +// ExitReplayType is called when production replayType is exited. +func (s *BaseDorisParserListener) ExitReplayType(ctx *ReplayTypeContext) {} + +// EnterMergeType is called when production mergeType is entered. +func (s *BaseDorisParserListener) EnterMergeType(ctx *MergeTypeContext) {} + +// ExitMergeType is called when production mergeType is exited. +func (s *BaseDorisParserListener) ExitMergeType(ctx *MergeTypeContext) {} + +// EnterPreFilterClause is called when production preFilterClause is entered. +func (s *BaseDorisParserListener) EnterPreFilterClause(ctx *PreFilterClauseContext) {} + +// ExitPreFilterClause is called when production preFilterClause is exited. +func (s *BaseDorisParserListener) ExitPreFilterClause(ctx *PreFilterClauseContext) {} + +// EnterDeleteOnClause is called when production deleteOnClause is entered. +func (s *BaseDorisParserListener) EnterDeleteOnClause(ctx *DeleteOnClauseContext) {} + +// ExitDeleteOnClause is called when production deleteOnClause is exited. +func (s *BaseDorisParserListener) ExitDeleteOnClause(ctx *DeleteOnClauseContext) {} + +// EnterSequenceColClause is called when production sequenceColClause is entered. +func (s *BaseDorisParserListener) EnterSequenceColClause(ctx *SequenceColClauseContext) {} + +// ExitSequenceColClause is called when production sequenceColClause is exited. +func (s *BaseDorisParserListener) ExitSequenceColClause(ctx *SequenceColClauseContext) {} + +// EnterColFromPath is called when production colFromPath is entered. +func (s *BaseDorisParserListener) EnterColFromPath(ctx *ColFromPathContext) {} + +// ExitColFromPath is called when production colFromPath is exited. +func (s *BaseDorisParserListener) ExitColFromPath(ctx *ColFromPathContext) {} + +// EnterColMappingList is called when production colMappingList is entered. +func (s *BaseDorisParserListener) EnterColMappingList(ctx *ColMappingListContext) {} + +// ExitColMappingList is called when production colMappingList is exited. +func (s *BaseDorisParserListener) ExitColMappingList(ctx *ColMappingListContext) {} + +// EnterMappingExpr is called when production mappingExpr is entered. +func (s *BaseDorisParserListener) EnterMappingExpr(ctx *MappingExprContext) {} + +// ExitMappingExpr is called when production mappingExpr is exited. +func (s *BaseDorisParserListener) ExitMappingExpr(ctx *MappingExprContext) {} + +// EnterWithRemoteStorageSystem is called when production withRemoteStorageSystem is entered. +func (s *BaseDorisParserListener) EnterWithRemoteStorageSystem(ctx *WithRemoteStorageSystemContext) {} + +// ExitWithRemoteStorageSystem is called when production withRemoteStorageSystem is exited. +func (s *BaseDorisParserListener) ExitWithRemoteStorageSystem(ctx *WithRemoteStorageSystemContext) {} + +// EnterResourceDesc is called when production resourceDesc is entered. +func (s *BaseDorisParserListener) EnterResourceDesc(ctx *ResourceDescContext) {} + +// ExitResourceDesc is called when production resourceDesc is exited. +func (s *BaseDorisParserListener) ExitResourceDesc(ctx *ResourceDescContext) {} + +// EnterMysqlDataDesc is called when production mysqlDataDesc is entered. +func (s *BaseDorisParserListener) EnterMysqlDataDesc(ctx *MysqlDataDescContext) {} + +// ExitMysqlDataDesc is called when production mysqlDataDesc is exited. +func (s *BaseDorisParserListener) ExitMysqlDataDesc(ctx *MysqlDataDescContext) {} + +// EnterSkipLines is called when production skipLines is entered. +func (s *BaseDorisParserListener) EnterSkipLines(ctx *SkipLinesContext) {} + +// ExitSkipLines is called when production skipLines is exited. +func (s *BaseDorisParserListener) ExitSkipLines(ctx *SkipLinesContext) {} + +// EnterOutFileClause is called when production outFileClause is entered. +func (s *BaseDorisParserListener) EnterOutFileClause(ctx *OutFileClauseContext) {} + +// ExitOutFileClause is called when production outFileClause is exited. +func (s *BaseDorisParserListener) ExitOutFileClause(ctx *OutFileClauseContext) {} + +// EnterQuery is called when production query is entered. +func (s *BaseDorisParserListener) EnterQuery(ctx *QueryContext) {} + +// ExitQuery is called when production query is exited. +func (s *BaseDorisParserListener) ExitQuery(ctx *QueryContext) {} + +// EnterQueryTermDefault is called when production queryTermDefault is entered. +func (s *BaseDorisParserListener) EnterQueryTermDefault(ctx *QueryTermDefaultContext) {} + +// ExitQueryTermDefault is called when production queryTermDefault is exited. +func (s *BaseDorisParserListener) ExitQueryTermDefault(ctx *QueryTermDefaultContext) {} + +// EnterSetOperation is called when production setOperation is entered. +func (s *BaseDorisParserListener) EnterSetOperation(ctx *SetOperationContext) {} + +// ExitSetOperation is called when production setOperation is exited. +func (s *BaseDorisParserListener) ExitSetOperation(ctx *SetOperationContext) {} + +// EnterSetQuantifier is called when production setQuantifier is entered. +func (s *BaseDorisParserListener) EnterSetQuantifier(ctx *SetQuantifierContext) {} + +// ExitSetQuantifier is called when production setQuantifier is exited. +func (s *BaseDorisParserListener) ExitSetQuantifier(ctx *SetQuantifierContext) {} + +// EnterQueryPrimaryDefault is called when production queryPrimaryDefault is entered. +func (s *BaseDorisParserListener) EnterQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) {} + +// ExitQueryPrimaryDefault is called when production queryPrimaryDefault is exited. +func (s *BaseDorisParserListener) ExitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) {} + +// EnterSubquery is called when production subquery is entered. +func (s *BaseDorisParserListener) EnterSubquery(ctx *SubqueryContext) {} + +// ExitSubquery is called when production subquery is exited. +func (s *BaseDorisParserListener) ExitSubquery(ctx *SubqueryContext) {} + +// EnterValuesTable is called when production valuesTable is entered. +func (s *BaseDorisParserListener) EnterValuesTable(ctx *ValuesTableContext) {} + +// ExitValuesTable is called when production valuesTable is exited. +func (s *BaseDorisParserListener) ExitValuesTable(ctx *ValuesTableContext) {} + +// EnterRegularQuerySpecification is called when production regularQuerySpecification is entered. +func (s *BaseDorisParserListener) EnterRegularQuerySpecification(ctx *RegularQuerySpecificationContext) { +} + +// ExitRegularQuerySpecification is called when production regularQuerySpecification is exited. +func (s *BaseDorisParserListener) ExitRegularQuerySpecification(ctx *RegularQuerySpecificationContext) { +} + +// EnterCte is called when production cte is entered. +func (s *BaseDorisParserListener) EnterCte(ctx *CteContext) {} + +// ExitCte is called when production cte is exited. +func (s *BaseDorisParserListener) ExitCte(ctx *CteContext) {} + +// EnterAliasQuery is called when production aliasQuery is entered. +func (s *BaseDorisParserListener) EnterAliasQuery(ctx *AliasQueryContext) {} + +// ExitAliasQuery is called when production aliasQuery is exited. +func (s *BaseDorisParserListener) ExitAliasQuery(ctx *AliasQueryContext) {} + +// EnterColumnAliases is called when production columnAliases is entered. +func (s *BaseDorisParserListener) EnterColumnAliases(ctx *ColumnAliasesContext) {} + +// ExitColumnAliases is called when production columnAliases is exited. +func (s *BaseDorisParserListener) ExitColumnAliases(ctx *ColumnAliasesContext) {} + +// EnterSelectClause is called when production selectClause is entered. +func (s *BaseDorisParserListener) EnterSelectClause(ctx *SelectClauseContext) {} + +// ExitSelectClause is called when production selectClause is exited. +func (s *BaseDorisParserListener) ExitSelectClause(ctx *SelectClauseContext) {} + +// EnterSelectColumnClause is called when production selectColumnClause is entered. +func (s *BaseDorisParserListener) EnterSelectColumnClause(ctx *SelectColumnClauseContext) {} + +// ExitSelectColumnClause is called when production selectColumnClause is exited. +func (s *BaseDorisParserListener) ExitSelectColumnClause(ctx *SelectColumnClauseContext) {} + +// EnterWhereClause is called when production whereClause is entered. +func (s *BaseDorisParserListener) EnterWhereClause(ctx *WhereClauseContext) {} + +// ExitWhereClause is called when production whereClause is exited. +func (s *BaseDorisParserListener) ExitWhereClause(ctx *WhereClauseContext) {} + +// EnterFromClause is called when production fromClause is entered. +func (s *BaseDorisParserListener) EnterFromClause(ctx *FromClauseContext) {} + +// ExitFromClause is called when production fromClause is exited. +func (s *BaseDorisParserListener) ExitFromClause(ctx *FromClauseContext) {} + +// EnterIntoClause is called when production intoClause is entered. +func (s *BaseDorisParserListener) EnterIntoClause(ctx *IntoClauseContext) {} + +// ExitIntoClause is called when production intoClause is exited. +func (s *BaseDorisParserListener) ExitIntoClause(ctx *IntoClauseContext) {} + +// EnterBulkCollectClause is called when production bulkCollectClause is entered. +func (s *BaseDorisParserListener) EnterBulkCollectClause(ctx *BulkCollectClauseContext) {} + +// ExitBulkCollectClause is called when production bulkCollectClause is exited. +func (s *BaseDorisParserListener) ExitBulkCollectClause(ctx *BulkCollectClauseContext) {} + +// EnterTableRow is called when production tableRow is entered. +func (s *BaseDorisParserListener) EnterTableRow(ctx *TableRowContext) {} + +// ExitTableRow is called when production tableRow is exited. +func (s *BaseDorisParserListener) ExitTableRow(ctx *TableRowContext) {} + +// EnterRelations is called when production relations is entered. +func (s *BaseDorisParserListener) EnterRelations(ctx *RelationsContext) {} + +// ExitRelations is called when production relations is exited. +func (s *BaseDorisParserListener) ExitRelations(ctx *RelationsContext) {} + +// EnterRelation is called when production relation is entered. +func (s *BaseDorisParserListener) EnterRelation(ctx *RelationContext) {} + +// ExitRelation is called when production relation is exited. +func (s *BaseDorisParserListener) ExitRelation(ctx *RelationContext) {} + +// EnterJoinRelation is called when production joinRelation is entered. +func (s *BaseDorisParserListener) EnterJoinRelation(ctx *JoinRelationContext) {} + +// ExitJoinRelation is called when production joinRelation is exited. +func (s *BaseDorisParserListener) ExitJoinRelation(ctx *JoinRelationContext) {} + +// EnterDistributeType is called when production distributeType is entered. +func (s *BaseDorisParserListener) EnterDistributeType(ctx *DistributeTypeContext) {} + +// ExitDistributeType is called when production distributeType is exited. +func (s *BaseDorisParserListener) ExitDistributeType(ctx *DistributeTypeContext) {} + +// EnterSkewHint is called when production skewHint is entered. +func (s *BaseDorisParserListener) EnterSkewHint(ctx *SkewHintContext) {} + +// ExitSkewHint is called when production skewHint is exited. +func (s *BaseDorisParserListener) ExitSkewHint(ctx *SkewHintContext) {} + +// EnterConstantList is called when production constantList is entered. +func (s *BaseDorisParserListener) EnterConstantList(ctx *ConstantListContext) {} + +// ExitConstantList is called when production constantList is exited. +func (s *BaseDorisParserListener) ExitConstantList(ctx *ConstantListContext) {} + +// EnterBracketRelationHint is called when production bracketRelationHint is entered. +func (s *BaseDorisParserListener) EnterBracketRelationHint(ctx *BracketRelationHintContext) {} + +// ExitBracketRelationHint is called when production bracketRelationHint is exited. +func (s *BaseDorisParserListener) ExitBracketRelationHint(ctx *BracketRelationHintContext) {} + +// EnterCommentRelationHint is called when production commentRelationHint is entered. +func (s *BaseDorisParserListener) EnterCommentRelationHint(ctx *CommentRelationHintContext) {} + +// ExitCommentRelationHint is called when production commentRelationHint is exited. +func (s *BaseDorisParserListener) ExitCommentRelationHint(ctx *CommentRelationHintContext) {} + +// EnterExpressionWithOrder is called when production expressionWithOrder is entered. +func (s *BaseDorisParserListener) EnterExpressionWithOrder(ctx *ExpressionWithOrderContext) {} + +// ExitExpressionWithOrder is called when production expressionWithOrder is exited. +func (s *BaseDorisParserListener) ExitExpressionWithOrder(ctx *ExpressionWithOrderContext) {} + +// EnterAggClause is called when production aggClause is entered. +func (s *BaseDorisParserListener) EnterAggClause(ctx *AggClauseContext) {} + +// ExitAggClause is called when production aggClause is exited. +func (s *BaseDorisParserListener) ExitAggClause(ctx *AggClauseContext) {} + +// EnterGroupingElement is called when production groupingElement is entered. +func (s *BaseDorisParserListener) EnterGroupingElement(ctx *GroupingElementContext) {} + +// ExitGroupingElement is called when production groupingElement is exited. +func (s *BaseDorisParserListener) ExitGroupingElement(ctx *GroupingElementContext) {} + +// EnterGroupingSet is called when production groupingSet is entered. +func (s *BaseDorisParserListener) EnterGroupingSet(ctx *GroupingSetContext) {} + +// ExitGroupingSet is called when production groupingSet is exited. +func (s *BaseDorisParserListener) ExitGroupingSet(ctx *GroupingSetContext) {} + +// EnterHavingClause is called when production havingClause is entered. +func (s *BaseDorisParserListener) EnterHavingClause(ctx *HavingClauseContext) {} + +// ExitHavingClause is called when production havingClause is exited. +func (s *BaseDorisParserListener) ExitHavingClause(ctx *HavingClauseContext) {} + +// EnterQualifyClause is called when production qualifyClause is entered. +func (s *BaseDorisParserListener) EnterQualifyClause(ctx *QualifyClauseContext) {} + +// ExitQualifyClause is called when production qualifyClause is exited. +func (s *BaseDorisParserListener) ExitQualifyClause(ctx *QualifyClauseContext) {} + +// EnterSelectHint is called when production selectHint is entered. +func (s *BaseDorisParserListener) EnterSelectHint(ctx *SelectHintContext) {} + +// ExitSelectHint is called when production selectHint is exited. +func (s *BaseDorisParserListener) ExitSelectHint(ctx *SelectHintContext) {} + +// EnterHintStatement is called when production hintStatement is entered. +func (s *BaseDorisParserListener) EnterHintStatement(ctx *HintStatementContext) {} + +// ExitHintStatement is called when production hintStatement is exited. +func (s *BaseDorisParserListener) ExitHintStatement(ctx *HintStatementContext) {} + +// EnterHintName is called when production hintName is entered. +func (s *BaseDorisParserListener) EnterHintName(ctx *HintNameContext) {} + +// ExitHintName is called when production hintName is exited. +func (s *BaseDorisParserListener) ExitHintName(ctx *HintNameContext) {} + +// EnterHintAssignment is called when production hintAssignment is entered. +func (s *BaseDorisParserListener) EnterHintAssignment(ctx *HintAssignmentContext) {} + +// ExitHintAssignment is called when production hintAssignment is exited. +func (s *BaseDorisParserListener) ExitHintAssignment(ctx *HintAssignmentContext) {} + +// EnterUpdateAssignment is called when production updateAssignment is entered. +func (s *BaseDorisParserListener) EnterUpdateAssignment(ctx *UpdateAssignmentContext) {} + +// ExitUpdateAssignment is called when production updateAssignment is exited. +func (s *BaseDorisParserListener) ExitUpdateAssignment(ctx *UpdateAssignmentContext) {} + +// EnterUpdateAssignmentSeq is called when production updateAssignmentSeq is entered. +func (s *BaseDorisParserListener) EnterUpdateAssignmentSeq(ctx *UpdateAssignmentSeqContext) {} + +// ExitUpdateAssignmentSeq is called when production updateAssignmentSeq is exited. +func (s *BaseDorisParserListener) ExitUpdateAssignmentSeq(ctx *UpdateAssignmentSeqContext) {} + +// EnterLateralView is called when production lateralView is entered. +func (s *BaseDorisParserListener) EnterLateralView(ctx *LateralViewContext) {} + +// ExitLateralView is called when production lateralView is exited. +func (s *BaseDorisParserListener) ExitLateralView(ctx *LateralViewContext) {} + +// EnterQueryOrganization is called when production queryOrganization is entered. +func (s *BaseDorisParserListener) EnterQueryOrganization(ctx *QueryOrganizationContext) {} + +// ExitQueryOrganization is called when production queryOrganization is exited. +func (s *BaseDorisParserListener) ExitQueryOrganization(ctx *QueryOrganizationContext) {} + +// EnterSortClause is called when production sortClause is entered. +func (s *BaseDorisParserListener) EnterSortClause(ctx *SortClauseContext) {} + +// ExitSortClause is called when production sortClause is exited. +func (s *BaseDorisParserListener) ExitSortClause(ctx *SortClauseContext) {} + +// EnterSortItem is called when production sortItem is entered. +func (s *BaseDorisParserListener) EnterSortItem(ctx *SortItemContext) {} + +// ExitSortItem is called when production sortItem is exited. +func (s *BaseDorisParserListener) ExitSortItem(ctx *SortItemContext) {} + +// EnterLimitClause is called when production limitClause is entered. +func (s *BaseDorisParserListener) EnterLimitClause(ctx *LimitClauseContext) {} + +// ExitLimitClause is called when production limitClause is exited. +func (s *BaseDorisParserListener) ExitLimitClause(ctx *LimitClauseContext) {} + +// EnterPartitionClause is called when production partitionClause is entered. +func (s *BaseDorisParserListener) EnterPartitionClause(ctx *PartitionClauseContext) {} + +// ExitPartitionClause is called when production partitionClause is exited. +func (s *BaseDorisParserListener) ExitPartitionClause(ctx *PartitionClauseContext) {} + +// EnterJoinType is called when production joinType is entered. +func (s *BaseDorisParserListener) EnterJoinType(ctx *JoinTypeContext) {} + +// ExitJoinType is called when production joinType is exited. +func (s *BaseDorisParserListener) ExitJoinType(ctx *JoinTypeContext) {} + +// EnterJoinCriteria is called when production joinCriteria is entered. +func (s *BaseDorisParserListener) EnterJoinCriteria(ctx *JoinCriteriaContext) {} + +// ExitJoinCriteria is called when production joinCriteria is exited. +func (s *BaseDorisParserListener) ExitJoinCriteria(ctx *JoinCriteriaContext) {} + +// EnterIdentifierList is called when production identifierList is entered. +func (s *BaseDorisParserListener) EnterIdentifierList(ctx *IdentifierListContext) {} + +// ExitIdentifierList is called when production identifierList is exited. +func (s *BaseDorisParserListener) ExitIdentifierList(ctx *IdentifierListContext) {} + +// EnterIdentifierSeq is called when production identifierSeq is entered. +func (s *BaseDorisParserListener) EnterIdentifierSeq(ctx *IdentifierSeqContext) {} + +// ExitIdentifierSeq is called when production identifierSeq is exited. +func (s *BaseDorisParserListener) ExitIdentifierSeq(ctx *IdentifierSeqContext) {} + +// EnterOptScanParams is called when production optScanParams is entered. +func (s *BaseDorisParserListener) EnterOptScanParams(ctx *OptScanParamsContext) {} + +// ExitOptScanParams is called when production optScanParams is exited. +func (s *BaseDorisParserListener) ExitOptScanParams(ctx *OptScanParamsContext) {} + +// EnterTableName is called when production tableName is entered. +func (s *BaseDorisParserListener) EnterTableName(ctx *TableNameContext) {} + +// ExitTableName is called when production tableName is exited. +func (s *BaseDorisParserListener) ExitTableName(ctx *TableNameContext) {} + +// EnterAliasedQuery is called when production aliasedQuery is entered. +func (s *BaseDorisParserListener) EnterAliasedQuery(ctx *AliasedQueryContext) {} + +// ExitAliasedQuery is called when production aliasedQuery is exited. +func (s *BaseDorisParserListener) ExitAliasedQuery(ctx *AliasedQueryContext) {} + +// EnterTableValuedFunction is called when production tableValuedFunction is entered. +func (s *BaseDorisParserListener) EnterTableValuedFunction(ctx *TableValuedFunctionContext) {} + +// ExitTableValuedFunction is called when production tableValuedFunction is exited. +func (s *BaseDorisParserListener) ExitTableValuedFunction(ctx *TableValuedFunctionContext) {} + +// EnterRelationList is called when production relationList is entered. +func (s *BaseDorisParserListener) EnterRelationList(ctx *RelationListContext) {} + +// ExitRelationList is called when production relationList is exited. +func (s *BaseDorisParserListener) ExitRelationList(ctx *RelationListContext) {} + +// EnterMaterializedViewName is called when production materializedViewName is entered. +func (s *BaseDorisParserListener) EnterMaterializedViewName(ctx *MaterializedViewNameContext) {} + +// ExitMaterializedViewName is called when production materializedViewName is exited. +func (s *BaseDorisParserListener) ExitMaterializedViewName(ctx *MaterializedViewNameContext) {} + +// EnterPropertyClause is called when production propertyClause is entered. +func (s *BaseDorisParserListener) EnterPropertyClause(ctx *PropertyClauseContext) {} + +// ExitPropertyClause is called when production propertyClause is exited. +func (s *BaseDorisParserListener) ExitPropertyClause(ctx *PropertyClauseContext) {} + +// EnterPropertyItemList is called when production propertyItemList is entered. +func (s *BaseDorisParserListener) EnterPropertyItemList(ctx *PropertyItemListContext) {} + +// ExitPropertyItemList is called when production propertyItemList is exited. +func (s *BaseDorisParserListener) ExitPropertyItemList(ctx *PropertyItemListContext) {} + +// EnterPropertyItem is called when production propertyItem is entered. +func (s *BaseDorisParserListener) EnterPropertyItem(ctx *PropertyItemContext) {} + +// ExitPropertyItem is called when production propertyItem is exited. +func (s *BaseDorisParserListener) ExitPropertyItem(ctx *PropertyItemContext) {} + +// EnterPropertyKey is called when production propertyKey is entered. +func (s *BaseDorisParserListener) EnterPropertyKey(ctx *PropertyKeyContext) {} + +// ExitPropertyKey is called when production propertyKey is exited. +func (s *BaseDorisParserListener) ExitPropertyKey(ctx *PropertyKeyContext) {} + +// EnterPropertyValue is called when production propertyValue is entered. +func (s *BaseDorisParserListener) EnterPropertyValue(ctx *PropertyValueContext) {} + +// ExitPropertyValue is called when production propertyValue is exited. +func (s *BaseDorisParserListener) ExitPropertyValue(ctx *PropertyValueContext) {} + +// EnterTableAlias is called when production tableAlias is entered. +func (s *BaseDorisParserListener) EnterTableAlias(ctx *TableAliasContext) {} + +// ExitTableAlias is called when production tableAlias is exited. +func (s *BaseDorisParserListener) ExitTableAlias(ctx *TableAliasContext) {} + +// EnterMultipartIdentifier is called when production multipartIdentifier is entered. +func (s *BaseDorisParserListener) EnterMultipartIdentifier(ctx *MultipartIdentifierContext) {} + +// ExitMultipartIdentifier is called when production multipartIdentifier is exited. +func (s *BaseDorisParserListener) ExitMultipartIdentifier(ctx *MultipartIdentifierContext) {} + +// EnterSimpleColumnDefs is called when production simpleColumnDefs is entered. +func (s *BaseDorisParserListener) EnterSimpleColumnDefs(ctx *SimpleColumnDefsContext) {} + +// ExitSimpleColumnDefs is called when production simpleColumnDefs is exited. +func (s *BaseDorisParserListener) ExitSimpleColumnDefs(ctx *SimpleColumnDefsContext) {} + +// EnterSimpleColumnDef is called when production simpleColumnDef is entered. +func (s *BaseDorisParserListener) EnterSimpleColumnDef(ctx *SimpleColumnDefContext) {} + +// ExitSimpleColumnDef is called when production simpleColumnDef is exited. +func (s *BaseDorisParserListener) ExitSimpleColumnDef(ctx *SimpleColumnDefContext) {} + +// EnterColumnDefs is called when production columnDefs is entered. +func (s *BaseDorisParserListener) EnterColumnDefs(ctx *ColumnDefsContext) {} + +// ExitColumnDefs is called when production columnDefs is exited. +func (s *BaseDorisParserListener) ExitColumnDefs(ctx *ColumnDefsContext) {} + +// EnterColumnDef is called when production columnDef is entered. +func (s *BaseDorisParserListener) EnterColumnDef(ctx *ColumnDefContext) {} + +// ExitColumnDef is called when production columnDef is exited. +func (s *BaseDorisParserListener) ExitColumnDef(ctx *ColumnDefContext) {} + +// EnterIndexDefs is called when production indexDefs is entered. +func (s *BaseDorisParserListener) EnterIndexDefs(ctx *IndexDefsContext) {} + +// ExitIndexDefs is called when production indexDefs is exited. +func (s *BaseDorisParserListener) ExitIndexDefs(ctx *IndexDefsContext) {} + +// EnterIndexDef is called when production indexDef is entered. +func (s *BaseDorisParserListener) EnterIndexDef(ctx *IndexDefContext) {} + +// ExitIndexDef is called when production indexDef is exited. +func (s *BaseDorisParserListener) ExitIndexDef(ctx *IndexDefContext) {} + +// EnterPartitionsDef is called when production partitionsDef is entered. +func (s *BaseDorisParserListener) EnterPartitionsDef(ctx *PartitionsDefContext) {} + +// ExitPartitionsDef is called when production partitionsDef is exited. +func (s *BaseDorisParserListener) ExitPartitionsDef(ctx *PartitionsDefContext) {} + +// EnterPartitionDef is called when production partitionDef is entered. +func (s *BaseDorisParserListener) EnterPartitionDef(ctx *PartitionDefContext) {} + +// ExitPartitionDef is called when production partitionDef is exited. +func (s *BaseDorisParserListener) ExitPartitionDef(ctx *PartitionDefContext) {} + +// EnterLessThanPartitionDef is called when production lessThanPartitionDef is entered. +func (s *BaseDorisParserListener) EnterLessThanPartitionDef(ctx *LessThanPartitionDefContext) {} + +// ExitLessThanPartitionDef is called when production lessThanPartitionDef is exited. +func (s *BaseDorisParserListener) ExitLessThanPartitionDef(ctx *LessThanPartitionDefContext) {} + +// EnterFixedPartitionDef is called when production fixedPartitionDef is entered. +func (s *BaseDorisParserListener) EnterFixedPartitionDef(ctx *FixedPartitionDefContext) {} + +// ExitFixedPartitionDef is called when production fixedPartitionDef is exited. +func (s *BaseDorisParserListener) ExitFixedPartitionDef(ctx *FixedPartitionDefContext) {} + +// EnterStepPartitionDef is called when production stepPartitionDef is entered. +func (s *BaseDorisParserListener) EnterStepPartitionDef(ctx *StepPartitionDefContext) {} + +// ExitStepPartitionDef is called when production stepPartitionDef is exited. +func (s *BaseDorisParserListener) ExitStepPartitionDef(ctx *StepPartitionDefContext) {} + +// EnterInPartitionDef is called when production inPartitionDef is entered. +func (s *BaseDorisParserListener) EnterInPartitionDef(ctx *InPartitionDefContext) {} + +// ExitInPartitionDef is called when production inPartitionDef is exited. +func (s *BaseDorisParserListener) ExitInPartitionDef(ctx *InPartitionDefContext) {} + +// EnterPartitionValueList is called when production partitionValueList is entered. +func (s *BaseDorisParserListener) EnterPartitionValueList(ctx *PartitionValueListContext) {} + +// ExitPartitionValueList is called when production partitionValueList is exited. +func (s *BaseDorisParserListener) ExitPartitionValueList(ctx *PartitionValueListContext) {} + +// EnterPartitionValueDef is called when production partitionValueDef is entered. +func (s *BaseDorisParserListener) EnterPartitionValueDef(ctx *PartitionValueDefContext) {} + +// ExitPartitionValueDef is called when production partitionValueDef is exited. +func (s *BaseDorisParserListener) ExitPartitionValueDef(ctx *PartitionValueDefContext) {} + +// EnterRollupDefs is called when production rollupDefs is entered. +func (s *BaseDorisParserListener) EnterRollupDefs(ctx *RollupDefsContext) {} + +// ExitRollupDefs is called when production rollupDefs is exited. +func (s *BaseDorisParserListener) ExitRollupDefs(ctx *RollupDefsContext) {} + +// EnterRollupDef is called when production rollupDef is entered. +func (s *BaseDorisParserListener) EnterRollupDef(ctx *RollupDefContext) {} + +// ExitRollupDef is called when production rollupDef is exited. +func (s *BaseDorisParserListener) ExitRollupDef(ctx *RollupDefContext) {} + +// EnterAggTypeDef is called when production aggTypeDef is entered. +func (s *BaseDorisParserListener) EnterAggTypeDef(ctx *AggTypeDefContext) {} + +// ExitAggTypeDef is called when production aggTypeDef is exited. +func (s *BaseDorisParserListener) ExitAggTypeDef(ctx *AggTypeDefContext) {} + +// EnterTabletList is called when production tabletList is entered. +func (s *BaseDorisParserListener) EnterTabletList(ctx *TabletListContext) {} + +// ExitTabletList is called when production tabletList is exited. +func (s *BaseDorisParserListener) ExitTabletList(ctx *TabletListContext) {} + +// EnterInlineTable is called when production inlineTable is entered. +func (s *BaseDorisParserListener) EnterInlineTable(ctx *InlineTableContext) {} + +// ExitInlineTable is called when production inlineTable is exited. +func (s *BaseDorisParserListener) ExitInlineTable(ctx *InlineTableContext) {} + +// EnterNamedExpression is called when production namedExpression is entered. +func (s *BaseDorisParserListener) EnterNamedExpression(ctx *NamedExpressionContext) {} + +// ExitNamedExpression is called when production namedExpression is exited. +func (s *BaseDorisParserListener) ExitNamedExpression(ctx *NamedExpressionContext) {} + +// EnterNamedExpressionSeq is called when production namedExpressionSeq is entered. +func (s *BaseDorisParserListener) EnterNamedExpressionSeq(ctx *NamedExpressionSeqContext) {} + +// ExitNamedExpressionSeq is called when production namedExpressionSeq is exited. +func (s *BaseDorisParserListener) ExitNamedExpressionSeq(ctx *NamedExpressionSeqContext) {} + +// EnterExpression is called when production expression is entered. +func (s *BaseDorisParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BaseDorisParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterFuncExpression is called when production funcExpression is entered. +func (s *BaseDorisParserListener) EnterFuncExpression(ctx *FuncExpressionContext) {} + +// ExitFuncExpression is called when production funcExpression is exited. +func (s *BaseDorisParserListener) ExitFuncExpression(ctx *FuncExpressionContext) {} + +// EnterLambdaExpression is called when production lambdaExpression is entered. +func (s *BaseDorisParserListener) EnterLambdaExpression(ctx *LambdaExpressionContext) {} + +// ExitLambdaExpression is called when production lambdaExpression is exited. +func (s *BaseDorisParserListener) ExitLambdaExpression(ctx *LambdaExpressionContext) {} + +// EnterExist is called when production exist is entered. +func (s *BaseDorisParserListener) EnterExist(ctx *ExistContext) {} + +// ExitExist is called when production exist is exited. +func (s *BaseDorisParserListener) ExitExist(ctx *ExistContext) {} + +// EnterLogicalNot is called when production logicalNot is entered. +func (s *BaseDorisParserListener) EnterLogicalNot(ctx *LogicalNotContext) {} + +// ExitLogicalNot is called when production logicalNot is exited. +func (s *BaseDorisParserListener) ExitLogicalNot(ctx *LogicalNotContext) {} + +// EnterPredicated is called when production predicated is entered. +func (s *BaseDorisParserListener) EnterPredicated(ctx *PredicatedContext) {} + +// ExitPredicated is called when production predicated is exited. +func (s *BaseDorisParserListener) ExitPredicated(ctx *PredicatedContext) {} + +// EnterIsnull is called when production isnull is entered. +func (s *BaseDorisParserListener) EnterIsnull(ctx *IsnullContext) {} + +// ExitIsnull is called when production isnull is exited. +func (s *BaseDorisParserListener) ExitIsnull(ctx *IsnullContext) {} + +// EnterIs_not_null_pred is called when production is_not_null_pred is entered. +func (s *BaseDorisParserListener) EnterIs_not_null_pred(ctx *Is_not_null_predContext) {} + +// ExitIs_not_null_pred is called when production is_not_null_pred is exited. +func (s *BaseDorisParserListener) ExitIs_not_null_pred(ctx *Is_not_null_predContext) {} + +// EnterLogicalBinary is called when production logicalBinary is entered. +func (s *BaseDorisParserListener) EnterLogicalBinary(ctx *LogicalBinaryContext) {} + +// ExitLogicalBinary is called when production logicalBinary is exited. +func (s *BaseDorisParserListener) ExitLogicalBinary(ctx *LogicalBinaryContext) {} + +// EnterDoublePipes is called when production doublePipes is entered. +func (s *BaseDorisParserListener) EnterDoublePipes(ctx *DoublePipesContext) {} + +// ExitDoublePipes is called when production doublePipes is exited. +func (s *BaseDorisParserListener) ExitDoublePipes(ctx *DoublePipesContext) {} + +// EnterRowConstructor is called when production rowConstructor is entered. +func (s *BaseDorisParserListener) EnterRowConstructor(ctx *RowConstructorContext) {} + +// ExitRowConstructor is called when production rowConstructor is exited. +func (s *BaseDorisParserListener) ExitRowConstructor(ctx *RowConstructorContext) {} + +// EnterRowConstructorItem is called when production rowConstructorItem is entered. +func (s *BaseDorisParserListener) EnterRowConstructorItem(ctx *RowConstructorItemContext) {} + +// ExitRowConstructorItem is called when production rowConstructorItem is exited. +func (s *BaseDorisParserListener) ExitRowConstructorItem(ctx *RowConstructorItemContext) {} + +// EnterPredicate is called when production predicate is entered. +func (s *BaseDorisParserListener) EnterPredicate(ctx *PredicateContext) {} + +// ExitPredicate is called when production predicate is exited. +func (s *BaseDorisParserListener) ExitPredicate(ctx *PredicateContext) {} + +// EnterValueExpressionDefault is called when production valueExpressionDefault is entered. +func (s *BaseDorisParserListener) EnterValueExpressionDefault(ctx *ValueExpressionDefaultContext) {} + +// ExitValueExpressionDefault is called when production valueExpressionDefault is exited. +func (s *BaseDorisParserListener) ExitValueExpressionDefault(ctx *ValueExpressionDefaultContext) {} + +// EnterComparison is called when production comparison is entered. +func (s *BaseDorisParserListener) EnterComparison(ctx *ComparisonContext) {} + +// ExitComparison is called when production comparison is exited. +func (s *BaseDorisParserListener) ExitComparison(ctx *ComparisonContext) {} + +// EnterArithmeticBinary is called when production arithmeticBinary is entered. +func (s *BaseDorisParserListener) EnterArithmeticBinary(ctx *ArithmeticBinaryContext) {} + +// ExitArithmeticBinary is called when production arithmeticBinary is exited. +func (s *BaseDorisParserListener) ExitArithmeticBinary(ctx *ArithmeticBinaryContext) {} + +// EnterArithmeticUnary is called when production arithmeticUnary is entered. +func (s *BaseDorisParserListener) EnterArithmeticUnary(ctx *ArithmeticUnaryContext) {} + +// ExitArithmeticUnary is called when production arithmeticUnary is exited. +func (s *BaseDorisParserListener) ExitArithmeticUnary(ctx *ArithmeticUnaryContext) {} + +// EnterDereference is called when production dereference is entered. +func (s *BaseDorisParserListener) EnterDereference(ctx *DereferenceContext) {} + +// ExitDereference is called when production dereference is exited. +func (s *BaseDorisParserListener) ExitDereference(ctx *DereferenceContext) {} + +// EnterCurrentDate is called when production currentDate is entered. +func (s *BaseDorisParserListener) EnterCurrentDate(ctx *CurrentDateContext) {} + +// ExitCurrentDate is called when production currentDate is exited. +func (s *BaseDorisParserListener) ExitCurrentDate(ctx *CurrentDateContext) {} + +// EnterSubstring is called when production substring is entered. +func (s *BaseDorisParserListener) EnterSubstring(ctx *SubstringContext) {} + +// ExitSubstring is called when production substring is exited. +func (s *BaseDorisParserListener) ExitSubstring(ctx *SubstringContext) {} + +// EnterCast is called when production cast is entered. +func (s *BaseDorisParserListener) EnterCast(ctx *CastContext) {} + +// ExitCast is called when production cast is exited. +func (s *BaseDorisParserListener) ExitCast(ctx *CastContext) {} + +// EnterParenthesizedExpression is called when production parenthesizedExpression is entered. +func (s *BaseDorisParserListener) EnterParenthesizedExpression(ctx *ParenthesizedExpressionContext) {} + +// ExitParenthesizedExpression is called when production parenthesizedExpression is exited. +func (s *BaseDorisParserListener) ExitParenthesizedExpression(ctx *ParenthesizedExpressionContext) {} + +// EnterTrim is called when production trim is entered. +func (s *BaseDorisParserListener) EnterTrim(ctx *TrimContext) {} + +// ExitTrim is called when production trim is exited. +func (s *BaseDorisParserListener) ExitTrim(ctx *TrimContext) {} + +// EnterUserVariable is called when production userVariable is entered. +func (s *BaseDorisParserListener) EnterUserVariable(ctx *UserVariableContext) {} + +// ExitUserVariable is called when production userVariable is exited. +func (s *BaseDorisParserListener) ExitUserVariable(ctx *UserVariableContext) {} + +// EnterElementAt is called when production elementAt is entered. +func (s *BaseDorisParserListener) EnterElementAt(ctx *ElementAtContext) {} + +// ExitElementAt is called when production elementAt is exited. +func (s *BaseDorisParserListener) ExitElementAt(ctx *ElementAtContext) {} + +// EnterLocalTimestamp is called when production localTimestamp is entered. +func (s *BaseDorisParserListener) EnterLocalTimestamp(ctx *LocalTimestampContext) {} + +// ExitLocalTimestamp is called when production localTimestamp is exited. +func (s *BaseDorisParserListener) ExitLocalTimestamp(ctx *LocalTimestampContext) {} + +// EnterCharFunction is called when production charFunction is entered. +func (s *BaseDorisParserListener) EnterCharFunction(ctx *CharFunctionContext) {} + +// ExitCharFunction is called when production charFunction is exited. +func (s *BaseDorisParserListener) ExitCharFunction(ctx *CharFunctionContext) {} + +// EnterIntervalLiteral is called when production intervalLiteral is entered. +func (s *BaseDorisParserListener) EnterIntervalLiteral(ctx *IntervalLiteralContext) {} + +// ExitIntervalLiteral is called when production intervalLiteral is exited. +func (s *BaseDorisParserListener) ExitIntervalLiteral(ctx *IntervalLiteralContext) {} + +// EnterGroupConcat is called when production groupConcat is entered. +func (s *BaseDorisParserListener) EnterGroupConcat(ctx *GroupConcatContext) {} + +// ExitGroupConcat is called when production groupConcat is exited. +func (s *BaseDorisParserListener) ExitGroupConcat(ctx *GroupConcatContext) {} + +// EnterSimpleCase is called when production simpleCase is entered. +func (s *BaseDorisParserListener) EnterSimpleCase(ctx *SimpleCaseContext) {} + +// ExitSimpleCase is called when production simpleCase is exited. +func (s *BaseDorisParserListener) ExitSimpleCase(ctx *SimpleCaseContext) {} + +// EnterColumnReference is called when production columnReference is entered. +func (s *BaseDorisParserListener) EnterColumnReference(ctx *ColumnReferenceContext) {} + +// ExitColumnReference is called when production columnReference is exited. +func (s *BaseDorisParserListener) ExitColumnReference(ctx *ColumnReferenceContext) {} + +// EnterStar is called when production star is entered. +func (s *BaseDorisParserListener) EnterStar(ctx *StarContext) {} + +// ExitStar is called when production star is exited. +func (s *BaseDorisParserListener) ExitStar(ctx *StarContext) {} + +// EnterGetFormatFunction is called when production getFormatFunction is entered. +func (s *BaseDorisParserListener) EnterGetFormatFunction(ctx *GetFormatFunctionContext) {} + +// ExitGetFormatFunction is called when production getFormatFunction is exited. +func (s *BaseDorisParserListener) ExitGetFormatFunction(ctx *GetFormatFunctionContext) {} + +// EnterSessionUser is called when production sessionUser is entered. +func (s *BaseDorisParserListener) EnterSessionUser(ctx *SessionUserContext) {} + +// ExitSessionUser is called when production sessionUser is exited. +func (s *BaseDorisParserListener) ExitSessionUser(ctx *SessionUserContext) {} + +// EnterConvertType is called when production convertType is entered. +func (s *BaseDorisParserListener) EnterConvertType(ctx *ConvertTypeContext) {} + +// ExitConvertType is called when production convertType is exited. +func (s *BaseDorisParserListener) ExitConvertType(ctx *ConvertTypeContext) {} + +// EnterConvertCharSet is called when production convertCharSet is entered. +func (s *BaseDorisParserListener) EnterConvertCharSet(ctx *ConvertCharSetContext) {} + +// ExitConvertCharSet is called when production convertCharSet is exited. +func (s *BaseDorisParserListener) ExitConvertCharSet(ctx *ConvertCharSetContext) {} + +// EnterSubqueryExpression is called when production subqueryExpression is entered. +func (s *BaseDorisParserListener) EnterSubqueryExpression(ctx *SubqueryExpressionContext) {} + +// ExitSubqueryExpression is called when production subqueryExpression is exited. +func (s *BaseDorisParserListener) ExitSubqueryExpression(ctx *SubqueryExpressionContext) {} + +// EnterEncryptKey is called when production encryptKey is entered. +func (s *BaseDorisParserListener) EnterEncryptKey(ctx *EncryptKeyContext) {} + +// ExitEncryptKey is called when production encryptKey is exited. +func (s *BaseDorisParserListener) ExitEncryptKey(ctx *EncryptKeyContext) {} + +// EnterCurrentTime is called when production currentTime is entered. +func (s *BaseDorisParserListener) EnterCurrentTime(ctx *CurrentTimeContext) {} + +// ExitCurrentTime is called when production currentTime is exited. +func (s *BaseDorisParserListener) ExitCurrentTime(ctx *CurrentTimeContext) {} + +// EnterLocalTime is called when production localTime is entered. +func (s *BaseDorisParserListener) EnterLocalTime(ctx *LocalTimeContext) {} + +// ExitLocalTime is called when production localTime is exited. +func (s *BaseDorisParserListener) ExitLocalTime(ctx *LocalTimeContext) {} + +// EnterSystemVariable is called when production systemVariable is entered. +func (s *BaseDorisParserListener) EnterSystemVariable(ctx *SystemVariableContext) {} + +// ExitSystemVariable is called when production systemVariable is exited. +func (s *BaseDorisParserListener) ExitSystemVariable(ctx *SystemVariableContext) {} + +// EnterCollate is called when production collate is entered. +func (s *BaseDorisParserListener) EnterCollate(ctx *CollateContext) {} + +// ExitCollate is called when production collate is exited. +func (s *BaseDorisParserListener) ExitCollate(ctx *CollateContext) {} + +// EnterCurrentUser is called when production currentUser is entered. +func (s *BaseDorisParserListener) EnterCurrentUser(ctx *CurrentUserContext) {} + +// ExitCurrentUser is called when production currentUser is exited. +func (s *BaseDorisParserListener) ExitCurrentUser(ctx *CurrentUserContext) {} + +// EnterConstantDefault is called when production constantDefault is entered. +func (s *BaseDorisParserListener) EnterConstantDefault(ctx *ConstantDefaultContext) {} + +// ExitConstantDefault is called when production constantDefault is exited. +func (s *BaseDorisParserListener) ExitConstantDefault(ctx *ConstantDefaultContext) {} + +// EnterExtract is called when production extract is entered. +func (s *BaseDorisParserListener) EnterExtract(ctx *ExtractContext) {} + +// ExitExtract is called when production extract is exited. +func (s *BaseDorisParserListener) ExitExtract(ctx *ExtractContext) {} + +// EnterCurrentTimestamp is called when production currentTimestamp is entered. +func (s *BaseDorisParserListener) EnterCurrentTimestamp(ctx *CurrentTimestampContext) {} + +// ExitCurrentTimestamp is called when production currentTimestamp is exited. +func (s *BaseDorisParserListener) ExitCurrentTimestamp(ctx *CurrentTimestampContext) {} + +// EnterFunctionCall is called when production functionCall is entered. +func (s *BaseDorisParserListener) EnterFunctionCall(ctx *FunctionCallContext) {} + +// ExitFunctionCall is called when production functionCall is exited. +func (s *BaseDorisParserListener) ExitFunctionCall(ctx *FunctionCallContext) {} + +// EnterArraySlice is called when production arraySlice is entered. +func (s *BaseDorisParserListener) EnterArraySlice(ctx *ArraySliceContext) {} + +// ExitArraySlice is called when production arraySlice is exited. +func (s *BaseDorisParserListener) ExitArraySlice(ctx *ArraySliceContext) {} + +// EnterSearchedCase is called when production searchedCase is entered. +func (s *BaseDorisParserListener) EnterSearchedCase(ctx *SearchedCaseContext) {} + +// ExitSearchedCase is called when production searchedCase is exited. +func (s *BaseDorisParserListener) ExitSearchedCase(ctx *SearchedCaseContext) {} + +// EnterPosition is called when production position is entered. +func (s *BaseDorisParserListener) EnterPosition(ctx *PositionContext) {} + +// ExitPosition is called when production position is exited. +func (s *BaseDorisParserListener) ExitPosition(ctx *PositionContext) {} + +// EnterTryCast is called when production tryCast is entered. +func (s *BaseDorisParserListener) EnterTryCast(ctx *TryCastContext) {} + +// ExitTryCast is called when production tryCast is exited. +func (s *BaseDorisParserListener) ExitTryCast(ctx *TryCastContext) {} + +// EnterExcept is called when production except is entered. +func (s *BaseDorisParserListener) EnterExcept(ctx *ExceptContext) {} + +// ExitExcept is called when production except is exited. +func (s *BaseDorisParserListener) ExitExcept(ctx *ExceptContext) {} + +// EnterReplace is called when production replace is entered. +func (s *BaseDorisParserListener) EnterReplace(ctx *ReplaceContext) {} + +// ExitReplace is called when production replace is exited. +func (s *BaseDorisParserListener) ExitReplace(ctx *ReplaceContext) {} + +// EnterCastDataType is called when production castDataType is entered. +func (s *BaseDorisParserListener) EnterCastDataType(ctx *CastDataTypeContext) {} + +// ExitCastDataType is called when production castDataType is exited. +func (s *BaseDorisParserListener) ExitCastDataType(ctx *CastDataTypeContext) {} + +// EnterFunctionCallExpression is called when production functionCallExpression is entered. +func (s *BaseDorisParserListener) EnterFunctionCallExpression(ctx *FunctionCallExpressionContext) {} + +// ExitFunctionCallExpression is called when production functionCallExpression is exited. +func (s *BaseDorisParserListener) ExitFunctionCallExpression(ctx *FunctionCallExpressionContext) {} + +// EnterFunctionIdentifier is called when production functionIdentifier is entered. +func (s *BaseDorisParserListener) EnterFunctionIdentifier(ctx *FunctionIdentifierContext) {} + +// ExitFunctionIdentifier is called when production functionIdentifier is exited. +func (s *BaseDorisParserListener) ExitFunctionIdentifier(ctx *FunctionIdentifierContext) {} + +// EnterFunctionNameIdentifier is called when production functionNameIdentifier is entered. +func (s *BaseDorisParserListener) EnterFunctionNameIdentifier(ctx *FunctionNameIdentifierContext) {} + +// ExitFunctionNameIdentifier is called when production functionNameIdentifier is exited. +func (s *BaseDorisParserListener) ExitFunctionNameIdentifier(ctx *FunctionNameIdentifierContext) {} + +// EnterWindowSpec is called when production windowSpec is entered. +func (s *BaseDorisParserListener) EnterWindowSpec(ctx *WindowSpecContext) {} + +// ExitWindowSpec is called when production windowSpec is exited. +func (s *BaseDorisParserListener) ExitWindowSpec(ctx *WindowSpecContext) {} + +// EnterWindowFrame is called when production windowFrame is entered. +func (s *BaseDorisParserListener) EnterWindowFrame(ctx *WindowFrameContext) {} + +// ExitWindowFrame is called when production windowFrame is exited. +func (s *BaseDorisParserListener) ExitWindowFrame(ctx *WindowFrameContext) {} + +// EnterFrameUnits is called when production frameUnits is entered. +func (s *BaseDorisParserListener) EnterFrameUnits(ctx *FrameUnitsContext) {} + +// ExitFrameUnits is called when production frameUnits is exited. +func (s *BaseDorisParserListener) ExitFrameUnits(ctx *FrameUnitsContext) {} + +// EnterFrameBoundary is called when production frameBoundary is entered. +func (s *BaseDorisParserListener) EnterFrameBoundary(ctx *FrameBoundaryContext) {} + +// ExitFrameBoundary is called when production frameBoundary is exited. +func (s *BaseDorisParserListener) ExitFrameBoundary(ctx *FrameBoundaryContext) {} + +// EnterQualifiedName is called when production qualifiedName is entered. +func (s *BaseDorisParserListener) EnterQualifiedName(ctx *QualifiedNameContext) {} + +// ExitQualifiedName is called when production qualifiedName is exited. +func (s *BaseDorisParserListener) ExitQualifiedName(ctx *QualifiedNameContext) {} + +// EnterSpecifiedPartition is called when production specifiedPartition is entered. +func (s *BaseDorisParserListener) EnterSpecifiedPartition(ctx *SpecifiedPartitionContext) {} + +// ExitSpecifiedPartition is called when production specifiedPartition is exited. +func (s *BaseDorisParserListener) ExitSpecifiedPartition(ctx *SpecifiedPartitionContext) {} + +// EnterNullLiteral is called when production nullLiteral is entered. +func (s *BaseDorisParserListener) EnterNullLiteral(ctx *NullLiteralContext) {} + +// ExitNullLiteral is called when production nullLiteral is exited. +func (s *BaseDorisParserListener) ExitNullLiteral(ctx *NullLiteralContext) {} + +// EnterTypeConstructor is called when production typeConstructor is entered. +func (s *BaseDorisParserListener) EnterTypeConstructor(ctx *TypeConstructorContext) {} + +// ExitTypeConstructor is called when production typeConstructor is exited. +func (s *BaseDorisParserListener) ExitTypeConstructor(ctx *TypeConstructorContext) {} + +// EnterNumericLiteral is called when production numericLiteral is entered. +func (s *BaseDorisParserListener) EnterNumericLiteral(ctx *NumericLiteralContext) {} + +// ExitNumericLiteral is called when production numericLiteral is exited. +func (s *BaseDorisParserListener) ExitNumericLiteral(ctx *NumericLiteralContext) {} + +// EnterBooleanLiteral is called when production booleanLiteral is entered. +func (s *BaseDorisParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext) {} + +// ExitBooleanLiteral is called when production booleanLiteral is exited. +func (s *BaseDorisParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext) {} + +// EnterStringLiteral is called when production stringLiteral is entered. +func (s *BaseDorisParserListener) EnterStringLiteral(ctx *StringLiteralContext) {} + +// ExitStringLiteral is called when production stringLiteral is exited. +func (s *BaseDorisParserListener) ExitStringLiteral(ctx *StringLiteralContext) {} + +// EnterVarbinaryLiteral is called when production varbinaryLiteral is entered. +func (s *BaseDorisParserListener) EnterVarbinaryLiteral(ctx *VarbinaryLiteralContext) {} + +// ExitVarbinaryLiteral is called when production varbinaryLiteral is exited. +func (s *BaseDorisParserListener) ExitVarbinaryLiteral(ctx *VarbinaryLiteralContext) {} + +// EnterArrayLiteral is called when production arrayLiteral is entered. +func (s *BaseDorisParserListener) EnterArrayLiteral(ctx *ArrayLiteralContext) {} + +// ExitArrayLiteral is called when production arrayLiteral is exited. +func (s *BaseDorisParserListener) ExitArrayLiteral(ctx *ArrayLiteralContext) {} + +// EnterMapLiteral is called when production mapLiteral is entered. +func (s *BaseDorisParserListener) EnterMapLiteral(ctx *MapLiteralContext) {} + +// ExitMapLiteral is called when production mapLiteral is exited. +func (s *BaseDorisParserListener) ExitMapLiteral(ctx *MapLiteralContext) {} + +// EnterStructLiteral is called when production structLiteral is entered. +func (s *BaseDorisParserListener) EnterStructLiteral(ctx *StructLiteralContext) {} + +// ExitStructLiteral is called when production structLiteral is exited. +func (s *BaseDorisParserListener) ExitStructLiteral(ctx *StructLiteralContext) {} + +// EnterPlaceholder is called when production placeholder is entered. +func (s *BaseDorisParserListener) EnterPlaceholder(ctx *PlaceholderContext) {} + +// ExitPlaceholder is called when production placeholder is exited. +func (s *BaseDorisParserListener) ExitPlaceholder(ctx *PlaceholderContext) {} + +// EnterComparisonOperator is called when production comparisonOperator is entered. +func (s *BaseDorisParserListener) EnterComparisonOperator(ctx *ComparisonOperatorContext) {} + +// ExitComparisonOperator is called when production comparisonOperator is exited. +func (s *BaseDorisParserListener) ExitComparisonOperator(ctx *ComparisonOperatorContext) {} + +// EnterBooleanValue is called when production booleanValue is entered. +func (s *BaseDorisParserListener) EnterBooleanValue(ctx *BooleanValueContext) {} + +// ExitBooleanValue is called when production booleanValue is exited. +func (s *BaseDorisParserListener) ExitBooleanValue(ctx *BooleanValueContext) {} + +// EnterWhenClause is called when production whenClause is entered. +func (s *BaseDorisParserListener) EnterWhenClause(ctx *WhenClauseContext) {} + +// ExitWhenClause is called when production whenClause is exited. +func (s *BaseDorisParserListener) ExitWhenClause(ctx *WhenClauseContext) {} + +// EnterInterval is called when production interval is entered. +func (s *BaseDorisParserListener) EnterInterval(ctx *IntervalContext) {} + +// ExitInterval is called when production interval is exited. +func (s *BaseDorisParserListener) ExitInterval(ctx *IntervalContext) {} + +// EnterUnitIdentifier is called when production unitIdentifier is entered. +func (s *BaseDorisParserListener) EnterUnitIdentifier(ctx *UnitIdentifierContext) {} + +// ExitUnitIdentifier is called when production unitIdentifier is exited. +func (s *BaseDorisParserListener) ExitUnitIdentifier(ctx *UnitIdentifierContext) {} + +// EnterDataTypeWithNullable is called when production dataTypeWithNullable is entered. +func (s *BaseDorisParserListener) EnterDataTypeWithNullable(ctx *DataTypeWithNullableContext) {} + +// ExitDataTypeWithNullable is called when production dataTypeWithNullable is exited. +func (s *BaseDorisParserListener) ExitDataTypeWithNullable(ctx *DataTypeWithNullableContext) {} + +// EnterComplexDataType is called when production complexDataType is entered. +func (s *BaseDorisParserListener) EnterComplexDataType(ctx *ComplexDataTypeContext) {} + +// ExitComplexDataType is called when production complexDataType is exited. +func (s *BaseDorisParserListener) ExitComplexDataType(ctx *ComplexDataTypeContext) {} + +// EnterVariantPredefinedFields is called when production variantPredefinedFields is entered. +func (s *BaseDorisParserListener) EnterVariantPredefinedFields(ctx *VariantPredefinedFieldsContext) {} + +// ExitVariantPredefinedFields is called when production variantPredefinedFields is exited. +func (s *BaseDorisParserListener) ExitVariantPredefinedFields(ctx *VariantPredefinedFieldsContext) {} + +// EnterAggStateDataType is called when production aggStateDataType is entered. +func (s *BaseDorisParserListener) EnterAggStateDataType(ctx *AggStateDataTypeContext) {} + +// ExitAggStateDataType is called when production aggStateDataType is exited. +func (s *BaseDorisParserListener) ExitAggStateDataType(ctx *AggStateDataTypeContext) {} + +// EnterPrimitiveDataType is called when production primitiveDataType is entered. +func (s *BaseDorisParserListener) EnterPrimitiveDataType(ctx *PrimitiveDataTypeContext) {} + +// ExitPrimitiveDataType is called when production primitiveDataType is exited. +func (s *BaseDorisParserListener) ExitPrimitiveDataType(ctx *PrimitiveDataTypeContext) {} + +// EnterPrimitiveColType is called when production primitiveColType is entered. +func (s *BaseDorisParserListener) EnterPrimitiveColType(ctx *PrimitiveColTypeContext) {} + +// ExitPrimitiveColType is called when production primitiveColType is exited. +func (s *BaseDorisParserListener) ExitPrimitiveColType(ctx *PrimitiveColTypeContext) {} + +// EnterComplexColTypeList is called when production complexColTypeList is entered. +func (s *BaseDorisParserListener) EnterComplexColTypeList(ctx *ComplexColTypeListContext) {} + +// ExitComplexColTypeList is called when production complexColTypeList is exited. +func (s *BaseDorisParserListener) ExitComplexColTypeList(ctx *ComplexColTypeListContext) {} + +// EnterComplexColType is called when production complexColType is entered. +func (s *BaseDorisParserListener) EnterComplexColType(ctx *ComplexColTypeContext) {} + +// ExitComplexColType is called when production complexColType is exited. +func (s *BaseDorisParserListener) ExitComplexColType(ctx *ComplexColTypeContext) {} + +// EnterVariant is called when production variant is entered. +func (s *BaseDorisParserListener) EnterVariant(ctx *VariantContext) {} + +// ExitVariant is called when production variant is exited. +func (s *BaseDorisParserListener) ExitVariant(ctx *VariantContext) {} + +// EnterVariantSubColTypeList is called when production variantSubColTypeList is entered. +func (s *BaseDorisParserListener) EnterVariantSubColTypeList(ctx *VariantSubColTypeListContext) {} + +// ExitVariantSubColTypeList is called when production variantSubColTypeList is exited. +func (s *BaseDorisParserListener) ExitVariantSubColTypeList(ctx *VariantSubColTypeListContext) {} + +// EnterVariantSubColType is called when production variantSubColType is entered. +func (s *BaseDorisParserListener) EnterVariantSubColType(ctx *VariantSubColTypeContext) {} + +// ExitVariantSubColType is called when production variantSubColType is exited. +func (s *BaseDorisParserListener) ExitVariantSubColType(ctx *VariantSubColTypeContext) {} + +// EnterVariantSubColMatchType is called when production variantSubColMatchType is entered. +func (s *BaseDorisParserListener) EnterVariantSubColMatchType(ctx *VariantSubColMatchTypeContext) {} + +// ExitVariantSubColMatchType is called when production variantSubColMatchType is exited. +func (s *BaseDorisParserListener) ExitVariantSubColMatchType(ctx *VariantSubColMatchTypeContext) {} + +// EnterCommentSpec is called when production commentSpec is entered. +func (s *BaseDorisParserListener) EnterCommentSpec(ctx *CommentSpecContext) {} + +// ExitCommentSpec is called when production commentSpec is exited. +func (s *BaseDorisParserListener) ExitCommentSpec(ctx *CommentSpecContext) {} + +// EnterSample is called when production sample is entered. +func (s *BaseDorisParserListener) EnterSample(ctx *SampleContext) {} + +// ExitSample is called when production sample is exited. +func (s *BaseDorisParserListener) ExitSample(ctx *SampleContext) {} + +// EnterSampleByPercentile is called when production sampleByPercentile is entered. +func (s *BaseDorisParserListener) EnterSampleByPercentile(ctx *SampleByPercentileContext) {} + +// ExitSampleByPercentile is called when production sampleByPercentile is exited. +func (s *BaseDorisParserListener) ExitSampleByPercentile(ctx *SampleByPercentileContext) {} + +// EnterSampleByRows is called when production sampleByRows is entered. +func (s *BaseDorisParserListener) EnterSampleByRows(ctx *SampleByRowsContext) {} + +// ExitSampleByRows is called when production sampleByRows is exited. +func (s *BaseDorisParserListener) ExitSampleByRows(ctx *SampleByRowsContext) {} + +// EnterTableSnapshot is called when production tableSnapshot is entered. +func (s *BaseDorisParserListener) EnterTableSnapshot(ctx *TableSnapshotContext) {} + +// ExitTableSnapshot is called when production tableSnapshot is exited. +func (s *BaseDorisParserListener) ExitTableSnapshot(ctx *TableSnapshotContext) {} + +// EnterErrorCapturingIdentifier is called when production errorCapturingIdentifier is entered. +func (s *BaseDorisParserListener) EnterErrorCapturingIdentifier(ctx *ErrorCapturingIdentifierContext) { +} + +// ExitErrorCapturingIdentifier is called when production errorCapturingIdentifier is exited. +func (s *BaseDorisParserListener) ExitErrorCapturingIdentifier(ctx *ErrorCapturingIdentifierContext) { +} + +// EnterErrorIdent is called when production errorIdent is entered. +func (s *BaseDorisParserListener) EnterErrorIdent(ctx *ErrorIdentContext) {} + +// ExitErrorIdent is called when production errorIdent is exited. +func (s *BaseDorisParserListener) ExitErrorIdent(ctx *ErrorIdentContext) {} + +// EnterRealIdent is called when production realIdent is entered. +func (s *BaseDorisParserListener) EnterRealIdent(ctx *RealIdentContext) {} + +// ExitRealIdent is called when production realIdent is exited. +func (s *BaseDorisParserListener) ExitRealIdent(ctx *RealIdentContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BaseDorisParserListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BaseDorisParserListener) ExitIdentifier(ctx *IdentifierContext) {} + +// EnterUnquotedIdentifier is called when production unquotedIdentifier is entered. +func (s *BaseDorisParserListener) EnterUnquotedIdentifier(ctx *UnquotedIdentifierContext) {} + +// ExitUnquotedIdentifier is called when production unquotedIdentifier is exited. +func (s *BaseDorisParserListener) ExitUnquotedIdentifier(ctx *UnquotedIdentifierContext) {} + +// EnterQuotedIdentifierAlternative is called when production quotedIdentifierAlternative is entered. +func (s *BaseDorisParserListener) EnterQuotedIdentifierAlternative(ctx *QuotedIdentifierAlternativeContext) { +} + +// ExitQuotedIdentifierAlternative is called when production quotedIdentifierAlternative is exited. +func (s *BaseDorisParserListener) ExitQuotedIdentifierAlternative(ctx *QuotedIdentifierAlternativeContext) { +} + +// EnterQuotedIdentifier is called when production quotedIdentifier is entered. +func (s *BaseDorisParserListener) EnterQuotedIdentifier(ctx *QuotedIdentifierContext) {} + +// ExitQuotedIdentifier is called when production quotedIdentifier is exited. +func (s *BaseDorisParserListener) ExitQuotedIdentifier(ctx *QuotedIdentifierContext) {} + +// EnterIntegerLiteral is called when production integerLiteral is entered. +func (s *BaseDorisParserListener) EnterIntegerLiteral(ctx *IntegerLiteralContext) {} + +// ExitIntegerLiteral is called when production integerLiteral is exited. +func (s *BaseDorisParserListener) ExitIntegerLiteral(ctx *IntegerLiteralContext) {} + +// EnterDecimalLiteral is called when production decimalLiteral is entered. +func (s *BaseDorisParserListener) EnterDecimalLiteral(ctx *DecimalLiteralContext) {} + +// ExitDecimalLiteral is called when production decimalLiteral is exited. +func (s *BaseDorisParserListener) ExitDecimalLiteral(ctx *DecimalLiteralContext) {} + +// EnterNonReserved is called when production nonReserved is entered. +func (s *BaseDorisParserListener) EnterNonReserved(ctx *NonReservedContext) {} + +// ExitNonReserved is called when production nonReserved is exited. +func (s *BaseDorisParserListener) ExitNonReserved(ctx *NonReservedContext) {} diff --git a/doris/dorisparser_base_visitor.go b/doris/dorisparser_base_visitor.go new file mode 100644 index 0000000..af8c2ed --- /dev/null +++ b/doris/dorisparser_base_visitor.go @@ -0,0 +1,2672 @@ +// Code generated from DorisParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package doris // DorisParser +import "github.com/antlr4-go/antlr/v4" + +type BaseDorisParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseDorisParserVisitor) VisitMultiStatements(ctx *MultiStatementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSingleStatement(ctx *SingleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExpressionWithEof(ctx *ExpressionWithEofContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStatementBaseAlias(ctx *StatementBaseAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCallProcedure(ctx *CallProcedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateProcedure(ctx *CreateProcedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropProcedure(ctx *DropProcedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowProcedureStatus(ctx *ShowProcedureStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateProcedure(ctx *ShowCreateProcedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowConfig(ctx *ShowConfigContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStatementDefault(ctx *StatementDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedDmlStatementAlias(ctx *SupportedDmlStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedCreateStatementAlias(ctx *SupportedCreateStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedAlterStatementAlias(ctx *SupportedAlterStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMaterializedViewStatementAlias(ctx *MaterializedViewStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedJobStatementAlias(ctx *SupportedJobStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitConstraintStatementAlias(ctx *ConstraintStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedCleanStatementAlias(ctx *SupportedCleanStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedDescribeStatementAlias(ctx *SupportedDescribeStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedDropStatementAlias(ctx *SupportedDropStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedSetStatementAlias(ctx *SupportedSetStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedUnsetStatementAlias(ctx *SupportedUnsetStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedRefreshStatementAlias(ctx *SupportedRefreshStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedShowStatementAlias(ctx *SupportedShowStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedLoadStatementAlias(ctx *SupportedLoadStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedCancelStatementAlias(ctx *SupportedCancelStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedRecoverStatementAlias(ctx *SupportedRecoverStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedAdminStatementAlias(ctx *SupportedAdminStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedUseStatementAlias(ctx *SupportedUseStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedOtherStatementAlias(ctx *SupportedOtherStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedKillStatementAlias(ctx *SupportedKillStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedStatsStatementAlias(ctx *SupportedStatsStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedTransactionStatementAlias(ctx *SupportedTransactionStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedGrantRevokeStatementAlias(ctx *SupportedGrantRevokeStatementAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateMTMV(ctx *CreateMTMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshMTMV(ctx *RefreshMTMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterMTMV(ctx *AlterMTMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropMV(ctx *DropMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPauseMTMV(ctx *PauseMTMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitResumeMTMV(ctx *ResumeMTMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelMTMVTask(ctx *CancelMTMVTaskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateMTMV(ctx *ShowCreateMTMVContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateScheduledJob(ctx *CreateScheduledJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPauseJob(ctx *PauseJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterJob(ctx *AlterJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropJob(ctx *DropJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitResumeJob(ctx *ResumeJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelJobTask(ctx *CancelJobTaskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddConstraint(ctx *AddConstraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropConstraint(ctx *DropConstraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowConstraint(ctx *ShowConstraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitOptSpecBranch(ctx *OptSpecBranchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitInsertTable(ctx *InsertTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUpdate(ctx *UpdateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDelete(ctx *DeleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMergeInto(ctx *MergeIntoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLoad(ctx *LoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExport(ctx *ExportContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplay(ctx *ReplayContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCopyInto(ctx *CopyIntoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTruncateTable(ctx *TruncateTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMergeMatchedClause(ctx *MergeMatchedClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMergeNotMatchedClause(ctx *MergeNotMatchedClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateTable(ctx *CreateTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateView(ctx *CreateViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateFile(ctx *CreateFileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateTableLike(ctx *CreateTableLikeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateRole(ctx *CreateRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateWorkloadGroup(ctx *CreateWorkloadGroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateCatalog(ctx *CreateCatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateRowPolicy(ctx *CreateRowPolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateStoragePolicy(ctx *CreateStoragePolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBuildIndex(ctx *BuildIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateIndex(ctx *CreateIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateWorkloadPolicy(ctx *CreateWorkloadPolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateSqlBlockRule(ctx *CreateSqlBlockRuleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateEncryptkey(ctx *CreateEncryptkeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateUserDefineFunction(ctx *CreateUserDefineFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateAliasFunction(ctx *CreateAliasFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateUser(ctx *CreateUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateDatabase(ctx *CreateDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateRepository(ctx *CreateRepositoryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateResource(ctx *CreateResourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateDictionary(ctx *CreateDictionaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateStage(ctx *CreateStageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateStorageVault(ctx *CreateStorageVaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateIndexAnalyzer(ctx *CreateIndexAnalyzerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateIndexTokenizer(ctx *CreateIndexTokenizerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateIndexTokenFilter(ctx *CreateIndexTokenFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateIndexCharFilter(ctx *CreateIndexCharFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDictionaryColumnDefs(ctx *DictionaryColumnDefsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDictionaryColumnDef(ctx *DictionaryColumnDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterSystem(ctx *AlterSystemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterView(ctx *AlterViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterCatalogRename(ctx *AlterCatalogRenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterRole(ctx *AlterRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterStorageVault(ctx *AlterStorageVaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterWorkloadGroup(ctx *AlterWorkloadGroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterComputeGroup(ctx *AlterComputeGroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterCatalogProperties(ctx *AlterCatalogPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterWorkloadPolicy(ctx *AlterWorkloadPolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterSqlBlockRule(ctx *AlterSqlBlockRuleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterCatalogComment(ctx *AlterCatalogCommentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterDatabaseRename(ctx *AlterDatabaseRenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterStoragePolicy(ctx *AlterStoragePolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterTable(ctx *AlterTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterTableExecute(ctx *AlterTableExecuteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterTableAddRollup(ctx *AlterTableAddRollupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterTableDropRollup(ctx *AlterTableDropRollupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterTableProperties(ctx *AlterTablePropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterDatabaseSetQuota(ctx *AlterDatabaseSetQuotaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterDatabaseProperties(ctx *AlterDatabasePropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterSystemRenameComputeGroup(ctx *AlterSystemRenameComputeGroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterResource(ctx *AlterResourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterRepository(ctx *AlterRepositoryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterRoutineLoad(ctx *AlterRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterColocateGroup(ctx *AlterColocateGroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterUser(ctx *AlterUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropCatalogRecycleBin(ctx *DropCatalogRecycleBinContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropEncryptkey(ctx *DropEncryptkeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropRole(ctx *DropRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropSqlBlockRule(ctx *DropSqlBlockRuleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropUser(ctx *DropUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropStoragePolicy(ctx *DropStoragePolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropWorkloadGroup(ctx *DropWorkloadGroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropCatalog(ctx *DropCatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropFile(ctx *DropFileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropWorkloadPolicy(ctx *DropWorkloadPolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropRepository(ctx *DropRepositoryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropTable(ctx *DropTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropDatabase(ctx *DropDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropFunction(ctx *DropFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropIndex(ctx *DropIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropResource(ctx *DropResourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropRowPolicy(ctx *DropRowPolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropDictionary(ctx *DropDictionaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropStage(ctx *DropStageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropView(ctx *DropViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropIndexAnalyzer(ctx *DropIndexAnalyzerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropIndexTokenizer(ctx *DropIndexTokenizerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropIndexTokenFilter(ctx *DropIndexTokenFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropIndexCharFilter(ctx *DropIndexCharFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowVariables(ctx *ShowVariablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowAuthors(ctx *ShowAuthorsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowAlterTable(ctx *ShowAlterTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateDatabase(ctx *ShowCreateDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowBackup(ctx *ShowBackupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowBroker(ctx *ShowBrokerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowBuildIndex(ctx *ShowBuildIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDynamicPartition(ctx *ShowDynamicPartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowEvents(ctx *ShowEventsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowExport(ctx *ShowExportContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowLastInsert(ctx *ShowLastInsertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCharset(ctx *ShowCharsetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDelete(ctx *ShowDeleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateFunction(ctx *ShowCreateFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowFunctions(ctx *ShowFunctionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowGlobalFunctions(ctx *ShowGlobalFunctionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowGrants(ctx *ShowGrantsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowGrantsForUser(ctx *ShowGrantsForUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateUser(ctx *ShowCreateUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowSnapshot(ctx *ShowSnapshotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowLoadProfile(ctx *ShowLoadProfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateRepository(ctx *ShowCreateRepositoryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowView(ctx *ShowViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowPlugins(ctx *ShowPluginsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowStorageVault(ctx *ShowStorageVaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowRepositories(ctx *ShowRepositoriesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowEncryptKeys(ctx *ShowEncryptKeysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateTable(ctx *ShowCreateTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowProcessList(ctx *ShowProcessListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowPartitions(ctx *ShowPartitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowRestore(ctx *ShowRestoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowRoles(ctx *ShowRolesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowPartitionId(ctx *ShowPartitionIdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowPrivileges(ctx *ShowPrivilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowProc(ctx *ShowProcContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowSmallFiles(ctx *ShowSmallFilesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowStorageEngines(ctx *ShowStorageEnginesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateCatalog(ctx *ShowCreateCatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCatalog(ctx *ShowCatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCatalogs(ctx *ShowCatalogsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowUserProperties(ctx *ShowUserPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowAllProperties(ctx *ShowAllPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCollation(ctx *ShowCollationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowRowPolicy(ctx *ShowRowPolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowStoragePolicy(ctx *ShowStoragePolicyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowSqlBlockRule(ctx *ShowSqlBlockRuleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateView(ctx *ShowCreateViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateStorageVault(ctx *ShowCreateStorageVaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDataTypes(ctx *ShowDataTypesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowData(ctx *ShowDataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateMaterializedView(ctx *ShowCreateMaterializedViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowWarningErrors(ctx *ShowWarningErrorsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowWarningErrorCount(ctx *ShowWarningErrorCountContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowBackends(ctx *ShowBackendsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowStages(ctx *ShowStagesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowReplicaDistribution(ctx *ShowReplicaDistributionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowResources(ctx *ShowResourcesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowLoad(ctx *ShowLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowLoadWarings(ctx *ShowLoadWaringsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTriggers(ctx *ShowTriggersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDiagnoseTablet(ctx *ShowDiagnoseTabletContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowOpenTables(ctx *ShowOpenTablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowFrontends(ctx *ShowFrontendsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDatabaseId(ctx *ShowDatabaseIdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowColumns(ctx *ShowColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTableId(ctx *ShowTableIdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTrash(ctx *ShowTrashContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTypeCast(ctx *ShowTypeCastContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowClusters(ctx *ShowClustersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowStatus(ctx *ShowStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowWhitelist(ctx *ShowWhitelistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTabletsBelong(ctx *ShowTabletsBelongContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDataSkew(ctx *ShowDataSkewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTableCreation(ctx *ShowTableCreationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTabletStorageFormat(ctx *ShowTabletStorageFormatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowQueryProfile(ctx *ShowQueryProfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowConvertLsc(ctx *ShowConvertLscContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTables(ctx *ShowTablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowViews(ctx *ShowViewsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTableStatus(ctx *ShowTableStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDatabases(ctx *ShowDatabasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTabletsFromTable(ctx *ShowTabletsFromTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCatalogRecycleBin(ctx *ShowCatalogRecycleBinContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTabletId(ctx *ShowTabletIdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowDictionaries(ctx *ShowDictionariesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTransaction(ctx *ShowTransactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowReplicaStatus(ctx *ShowReplicaStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowWorkloadGroups(ctx *ShowWorkloadGroupsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCopy(ctx *ShowCopyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowQueryStats(ctx *ShowQueryStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowIndex(ctx *ShowIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowWarmUpJob(ctx *ShowWarmUpJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSync(ctx *SyncContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateLoad(ctx *ShowCreateLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateRoutineLoadAlias(ctx *CreateRoutineLoadAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMysqlLoad(ctx *MysqlLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowCreateRoutineLoad(ctx *ShowCreateRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPauseRoutineLoad(ctx *PauseRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPauseAllRoutineLoad(ctx *PauseAllRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitResumeRoutineLoad(ctx *ResumeRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitResumeAllRoutineLoad(ctx *ResumeAllRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStopRoutineLoad(ctx *StopRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowRoutineLoad(ctx *ShowRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowRoutineLoadTask(ctx *ShowRoutineLoadTaskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowIndexAnalyzer(ctx *ShowIndexAnalyzerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowIndexTokenizer(ctx *ShowIndexTokenizerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowIndexTokenFilter(ctx *ShowIndexTokenFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowIndexCharFilter(ctx *ShowIndexCharFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitKillConnection(ctx *KillConnectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitKillQuery(ctx *KillQueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitHelp(ctx *HelpContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUnlockTables(ctx *UnlockTablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitInstallPlugin(ctx *InstallPluginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUninstallPlugin(ctx *UninstallPluginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLockTables(ctx *LockTablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRestore(ctx *RestoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWarmUpCluster(ctx *WarmUpClusterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWarmUpSelect(ctx *WarmUpSelectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBackup(ctx *BackupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUnsupportedStartTransaction(ctx *UnsupportedStartTransactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWarmUpItem(ctx *WarmUpItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWarmUpSingleTableRef(ctx *WarmUpSingleTableRefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLockTable(ctx *LockTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateRoutineLoad(ctx *CreateRoutineLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSeparator(ctx *SeparatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportColumns(ctx *ImportColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportPrecedingFilter(ctx *ImportPrecedingFilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportWhere(ctx *ImportWhereContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportDeleteOn(ctx *ImportDeleteOnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportSequence(ctx *ImportSequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportPartitions(ctx *ImportPartitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportSequenceStatement(ctx *ImportSequenceStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportDeleteOnStatement(ctx *ImportDeleteOnStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportWhereStatement(ctx *ImportWhereStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportPrecedingFilterStatement(ctx *ImportPrecedingFilterStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportColumnsStatement(ctx *ImportColumnsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitImportColumnDesc(ctx *ImportColumnDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshCatalog(ctx *RefreshCatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshDatabase(ctx *RefreshDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshTable(ctx *RefreshTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshDictionary(ctx *RefreshDictionaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshLdap(ctx *RefreshLdapContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCleanAllProfile(ctx *CleanAllProfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCleanLabel(ctx *CleanLabelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCleanQueryStats(ctx *CleanQueryStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCleanAllQueryStats(ctx *CleanAllQueryStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelLoad(ctx *CancelLoadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelExport(ctx *CancelExportContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelWarmUpJob(ctx *CancelWarmUpJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelDecommisionBackend(ctx *CancelDecommisionBackendContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelBackup(ctx *CancelBackupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelRestore(ctx *CancelRestoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelBuildIndex(ctx *CancelBuildIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCancelAlterTable(ctx *CancelAlterTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminShowReplicaDistribution(ctx *AdminShowReplicaDistributionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminRebalanceDisk(ctx *AdminRebalanceDiskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCancelRebalanceDisk(ctx *AdminCancelRebalanceDiskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminDiagnoseTablet(ctx *AdminDiagnoseTabletContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminShowReplicaStatus(ctx *AdminShowReplicaStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCompactTable(ctx *AdminCompactTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCheckTablets(ctx *AdminCheckTabletsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminShowTabletStorageFormat(ctx *AdminShowTabletStorageFormatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetFrontendConfig(ctx *AdminSetFrontendConfigContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCleanTrash(ctx *AdminCleanTrashContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetReplicaVersion(ctx *AdminSetReplicaVersionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetTableStatus(ctx *AdminSetTableStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetReplicaStatus(ctx *AdminSetReplicaStatusContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminRepairTable(ctx *AdminRepairTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCancelRepairTable(ctx *AdminCancelRepairTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCopyTablet(ctx *AdminCopyTabletContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetEncryptionRootKey(ctx *AdminSetEncryptionRootKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminCreateClusterSnapshot(ctx *AdminCreateClusterSnapshotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetAutoClusterSnapshot(ctx *AdminSetAutoClusterSnapshotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminDropClusterSnapshot(ctx *AdminDropClusterSnapshotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminSetClusterSnapshotFeatureSwitch(ctx *AdminSetClusterSnapshotFeatureSwitchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAdminRotateTdeRootKey(ctx *AdminRotateTdeRootKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRecoverDatabase(ctx *RecoverDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRecoverTable(ctx *RecoverTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRecoverPartition(ctx *RecoverPartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBaseTableRef(ctx *BaseTableRefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWildWhere(ctx *WildWhereContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTransactionBegin(ctx *TransactionBeginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTranscationCommit(ctx *TranscationCommitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTransactionRollback(ctx *TransactionRollbackContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGrantTablePrivilege(ctx *GrantTablePrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGrantResourcePrivilege(ctx *GrantResourcePrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGrantRole(ctx *GrantRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRevokeRole(ctx *RevokeRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRevokeResourcePrivilege(ctx *RevokeResourcePrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRevokeTablePrivilege(ctx *RevokeTablePrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPrivilege(ctx *PrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPrivilegeList(ctx *PrivilegeListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddBackendClause(ctx *AddBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropBackendClause(ctx *DropBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddObserverClause(ctx *AddObserverClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropObserverClause(ctx *DropObserverClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddFollowerClause(ctx *AddFollowerClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropFollowerClause(ctx *DropFollowerClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddBrokerClause(ctx *AddBrokerClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropBrokerClause(ctx *DropBrokerClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropAllBrokerClause(ctx *DropAllBrokerClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyBackendClause(ctx *ModifyBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyFrontendOrBackendHostNameClause(ctx *ModifyFrontendOrBackendHostNameClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropRollupClause(ctx *DropRollupClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddRollupClause(ctx *AddRollupClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddColumnClause(ctx *AddColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddColumnsClause(ctx *AddColumnsClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropColumnClause(ctx *DropColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyColumnClause(ctx *ModifyColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReorderColumnsClause(ctx *ReorderColumnsClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddPartitionClause(ctx *AddPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropPartitionClause(ctx *DropPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyPartitionClause(ctx *ModifyPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplacePartitionClause(ctx *ReplacePartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplaceTableClause(ctx *ReplaceTableClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRenameClause(ctx *RenameClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRenameRollupClause(ctx *RenameRollupClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRenamePartitionClause(ctx *RenamePartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRenameColumnClause(ctx *RenameColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddIndexClause(ctx *AddIndexClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropIndexClause(ctx *DropIndexClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitEnableFeatureClause(ctx *EnableFeatureClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyDistributionClause(ctx *ModifyDistributionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyTableCommentClause(ctx *ModifyTableCommentClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitModifyEngineClause(ctx *ModifyEngineClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterMultiPartitionClause(ctx *AlterMultiPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateOrReplaceTagClauses(ctx *CreateOrReplaceTagClausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateOrReplaceBranchClauses(ctx *CreateOrReplaceBranchClausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropBranchClauses(ctx *DropBranchClausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropTagClauses(ctx *DropTagClausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAddPartitionFieldClause(ctx *AddPartitionFieldClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropPartitionFieldClause(ctx *DropPartitionFieldClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplacePartitionFieldClause(ctx *ReplacePartitionFieldClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTagOptions(ctx *TagOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBranchOptions(ctx *BranchOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRetainTime(ctx *RetainTimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRetentionSnapshot(ctx *RetentionSnapshotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTimeValueWithUnit(ctx *TimeValueWithUnitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropBranchClause(ctx *DropBranchClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropTagClause(ctx *DropTagClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionTransformWithArgs(ctx *PartitionTransformWithArgsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionTransformWithColumn(ctx *PartitionTransformWithColumnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionTransformIdentity(ctx *PartitionTransformIdentityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColumnPosition(ctx *ColumnPositionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitToRollup(ctx *ToRollupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFromRollup(ctx *FromRollupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowAnalyze(ctx *ShowAnalyzeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowQueuedAnalyzeJobs(ctx *ShowQueuedAnalyzeJobsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowColumnHistogramStats(ctx *ShowColumnHistogramStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowColumnStats(ctx *ShowColumnStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowAnalyzeTask(ctx *ShowAnalyzeTaskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAnalyzeDatabase(ctx *AnalyzeDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAnalyzeTable(ctx *AnalyzeTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterTableStats(ctx *AlterTableStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAlterColumnStats(ctx *AlterColumnStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowIndexStats(ctx *ShowIndexStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropStats(ctx *DropStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropCachedStats(ctx *DropCachedStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropExpiredStats(ctx *DropExpiredStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitKillAnalyzeJob(ctx *KillAnalyzeJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDropAnalyzeJob(ctx *DropAnalyzeJobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitShowTableStats(ctx *ShowTableStatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAnalyzeProperties(ctx *AnalyzePropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWorkloadPolicyActions(ctx *WorkloadPolicyActionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWorkloadPolicyAction(ctx *WorkloadPolicyActionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWorkloadPolicyConditions(ctx *WorkloadPolicyConditionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWorkloadPolicyCondition(ctx *WorkloadPolicyConditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStorageBackend(ctx *StorageBackendContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPasswordOption(ctx *PasswordOptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFunctionArguments(ctx *FunctionArgumentsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDataTypeList(ctx *DataTypeListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetOptions(ctx *SetOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetDefaultStorageVault(ctx *SetDefaultStorageVaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetUserProperties(ctx *SetUserPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetTransaction(ctx *SetTransactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetVariableWithType(ctx *SetVariableWithTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetNames(ctx *SetNamesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetCharset(ctx *SetCharsetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetCollate(ctx *SetCollateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetPassword(ctx *SetPasswordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetLdapAdminPassword(ctx *SetLdapAdminPasswordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetVariableWithoutType(ctx *SetVariableWithoutTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetSystemVariable(ctx *SetSystemVariableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetUserVariable(ctx *SetUserVariableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTransactionAccessMode(ctx *TransactionAccessModeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIsolationLevel(ctx *IsolationLevelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSupportedUnsetStatement(ctx *SupportedUnsetStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSwitchCatalog(ctx *SwitchCatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUseDatabase(ctx *UseDatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUseCloudCluster(ctx *UseCloudClusterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStageAndPattern(ctx *StageAndPatternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDescribeTableValuedFunction(ctx *DescribeTableValuedFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDescribeTableAll(ctx *DescribeTableAllContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDescribeTable(ctx *DescribeTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDescribeDictionary(ctx *DescribeDictionaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitConstraint(ctx *ConstraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionSpec(ctx *PartitionSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionTable(ctx *PartitionTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentityOrFunctionList(ctx *IdentityOrFunctionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentityOrFunction(ctx *IdentityOrFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDataDesc(ctx *DataDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStatementScope(ctx *StatementScopeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBuildMode(ctx *BuildModeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshTrigger(ctx *RefreshTriggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshSchedule(ctx *RefreshScheduleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRefreshMethod(ctx *RefreshMethodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMvPartition(ctx *MvPartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentifierOrText(ctx *IdentifierOrTextContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentifierOrTextOrAsterisk(ctx *IdentifierOrTextOrAsteriskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMultipartIdentifierOrAsterisk(ctx *MultipartIdentifierOrAsteriskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentifierOrAsterisk(ctx *IdentifierOrAsteriskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUserIdentify(ctx *UserIdentifyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGrantUserIdentify(ctx *GrantUserIdentifyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExplain(ctx *ExplainContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExplainCommand(ctx *ExplainCommandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPlanType(ctx *PlanTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplayCommand(ctx *ReplayCommandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplayType(ctx *ReplayTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMergeType(ctx *MergeTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPreFilterClause(ctx *PreFilterClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDeleteOnClause(ctx *DeleteOnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSequenceColClause(ctx *SequenceColClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColFromPath(ctx *ColFromPathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColMappingList(ctx *ColMappingListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMappingExpr(ctx *MappingExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWithRemoteStorageSystem(ctx *WithRemoteStorageSystemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitResourceDesc(ctx *ResourceDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMysqlDataDesc(ctx *MysqlDataDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSkipLines(ctx *SkipLinesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitOutFileClause(ctx *OutFileClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQuery(ctx *QueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQueryTermDefault(ctx *QueryTermDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetOperation(ctx *SetOperationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSetQuantifier(ctx *SetQuantifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSubquery(ctx *SubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitValuesTable(ctx *ValuesTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRegularQuerySpecification(ctx *RegularQuerySpecificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCte(ctx *CteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAliasQuery(ctx *AliasQueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColumnAliases(ctx *ColumnAliasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSelectClause(ctx *SelectClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSelectColumnClause(ctx *SelectColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWhereClause(ctx *WhereClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFromClause(ctx *FromClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIntoClause(ctx *IntoClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBulkCollectClause(ctx *BulkCollectClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTableRow(ctx *TableRowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRelations(ctx *RelationsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRelation(ctx *RelationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitJoinRelation(ctx *JoinRelationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDistributeType(ctx *DistributeTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSkewHint(ctx *SkewHintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitConstantList(ctx *ConstantListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBracketRelationHint(ctx *BracketRelationHintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCommentRelationHint(ctx *CommentRelationHintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExpressionWithOrder(ctx *ExpressionWithOrderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAggClause(ctx *AggClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGroupingElement(ctx *GroupingElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGroupingSet(ctx *GroupingSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitHavingClause(ctx *HavingClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQualifyClause(ctx *QualifyClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSelectHint(ctx *SelectHintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitHintStatement(ctx *HintStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitHintName(ctx *HintNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitHintAssignment(ctx *HintAssignmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUpdateAssignment(ctx *UpdateAssignmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUpdateAssignmentSeq(ctx *UpdateAssignmentSeqContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLateralView(ctx *LateralViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQueryOrganization(ctx *QueryOrganizationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSortClause(ctx *SortClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSortItem(ctx *SortItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLimitClause(ctx *LimitClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionClause(ctx *PartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitJoinType(ctx *JoinTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitJoinCriteria(ctx *JoinCriteriaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentifierList(ctx *IdentifierListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentifierSeq(ctx *IdentifierSeqContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitOptScanParams(ctx *OptScanParamsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTableName(ctx *TableNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAliasedQuery(ctx *AliasedQueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTableValuedFunction(ctx *TableValuedFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRelationList(ctx *RelationListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMaterializedViewName(ctx *MaterializedViewNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPropertyClause(ctx *PropertyClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPropertyItemList(ctx *PropertyItemListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPropertyItem(ctx *PropertyItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPropertyKey(ctx *PropertyKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPropertyValue(ctx *PropertyValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTableAlias(ctx *TableAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMultipartIdentifier(ctx *MultipartIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSimpleColumnDefs(ctx *SimpleColumnDefsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSimpleColumnDef(ctx *SimpleColumnDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColumnDefs(ctx *ColumnDefsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColumnDef(ctx *ColumnDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIndexDefs(ctx *IndexDefsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIndexDef(ctx *IndexDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionsDef(ctx *PartitionsDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionDef(ctx *PartitionDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLessThanPartitionDef(ctx *LessThanPartitionDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFixedPartitionDef(ctx *FixedPartitionDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStepPartitionDef(ctx *StepPartitionDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitInPartitionDef(ctx *InPartitionDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionValueList(ctx *PartitionValueListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPartitionValueDef(ctx *PartitionValueDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRollupDefs(ctx *RollupDefsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRollupDef(ctx *RollupDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAggTypeDef(ctx *AggTypeDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTabletList(ctx *TabletListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitInlineTable(ctx *InlineTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitNamedExpression(ctx *NamedExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitNamedExpressionSeq(ctx *NamedExpressionSeqContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExpression(ctx *ExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFuncExpression(ctx *FuncExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLambdaExpression(ctx *LambdaExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExist(ctx *ExistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLogicalNot(ctx *LogicalNotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPredicated(ctx *PredicatedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIsnull(ctx *IsnullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIs_not_null_pred(ctx *Is_not_null_predContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLogicalBinary(ctx *LogicalBinaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDoublePipes(ctx *DoublePipesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRowConstructor(ctx *RowConstructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRowConstructorItem(ctx *RowConstructorItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPredicate(ctx *PredicateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitValueExpressionDefault(ctx *ValueExpressionDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitComparison(ctx *ComparisonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitArithmeticBinary(ctx *ArithmeticBinaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitArithmeticUnary(ctx *ArithmeticUnaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDereference(ctx *DereferenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCurrentDate(ctx *CurrentDateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSubstring(ctx *SubstringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCast(ctx *CastContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTrim(ctx *TrimContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUserVariable(ctx *UserVariableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitElementAt(ctx *ElementAtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLocalTimestamp(ctx *LocalTimestampContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCharFunction(ctx *CharFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIntervalLiteral(ctx *IntervalLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGroupConcat(ctx *GroupConcatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSimpleCase(ctx *SimpleCaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitColumnReference(ctx *ColumnReferenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStar(ctx *StarContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitGetFormatFunction(ctx *GetFormatFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSessionUser(ctx *SessionUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitConvertType(ctx *ConvertTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitConvertCharSet(ctx *ConvertCharSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSubqueryExpression(ctx *SubqueryExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitEncryptKey(ctx *EncryptKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCurrentTime(ctx *CurrentTimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitLocalTime(ctx *LocalTimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSystemVariable(ctx *SystemVariableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCollate(ctx *CollateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCurrentUser(ctx *CurrentUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitConstantDefault(ctx *ConstantDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExtract(ctx *ExtractContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCurrentTimestamp(ctx *CurrentTimestampContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFunctionCall(ctx *FunctionCallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitArraySlice(ctx *ArraySliceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSearchedCase(ctx *SearchedCaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPosition(ctx *PositionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTryCast(ctx *TryCastContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitExcept(ctx *ExceptContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitReplace(ctx *ReplaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCastDataType(ctx *CastDataTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFunctionIdentifier(ctx *FunctionIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFunctionNameIdentifier(ctx *FunctionNameIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWindowSpec(ctx *WindowSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWindowFrame(ctx *WindowFrameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFrameUnits(ctx *FrameUnitsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitFrameBoundary(ctx *FrameBoundaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQualifiedName(ctx *QualifiedNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSpecifiedPartition(ctx *SpecifiedPartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitNullLiteral(ctx *NullLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTypeConstructor(ctx *TypeConstructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitNumericLiteral(ctx *NumericLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitVarbinaryLiteral(ctx *VarbinaryLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitMapLiteral(ctx *MapLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitStructLiteral(ctx *StructLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPlaceholder(ctx *PlaceholderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitBooleanValue(ctx *BooleanValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitWhenClause(ctx *WhenClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitInterval(ctx *IntervalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUnitIdentifier(ctx *UnitIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDataTypeWithNullable(ctx *DataTypeWithNullableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitComplexDataType(ctx *ComplexDataTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitVariantPredefinedFields(ctx *VariantPredefinedFieldsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitAggStateDataType(ctx *AggStateDataTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPrimitiveDataType(ctx *PrimitiveDataTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitPrimitiveColType(ctx *PrimitiveColTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitComplexColTypeList(ctx *ComplexColTypeListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitComplexColType(ctx *ComplexColTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitVariant(ctx *VariantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitVariantSubColTypeList(ctx *VariantSubColTypeListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitVariantSubColType(ctx *VariantSubColTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitVariantSubColMatchType(ctx *VariantSubColMatchTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitCommentSpec(ctx *CommentSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSample(ctx *SampleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSampleByPercentile(ctx *SampleByPercentileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitSampleByRows(ctx *SampleByRowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitTableSnapshot(ctx *TableSnapshotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitErrorCapturingIdentifier(ctx *ErrorCapturingIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitErrorIdent(ctx *ErrorIdentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitRealIdent(ctx *RealIdentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitUnquotedIdentifier(ctx *UnquotedIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQuotedIdentifierAlternative(ctx *QuotedIdentifierAlternativeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitQuotedIdentifier(ctx *QuotedIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseDorisParserVisitor) VisitNonReserved(ctx *NonReservedContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/doris/dorisparser_listener.go b/doris/dorisparser_listener.go new file mode 100644 index 0000000..ccd6c46 --- /dev/null +++ b/doris/dorisparser_listener.go @@ -0,0 +1,4005 @@ +// Code generated from DorisParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package doris // DorisParser +import "github.com/antlr4-go/antlr/v4" + +// DorisParserListener is a complete listener for a parse tree produced by DorisParser. +type DorisParserListener interface { + antlr.ParseTreeListener + + // EnterMultiStatements is called when entering the multiStatements production. + EnterMultiStatements(c *MultiStatementsContext) + + // EnterSingleStatement is called when entering the singleStatement production. + EnterSingleStatement(c *SingleStatementContext) + + // EnterExpressionWithEof is called when entering the expressionWithEof production. + EnterExpressionWithEof(c *ExpressionWithEofContext) + + // EnterStatementBaseAlias is called when entering the statementBaseAlias production. + EnterStatementBaseAlias(c *StatementBaseAliasContext) + + // EnterCallProcedure is called when entering the callProcedure production. + EnterCallProcedure(c *CallProcedureContext) + + // EnterCreateProcedure is called when entering the createProcedure production. + EnterCreateProcedure(c *CreateProcedureContext) + + // EnterDropProcedure is called when entering the dropProcedure production. + EnterDropProcedure(c *DropProcedureContext) + + // EnterShowProcedureStatus is called when entering the showProcedureStatus production. + EnterShowProcedureStatus(c *ShowProcedureStatusContext) + + // EnterShowCreateProcedure is called when entering the showCreateProcedure production. + EnterShowCreateProcedure(c *ShowCreateProcedureContext) + + // EnterShowConfig is called when entering the showConfig production. + EnterShowConfig(c *ShowConfigContext) + + // EnterStatementDefault is called when entering the statementDefault production. + EnterStatementDefault(c *StatementDefaultContext) + + // EnterSupportedDmlStatementAlias is called when entering the supportedDmlStatementAlias production. + EnterSupportedDmlStatementAlias(c *SupportedDmlStatementAliasContext) + + // EnterSupportedCreateStatementAlias is called when entering the supportedCreateStatementAlias production. + EnterSupportedCreateStatementAlias(c *SupportedCreateStatementAliasContext) + + // EnterSupportedAlterStatementAlias is called when entering the supportedAlterStatementAlias production. + EnterSupportedAlterStatementAlias(c *SupportedAlterStatementAliasContext) + + // EnterMaterializedViewStatementAlias is called when entering the materializedViewStatementAlias production. + EnterMaterializedViewStatementAlias(c *MaterializedViewStatementAliasContext) + + // EnterSupportedJobStatementAlias is called when entering the supportedJobStatementAlias production. + EnterSupportedJobStatementAlias(c *SupportedJobStatementAliasContext) + + // EnterConstraintStatementAlias is called when entering the constraintStatementAlias production. + EnterConstraintStatementAlias(c *ConstraintStatementAliasContext) + + // EnterSupportedCleanStatementAlias is called when entering the supportedCleanStatementAlias production. + EnterSupportedCleanStatementAlias(c *SupportedCleanStatementAliasContext) + + // EnterSupportedDescribeStatementAlias is called when entering the supportedDescribeStatementAlias production. + EnterSupportedDescribeStatementAlias(c *SupportedDescribeStatementAliasContext) + + // EnterSupportedDropStatementAlias is called when entering the supportedDropStatementAlias production. + EnterSupportedDropStatementAlias(c *SupportedDropStatementAliasContext) + + // EnterSupportedSetStatementAlias is called when entering the supportedSetStatementAlias production. + EnterSupportedSetStatementAlias(c *SupportedSetStatementAliasContext) + + // EnterSupportedUnsetStatementAlias is called when entering the supportedUnsetStatementAlias production. + EnterSupportedUnsetStatementAlias(c *SupportedUnsetStatementAliasContext) + + // EnterSupportedRefreshStatementAlias is called when entering the supportedRefreshStatementAlias production. + EnterSupportedRefreshStatementAlias(c *SupportedRefreshStatementAliasContext) + + // EnterSupportedShowStatementAlias is called when entering the supportedShowStatementAlias production. + EnterSupportedShowStatementAlias(c *SupportedShowStatementAliasContext) + + // EnterSupportedLoadStatementAlias is called when entering the supportedLoadStatementAlias production. + EnterSupportedLoadStatementAlias(c *SupportedLoadStatementAliasContext) + + // EnterSupportedCancelStatementAlias is called when entering the supportedCancelStatementAlias production. + EnterSupportedCancelStatementAlias(c *SupportedCancelStatementAliasContext) + + // EnterSupportedRecoverStatementAlias is called when entering the supportedRecoverStatementAlias production. + EnterSupportedRecoverStatementAlias(c *SupportedRecoverStatementAliasContext) + + // EnterSupportedAdminStatementAlias is called when entering the supportedAdminStatementAlias production. + EnterSupportedAdminStatementAlias(c *SupportedAdminStatementAliasContext) + + // EnterSupportedUseStatementAlias is called when entering the supportedUseStatementAlias production. + EnterSupportedUseStatementAlias(c *SupportedUseStatementAliasContext) + + // EnterSupportedOtherStatementAlias is called when entering the supportedOtherStatementAlias production. + EnterSupportedOtherStatementAlias(c *SupportedOtherStatementAliasContext) + + // EnterSupportedKillStatementAlias is called when entering the supportedKillStatementAlias production. + EnterSupportedKillStatementAlias(c *SupportedKillStatementAliasContext) + + // EnterSupportedStatsStatementAlias is called when entering the supportedStatsStatementAlias production. + EnterSupportedStatsStatementAlias(c *SupportedStatsStatementAliasContext) + + // EnterSupportedTransactionStatementAlias is called when entering the supportedTransactionStatementAlias production. + EnterSupportedTransactionStatementAlias(c *SupportedTransactionStatementAliasContext) + + // EnterSupportedGrantRevokeStatementAlias is called when entering the supportedGrantRevokeStatementAlias production. + EnterSupportedGrantRevokeStatementAlias(c *SupportedGrantRevokeStatementAliasContext) + + // EnterCreateMTMV is called when entering the createMTMV production. + EnterCreateMTMV(c *CreateMTMVContext) + + // EnterRefreshMTMV is called when entering the refreshMTMV production. + EnterRefreshMTMV(c *RefreshMTMVContext) + + // EnterAlterMTMV is called when entering the alterMTMV production. + EnterAlterMTMV(c *AlterMTMVContext) + + // EnterDropMV is called when entering the dropMV production. + EnterDropMV(c *DropMVContext) + + // EnterPauseMTMV is called when entering the pauseMTMV production. + EnterPauseMTMV(c *PauseMTMVContext) + + // EnterResumeMTMV is called when entering the resumeMTMV production. + EnterResumeMTMV(c *ResumeMTMVContext) + + // EnterCancelMTMVTask is called when entering the cancelMTMVTask production. + EnterCancelMTMVTask(c *CancelMTMVTaskContext) + + // EnterShowCreateMTMV is called when entering the showCreateMTMV production. + EnterShowCreateMTMV(c *ShowCreateMTMVContext) + + // EnterCreateScheduledJob is called when entering the createScheduledJob production. + EnterCreateScheduledJob(c *CreateScheduledJobContext) + + // EnterPauseJob is called when entering the pauseJob production. + EnterPauseJob(c *PauseJobContext) + + // EnterAlterJob is called when entering the alterJob production. + EnterAlterJob(c *AlterJobContext) + + // EnterDropJob is called when entering the dropJob production. + EnterDropJob(c *DropJobContext) + + // EnterResumeJob is called when entering the resumeJob production. + EnterResumeJob(c *ResumeJobContext) + + // EnterCancelJobTask is called when entering the cancelJobTask production. + EnterCancelJobTask(c *CancelJobTaskContext) + + // EnterAddConstraint is called when entering the addConstraint production. + EnterAddConstraint(c *AddConstraintContext) + + // EnterDropConstraint is called when entering the dropConstraint production. + EnterDropConstraint(c *DropConstraintContext) + + // EnterShowConstraint is called when entering the showConstraint production. + EnterShowConstraint(c *ShowConstraintContext) + + // EnterOptSpecBranch is called when entering the optSpecBranch production. + EnterOptSpecBranch(c *OptSpecBranchContext) + + // EnterInsertTable is called when entering the insertTable production. + EnterInsertTable(c *InsertTableContext) + + // EnterUpdate is called when entering the update production. + EnterUpdate(c *UpdateContext) + + // EnterDelete is called when entering the delete production. + EnterDelete(c *DeleteContext) + + // EnterMergeInto is called when entering the mergeInto production. + EnterMergeInto(c *MergeIntoContext) + + // EnterLoad is called when entering the load production. + EnterLoad(c *LoadContext) + + // EnterExport is called when entering the export production. + EnterExport(c *ExportContext) + + // EnterReplay is called when entering the replay production. + EnterReplay(c *ReplayContext) + + // EnterCopyInto is called when entering the copyInto production. + EnterCopyInto(c *CopyIntoContext) + + // EnterTruncateTable is called when entering the truncateTable production. + EnterTruncateTable(c *TruncateTableContext) + + // EnterMergeMatchedClause is called when entering the mergeMatchedClause production. + EnterMergeMatchedClause(c *MergeMatchedClauseContext) + + // EnterMergeNotMatchedClause is called when entering the mergeNotMatchedClause production. + EnterMergeNotMatchedClause(c *MergeNotMatchedClauseContext) + + // EnterCreateTable is called when entering the createTable production. + EnterCreateTable(c *CreateTableContext) + + // EnterCreateView is called when entering the createView production. + EnterCreateView(c *CreateViewContext) + + // EnterCreateFile is called when entering the createFile production. + EnterCreateFile(c *CreateFileContext) + + // EnterCreateTableLike is called when entering the createTableLike production. + EnterCreateTableLike(c *CreateTableLikeContext) + + // EnterCreateRole is called when entering the createRole production. + EnterCreateRole(c *CreateRoleContext) + + // EnterCreateWorkloadGroup is called when entering the createWorkloadGroup production. + EnterCreateWorkloadGroup(c *CreateWorkloadGroupContext) + + // EnterCreateCatalog is called when entering the createCatalog production. + EnterCreateCatalog(c *CreateCatalogContext) + + // EnterCreateRowPolicy is called when entering the createRowPolicy production. + EnterCreateRowPolicy(c *CreateRowPolicyContext) + + // EnterCreateStoragePolicy is called when entering the createStoragePolicy production. + EnterCreateStoragePolicy(c *CreateStoragePolicyContext) + + // EnterBuildIndex is called when entering the buildIndex production. + EnterBuildIndex(c *BuildIndexContext) + + // EnterCreateIndex is called when entering the createIndex production. + EnterCreateIndex(c *CreateIndexContext) + + // EnterCreateWorkloadPolicy is called when entering the createWorkloadPolicy production. + EnterCreateWorkloadPolicy(c *CreateWorkloadPolicyContext) + + // EnterCreateSqlBlockRule is called when entering the createSqlBlockRule production. + EnterCreateSqlBlockRule(c *CreateSqlBlockRuleContext) + + // EnterCreateEncryptkey is called when entering the createEncryptkey production. + EnterCreateEncryptkey(c *CreateEncryptkeyContext) + + // EnterCreateUserDefineFunction is called when entering the createUserDefineFunction production. + EnterCreateUserDefineFunction(c *CreateUserDefineFunctionContext) + + // EnterCreateAliasFunction is called when entering the createAliasFunction production. + EnterCreateAliasFunction(c *CreateAliasFunctionContext) + + // EnterCreateUser is called when entering the createUser production. + EnterCreateUser(c *CreateUserContext) + + // EnterCreateDatabase is called when entering the createDatabase production. + EnterCreateDatabase(c *CreateDatabaseContext) + + // EnterCreateRepository is called when entering the createRepository production. + EnterCreateRepository(c *CreateRepositoryContext) + + // EnterCreateResource is called when entering the createResource production. + EnterCreateResource(c *CreateResourceContext) + + // EnterCreateDictionary is called when entering the createDictionary production. + EnterCreateDictionary(c *CreateDictionaryContext) + + // EnterCreateStage is called when entering the createStage production. + EnterCreateStage(c *CreateStageContext) + + // EnterCreateStorageVault is called when entering the createStorageVault production. + EnterCreateStorageVault(c *CreateStorageVaultContext) + + // EnterCreateIndexAnalyzer is called when entering the createIndexAnalyzer production. + EnterCreateIndexAnalyzer(c *CreateIndexAnalyzerContext) + + // EnterCreateIndexTokenizer is called when entering the createIndexTokenizer production. + EnterCreateIndexTokenizer(c *CreateIndexTokenizerContext) + + // EnterCreateIndexTokenFilter is called when entering the createIndexTokenFilter production. + EnterCreateIndexTokenFilter(c *CreateIndexTokenFilterContext) + + // EnterCreateIndexCharFilter is called when entering the createIndexCharFilter production. + EnterCreateIndexCharFilter(c *CreateIndexCharFilterContext) + + // EnterDictionaryColumnDefs is called when entering the dictionaryColumnDefs production. + EnterDictionaryColumnDefs(c *DictionaryColumnDefsContext) + + // EnterDictionaryColumnDef is called when entering the dictionaryColumnDef production. + EnterDictionaryColumnDef(c *DictionaryColumnDefContext) + + // EnterAlterSystem is called when entering the alterSystem production. + EnterAlterSystem(c *AlterSystemContext) + + // EnterAlterView is called when entering the alterView production. + EnterAlterView(c *AlterViewContext) + + // EnterAlterCatalogRename is called when entering the alterCatalogRename production. + EnterAlterCatalogRename(c *AlterCatalogRenameContext) + + // EnterAlterRole is called when entering the alterRole production. + EnterAlterRole(c *AlterRoleContext) + + // EnterAlterStorageVault is called when entering the alterStorageVault production. + EnterAlterStorageVault(c *AlterStorageVaultContext) + + // EnterAlterWorkloadGroup is called when entering the alterWorkloadGroup production. + EnterAlterWorkloadGroup(c *AlterWorkloadGroupContext) + + // EnterAlterComputeGroup is called when entering the alterComputeGroup production. + EnterAlterComputeGroup(c *AlterComputeGroupContext) + + // EnterAlterCatalogProperties is called when entering the alterCatalogProperties production. + EnterAlterCatalogProperties(c *AlterCatalogPropertiesContext) + + // EnterAlterWorkloadPolicy is called when entering the alterWorkloadPolicy production. + EnterAlterWorkloadPolicy(c *AlterWorkloadPolicyContext) + + // EnterAlterSqlBlockRule is called when entering the alterSqlBlockRule production. + EnterAlterSqlBlockRule(c *AlterSqlBlockRuleContext) + + // EnterAlterCatalogComment is called when entering the alterCatalogComment production. + EnterAlterCatalogComment(c *AlterCatalogCommentContext) + + // EnterAlterDatabaseRename is called when entering the alterDatabaseRename production. + EnterAlterDatabaseRename(c *AlterDatabaseRenameContext) + + // EnterAlterStoragePolicy is called when entering the alterStoragePolicy production. + EnterAlterStoragePolicy(c *AlterStoragePolicyContext) + + // EnterAlterTable is called when entering the alterTable production. + EnterAlterTable(c *AlterTableContext) + + // EnterAlterTableExecute is called when entering the alterTableExecute production. + EnterAlterTableExecute(c *AlterTableExecuteContext) + + // EnterAlterTableAddRollup is called when entering the alterTableAddRollup production. + EnterAlterTableAddRollup(c *AlterTableAddRollupContext) + + // EnterAlterTableDropRollup is called when entering the alterTableDropRollup production. + EnterAlterTableDropRollup(c *AlterTableDropRollupContext) + + // EnterAlterTableProperties is called when entering the alterTableProperties production. + EnterAlterTableProperties(c *AlterTablePropertiesContext) + + // EnterAlterDatabaseSetQuota is called when entering the alterDatabaseSetQuota production. + EnterAlterDatabaseSetQuota(c *AlterDatabaseSetQuotaContext) + + // EnterAlterDatabaseProperties is called when entering the alterDatabaseProperties production. + EnterAlterDatabaseProperties(c *AlterDatabasePropertiesContext) + + // EnterAlterSystemRenameComputeGroup is called when entering the alterSystemRenameComputeGroup production. + EnterAlterSystemRenameComputeGroup(c *AlterSystemRenameComputeGroupContext) + + // EnterAlterResource is called when entering the alterResource production. + EnterAlterResource(c *AlterResourceContext) + + // EnterAlterRepository is called when entering the alterRepository production. + EnterAlterRepository(c *AlterRepositoryContext) + + // EnterAlterRoutineLoad is called when entering the alterRoutineLoad production. + EnterAlterRoutineLoad(c *AlterRoutineLoadContext) + + // EnterAlterColocateGroup is called when entering the alterColocateGroup production. + EnterAlterColocateGroup(c *AlterColocateGroupContext) + + // EnterAlterUser is called when entering the alterUser production. + EnterAlterUser(c *AlterUserContext) + + // EnterDropCatalogRecycleBin is called when entering the dropCatalogRecycleBin production. + EnterDropCatalogRecycleBin(c *DropCatalogRecycleBinContext) + + // EnterDropEncryptkey is called when entering the dropEncryptkey production. + EnterDropEncryptkey(c *DropEncryptkeyContext) + + // EnterDropRole is called when entering the dropRole production. + EnterDropRole(c *DropRoleContext) + + // EnterDropSqlBlockRule is called when entering the dropSqlBlockRule production. + EnterDropSqlBlockRule(c *DropSqlBlockRuleContext) + + // EnterDropUser is called when entering the dropUser production. + EnterDropUser(c *DropUserContext) + + // EnterDropStoragePolicy is called when entering the dropStoragePolicy production. + EnterDropStoragePolicy(c *DropStoragePolicyContext) + + // EnterDropWorkloadGroup is called when entering the dropWorkloadGroup production. + EnterDropWorkloadGroup(c *DropWorkloadGroupContext) + + // EnterDropCatalog is called when entering the dropCatalog production. + EnterDropCatalog(c *DropCatalogContext) + + // EnterDropFile is called when entering the dropFile production. + EnterDropFile(c *DropFileContext) + + // EnterDropWorkloadPolicy is called when entering the dropWorkloadPolicy production. + EnterDropWorkloadPolicy(c *DropWorkloadPolicyContext) + + // EnterDropRepository is called when entering the dropRepository production. + EnterDropRepository(c *DropRepositoryContext) + + // EnterDropTable is called when entering the dropTable production. + EnterDropTable(c *DropTableContext) + + // EnterDropDatabase is called when entering the dropDatabase production. + EnterDropDatabase(c *DropDatabaseContext) + + // EnterDropFunction is called when entering the dropFunction production. + EnterDropFunction(c *DropFunctionContext) + + // EnterDropIndex is called when entering the dropIndex production. + EnterDropIndex(c *DropIndexContext) + + // EnterDropResource is called when entering the dropResource production. + EnterDropResource(c *DropResourceContext) + + // EnterDropRowPolicy is called when entering the dropRowPolicy production. + EnterDropRowPolicy(c *DropRowPolicyContext) + + // EnterDropDictionary is called when entering the dropDictionary production. + EnterDropDictionary(c *DropDictionaryContext) + + // EnterDropStage is called when entering the dropStage production. + EnterDropStage(c *DropStageContext) + + // EnterDropView is called when entering the dropView production. + EnterDropView(c *DropViewContext) + + // EnterDropIndexAnalyzer is called when entering the dropIndexAnalyzer production. + EnterDropIndexAnalyzer(c *DropIndexAnalyzerContext) + + // EnterDropIndexTokenizer is called when entering the dropIndexTokenizer production. + EnterDropIndexTokenizer(c *DropIndexTokenizerContext) + + // EnterDropIndexTokenFilter is called when entering the dropIndexTokenFilter production. + EnterDropIndexTokenFilter(c *DropIndexTokenFilterContext) + + // EnterDropIndexCharFilter is called when entering the dropIndexCharFilter production. + EnterDropIndexCharFilter(c *DropIndexCharFilterContext) + + // EnterShowVariables is called when entering the showVariables production. + EnterShowVariables(c *ShowVariablesContext) + + // EnterShowAuthors is called when entering the showAuthors production. + EnterShowAuthors(c *ShowAuthorsContext) + + // EnterShowAlterTable is called when entering the showAlterTable production. + EnterShowAlterTable(c *ShowAlterTableContext) + + // EnterShowCreateDatabase is called when entering the showCreateDatabase production. + EnterShowCreateDatabase(c *ShowCreateDatabaseContext) + + // EnterShowBackup is called when entering the showBackup production. + EnterShowBackup(c *ShowBackupContext) + + // EnterShowBroker is called when entering the showBroker production. + EnterShowBroker(c *ShowBrokerContext) + + // EnterShowBuildIndex is called when entering the showBuildIndex production. + EnterShowBuildIndex(c *ShowBuildIndexContext) + + // EnterShowDynamicPartition is called when entering the showDynamicPartition production. + EnterShowDynamicPartition(c *ShowDynamicPartitionContext) + + // EnterShowEvents is called when entering the showEvents production. + EnterShowEvents(c *ShowEventsContext) + + // EnterShowExport is called when entering the showExport production. + EnterShowExport(c *ShowExportContext) + + // EnterShowLastInsert is called when entering the showLastInsert production. + EnterShowLastInsert(c *ShowLastInsertContext) + + // EnterShowCharset is called when entering the showCharset production. + EnterShowCharset(c *ShowCharsetContext) + + // EnterShowDelete is called when entering the showDelete production. + EnterShowDelete(c *ShowDeleteContext) + + // EnterShowCreateFunction is called when entering the showCreateFunction production. + EnterShowCreateFunction(c *ShowCreateFunctionContext) + + // EnterShowFunctions is called when entering the showFunctions production. + EnterShowFunctions(c *ShowFunctionsContext) + + // EnterShowGlobalFunctions is called when entering the showGlobalFunctions production. + EnterShowGlobalFunctions(c *ShowGlobalFunctionsContext) + + // EnterShowGrants is called when entering the showGrants production. + EnterShowGrants(c *ShowGrantsContext) + + // EnterShowGrantsForUser is called when entering the showGrantsForUser production. + EnterShowGrantsForUser(c *ShowGrantsForUserContext) + + // EnterShowCreateUser is called when entering the showCreateUser production. + EnterShowCreateUser(c *ShowCreateUserContext) + + // EnterShowSnapshot is called when entering the showSnapshot production. + EnterShowSnapshot(c *ShowSnapshotContext) + + // EnterShowLoadProfile is called when entering the showLoadProfile production. + EnterShowLoadProfile(c *ShowLoadProfileContext) + + // EnterShowCreateRepository is called when entering the showCreateRepository production. + EnterShowCreateRepository(c *ShowCreateRepositoryContext) + + // EnterShowView is called when entering the showView production. + EnterShowView(c *ShowViewContext) + + // EnterShowPlugins is called when entering the showPlugins production. + EnterShowPlugins(c *ShowPluginsContext) + + // EnterShowStorageVault is called when entering the showStorageVault production. + EnterShowStorageVault(c *ShowStorageVaultContext) + + // EnterShowRepositories is called when entering the showRepositories production. + EnterShowRepositories(c *ShowRepositoriesContext) + + // EnterShowEncryptKeys is called when entering the showEncryptKeys production. + EnterShowEncryptKeys(c *ShowEncryptKeysContext) + + // EnterShowCreateTable is called when entering the showCreateTable production. + EnterShowCreateTable(c *ShowCreateTableContext) + + // EnterShowProcessList is called when entering the showProcessList production. + EnterShowProcessList(c *ShowProcessListContext) + + // EnterShowPartitions is called when entering the showPartitions production. + EnterShowPartitions(c *ShowPartitionsContext) + + // EnterShowRestore is called when entering the showRestore production. + EnterShowRestore(c *ShowRestoreContext) + + // EnterShowRoles is called when entering the showRoles production. + EnterShowRoles(c *ShowRolesContext) + + // EnterShowPartitionId is called when entering the showPartitionId production. + EnterShowPartitionId(c *ShowPartitionIdContext) + + // EnterShowPrivileges is called when entering the showPrivileges production. + EnterShowPrivileges(c *ShowPrivilegesContext) + + // EnterShowProc is called when entering the showProc production. + EnterShowProc(c *ShowProcContext) + + // EnterShowSmallFiles is called when entering the showSmallFiles production. + EnterShowSmallFiles(c *ShowSmallFilesContext) + + // EnterShowStorageEngines is called when entering the showStorageEngines production. + EnterShowStorageEngines(c *ShowStorageEnginesContext) + + // EnterShowCreateCatalog is called when entering the showCreateCatalog production. + EnterShowCreateCatalog(c *ShowCreateCatalogContext) + + // EnterShowCatalog is called when entering the showCatalog production. + EnterShowCatalog(c *ShowCatalogContext) + + // EnterShowCatalogs is called when entering the showCatalogs production. + EnterShowCatalogs(c *ShowCatalogsContext) + + // EnterShowUserProperties is called when entering the showUserProperties production. + EnterShowUserProperties(c *ShowUserPropertiesContext) + + // EnterShowAllProperties is called when entering the showAllProperties production. + EnterShowAllProperties(c *ShowAllPropertiesContext) + + // EnterShowCollation is called when entering the showCollation production. + EnterShowCollation(c *ShowCollationContext) + + // EnterShowRowPolicy is called when entering the showRowPolicy production. + EnterShowRowPolicy(c *ShowRowPolicyContext) + + // EnterShowStoragePolicy is called when entering the showStoragePolicy production. + EnterShowStoragePolicy(c *ShowStoragePolicyContext) + + // EnterShowSqlBlockRule is called when entering the showSqlBlockRule production. + EnterShowSqlBlockRule(c *ShowSqlBlockRuleContext) + + // EnterShowCreateView is called when entering the showCreateView production. + EnterShowCreateView(c *ShowCreateViewContext) + + // EnterShowCreateStorageVault is called when entering the showCreateStorageVault production. + EnterShowCreateStorageVault(c *ShowCreateStorageVaultContext) + + // EnterShowDataTypes is called when entering the showDataTypes production. + EnterShowDataTypes(c *ShowDataTypesContext) + + // EnterShowData is called when entering the showData production. + EnterShowData(c *ShowDataContext) + + // EnterShowCreateMaterializedView is called when entering the showCreateMaterializedView production. + EnterShowCreateMaterializedView(c *ShowCreateMaterializedViewContext) + + // EnterShowWarningErrors is called when entering the showWarningErrors production. + EnterShowWarningErrors(c *ShowWarningErrorsContext) + + // EnterShowWarningErrorCount is called when entering the showWarningErrorCount production. + EnterShowWarningErrorCount(c *ShowWarningErrorCountContext) + + // EnterShowBackends is called when entering the showBackends production. + EnterShowBackends(c *ShowBackendsContext) + + // EnterShowStages is called when entering the showStages production. + EnterShowStages(c *ShowStagesContext) + + // EnterShowReplicaDistribution is called when entering the showReplicaDistribution production. + EnterShowReplicaDistribution(c *ShowReplicaDistributionContext) + + // EnterShowResources is called when entering the showResources production. + EnterShowResources(c *ShowResourcesContext) + + // EnterShowLoad is called when entering the showLoad production. + EnterShowLoad(c *ShowLoadContext) + + // EnterShowLoadWarings is called when entering the showLoadWarings production. + EnterShowLoadWarings(c *ShowLoadWaringsContext) + + // EnterShowTriggers is called when entering the showTriggers production. + EnterShowTriggers(c *ShowTriggersContext) + + // EnterShowDiagnoseTablet is called when entering the showDiagnoseTablet production. + EnterShowDiagnoseTablet(c *ShowDiagnoseTabletContext) + + // EnterShowOpenTables is called when entering the showOpenTables production. + EnterShowOpenTables(c *ShowOpenTablesContext) + + // EnterShowFrontends is called when entering the showFrontends production. + EnterShowFrontends(c *ShowFrontendsContext) + + // EnterShowDatabaseId is called when entering the showDatabaseId production. + EnterShowDatabaseId(c *ShowDatabaseIdContext) + + // EnterShowColumns is called when entering the showColumns production. + EnterShowColumns(c *ShowColumnsContext) + + // EnterShowTableId is called when entering the showTableId production. + EnterShowTableId(c *ShowTableIdContext) + + // EnterShowTrash is called when entering the showTrash production. + EnterShowTrash(c *ShowTrashContext) + + // EnterShowTypeCast is called when entering the showTypeCast production. + EnterShowTypeCast(c *ShowTypeCastContext) + + // EnterShowClusters is called when entering the showClusters production. + EnterShowClusters(c *ShowClustersContext) + + // EnterShowStatus is called when entering the showStatus production. + EnterShowStatus(c *ShowStatusContext) + + // EnterShowWhitelist is called when entering the showWhitelist production. + EnterShowWhitelist(c *ShowWhitelistContext) + + // EnterShowTabletsBelong is called when entering the showTabletsBelong production. + EnterShowTabletsBelong(c *ShowTabletsBelongContext) + + // EnterShowDataSkew is called when entering the showDataSkew production. + EnterShowDataSkew(c *ShowDataSkewContext) + + // EnterShowTableCreation is called when entering the showTableCreation production. + EnterShowTableCreation(c *ShowTableCreationContext) + + // EnterShowTabletStorageFormat is called when entering the showTabletStorageFormat production. + EnterShowTabletStorageFormat(c *ShowTabletStorageFormatContext) + + // EnterShowQueryProfile is called when entering the showQueryProfile production. + EnterShowQueryProfile(c *ShowQueryProfileContext) + + // EnterShowConvertLsc is called when entering the showConvertLsc production. + EnterShowConvertLsc(c *ShowConvertLscContext) + + // EnterShowTables is called when entering the showTables production. + EnterShowTables(c *ShowTablesContext) + + // EnterShowViews is called when entering the showViews production. + EnterShowViews(c *ShowViewsContext) + + // EnterShowTableStatus is called when entering the showTableStatus production. + EnterShowTableStatus(c *ShowTableStatusContext) + + // EnterShowDatabases is called when entering the showDatabases production. + EnterShowDatabases(c *ShowDatabasesContext) + + // EnterShowTabletsFromTable is called when entering the showTabletsFromTable production. + EnterShowTabletsFromTable(c *ShowTabletsFromTableContext) + + // EnterShowCatalogRecycleBin is called when entering the showCatalogRecycleBin production. + EnterShowCatalogRecycleBin(c *ShowCatalogRecycleBinContext) + + // EnterShowTabletId is called when entering the showTabletId production. + EnterShowTabletId(c *ShowTabletIdContext) + + // EnterShowDictionaries is called when entering the showDictionaries production. + EnterShowDictionaries(c *ShowDictionariesContext) + + // EnterShowTransaction is called when entering the showTransaction production. + EnterShowTransaction(c *ShowTransactionContext) + + // EnterShowReplicaStatus is called when entering the showReplicaStatus production. + EnterShowReplicaStatus(c *ShowReplicaStatusContext) + + // EnterShowWorkloadGroups is called when entering the showWorkloadGroups production. + EnterShowWorkloadGroups(c *ShowWorkloadGroupsContext) + + // EnterShowCopy is called when entering the showCopy production. + EnterShowCopy(c *ShowCopyContext) + + // EnterShowQueryStats is called when entering the showQueryStats production. + EnterShowQueryStats(c *ShowQueryStatsContext) + + // EnterShowIndex is called when entering the showIndex production. + EnterShowIndex(c *ShowIndexContext) + + // EnterShowWarmUpJob is called when entering the showWarmUpJob production. + EnterShowWarmUpJob(c *ShowWarmUpJobContext) + + // EnterSync is called when entering the sync production. + EnterSync(c *SyncContext) + + // EnterShowCreateLoad is called when entering the showCreateLoad production. + EnterShowCreateLoad(c *ShowCreateLoadContext) + + // EnterCreateRoutineLoadAlias is called when entering the createRoutineLoadAlias production. + EnterCreateRoutineLoadAlias(c *CreateRoutineLoadAliasContext) + + // EnterMysqlLoad is called when entering the mysqlLoad production. + EnterMysqlLoad(c *MysqlLoadContext) + + // EnterShowCreateRoutineLoad is called when entering the showCreateRoutineLoad production. + EnterShowCreateRoutineLoad(c *ShowCreateRoutineLoadContext) + + // EnterPauseRoutineLoad is called when entering the pauseRoutineLoad production. + EnterPauseRoutineLoad(c *PauseRoutineLoadContext) + + // EnterPauseAllRoutineLoad is called when entering the pauseAllRoutineLoad production. + EnterPauseAllRoutineLoad(c *PauseAllRoutineLoadContext) + + // EnterResumeRoutineLoad is called when entering the resumeRoutineLoad production. + EnterResumeRoutineLoad(c *ResumeRoutineLoadContext) + + // EnterResumeAllRoutineLoad is called when entering the resumeAllRoutineLoad production. + EnterResumeAllRoutineLoad(c *ResumeAllRoutineLoadContext) + + // EnterStopRoutineLoad is called when entering the stopRoutineLoad production. + EnterStopRoutineLoad(c *StopRoutineLoadContext) + + // EnterShowRoutineLoad is called when entering the showRoutineLoad production. + EnterShowRoutineLoad(c *ShowRoutineLoadContext) + + // EnterShowRoutineLoadTask is called when entering the showRoutineLoadTask production. + EnterShowRoutineLoadTask(c *ShowRoutineLoadTaskContext) + + // EnterShowIndexAnalyzer is called when entering the showIndexAnalyzer production. + EnterShowIndexAnalyzer(c *ShowIndexAnalyzerContext) + + // EnterShowIndexTokenizer is called when entering the showIndexTokenizer production. + EnterShowIndexTokenizer(c *ShowIndexTokenizerContext) + + // EnterShowIndexTokenFilter is called when entering the showIndexTokenFilter production. + EnterShowIndexTokenFilter(c *ShowIndexTokenFilterContext) + + // EnterShowIndexCharFilter is called when entering the showIndexCharFilter production. + EnterShowIndexCharFilter(c *ShowIndexCharFilterContext) + + // EnterKillConnection is called when entering the killConnection production. + EnterKillConnection(c *KillConnectionContext) + + // EnterKillQuery is called when entering the killQuery production. + EnterKillQuery(c *KillQueryContext) + + // EnterHelp is called when entering the help production. + EnterHelp(c *HelpContext) + + // EnterUnlockTables is called when entering the unlockTables production. + EnterUnlockTables(c *UnlockTablesContext) + + // EnterInstallPlugin is called when entering the installPlugin production. + EnterInstallPlugin(c *InstallPluginContext) + + // EnterUninstallPlugin is called when entering the uninstallPlugin production. + EnterUninstallPlugin(c *UninstallPluginContext) + + // EnterLockTables is called when entering the lockTables production. + EnterLockTables(c *LockTablesContext) + + // EnterRestore is called when entering the restore production. + EnterRestore(c *RestoreContext) + + // EnterWarmUpCluster is called when entering the warmUpCluster production. + EnterWarmUpCluster(c *WarmUpClusterContext) + + // EnterWarmUpSelect is called when entering the warmUpSelect production. + EnterWarmUpSelect(c *WarmUpSelectContext) + + // EnterBackup is called when entering the backup production. + EnterBackup(c *BackupContext) + + // EnterUnsupportedStartTransaction is called when entering the unsupportedStartTransaction production. + EnterUnsupportedStartTransaction(c *UnsupportedStartTransactionContext) + + // EnterWarmUpItem is called when entering the warmUpItem production. + EnterWarmUpItem(c *WarmUpItemContext) + + // EnterWarmUpSingleTableRef is called when entering the warmUpSingleTableRef production. + EnterWarmUpSingleTableRef(c *WarmUpSingleTableRefContext) + + // EnterLockTable is called when entering the lockTable production. + EnterLockTable(c *LockTableContext) + + // EnterCreateRoutineLoad is called when entering the createRoutineLoad production. + EnterCreateRoutineLoad(c *CreateRoutineLoadContext) + + // EnterSeparator is called when entering the separator production. + EnterSeparator(c *SeparatorContext) + + // EnterImportColumns is called when entering the importColumns production. + EnterImportColumns(c *ImportColumnsContext) + + // EnterImportPrecedingFilter is called when entering the importPrecedingFilter production. + EnterImportPrecedingFilter(c *ImportPrecedingFilterContext) + + // EnterImportWhere is called when entering the importWhere production. + EnterImportWhere(c *ImportWhereContext) + + // EnterImportDeleteOn is called when entering the importDeleteOn production. + EnterImportDeleteOn(c *ImportDeleteOnContext) + + // EnterImportSequence is called when entering the importSequence production. + EnterImportSequence(c *ImportSequenceContext) + + // EnterImportPartitions is called when entering the importPartitions production. + EnterImportPartitions(c *ImportPartitionsContext) + + // EnterImportSequenceStatement is called when entering the importSequenceStatement production. + EnterImportSequenceStatement(c *ImportSequenceStatementContext) + + // EnterImportDeleteOnStatement is called when entering the importDeleteOnStatement production. + EnterImportDeleteOnStatement(c *ImportDeleteOnStatementContext) + + // EnterImportWhereStatement is called when entering the importWhereStatement production. + EnterImportWhereStatement(c *ImportWhereStatementContext) + + // EnterImportPrecedingFilterStatement is called when entering the importPrecedingFilterStatement production. + EnterImportPrecedingFilterStatement(c *ImportPrecedingFilterStatementContext) + + // EnterImportColumnsStatement is called when entering the importColumnsStatement production. + EnterImportColumnsStatement(c *ImportColumnsStatementContext) + + // EnterImportColumnDesc is called when entering the importColumnDesc production. + EnterImportColumnDesc(c *ImportColumnDescContext) + + // EnterRefreshCatalog is called when entering the refreshCatalog production. + EnterRefreshCatalog(c *RefreshCatalogContext) + + // EnterRefreshDatabase is called when entering the refreshDatabase production. + EnterRefreshDatabase(c *RefreshDatabaseContext) + + // EnterRefreshTable is called when entering the refreshTable production. + EnterRefreshTable(c *RefreshTableContext) + + // EnterRefreshDictionary is called when entering the refreshDictionary production. + EnterRefreshDictionary(c *RefreshDictionaryContext) + + // EnterRefreshLdap is called when entering the refreshLdap production. + EnterRefreshLdap(c *RefreshLdapContext) + + // EnterCleanAllProfile is called when entering the cleanAllProfile production. + EnterCleanAllProfile(c *CleanAllProfileContext) + + // EnterCleanLabel is called when entering the cleanLabel production. + EnterCleanLabel(c *CleanLabelContext) + + // EnterCleanQueryStats is called when entering the cleanQueryStats production. + EnterCleanQueryStats(c *CleanQueryStatsContext) + + // EnterCleanAllQueryStats is called when entering the cleanAllQueryStats production. + EnterCleanAllQueryStats(c *CleanAllQueryStatsContext) + + // EnterCancelLoad is called when entering the cancelLoad production. + EnterCancelLoad(c *CancelLoadContext) + + // EnterCancelExport is called when entering the cancelExport production. + EnterCancelExport(c *CancelExportContext) + + // EnterCancelWarmUpJob is called when entering the cancelWarmUpJob production. + EnterCancelWarmUpJob(c *CancelWarmUpJobContext) + + // EnterCancelDecommisionBackend is called when entering the cancelDecommisionBackend production. + EnterCancelDecommisionBackend(c *CancelDecommisionBackendContext) + + // EnterCancelBackup is called when entering the cancelBackup production. + EnterCancelBackup(c *CancelBackupContext) + + // EnterCancelRestore is called when entering the cancelRestore production. + EnterCancelRestore(c *CancelRestoreContext) + + // EnterCancelBuildIndex is called when entering the cancelBuildIndex production. + EnterCancelBuildIndex(c *CancelBuildIndexContext) + + // EnterCancelAlterTable is called when entering the cancelAlterTable production. + EnterCancelAlterTable(c *CancelAlterTableContext) + + // EnterAdminShowReplicaDistribution is called when entering the adminShowReplicaDistribution production. + EnterAdminShowReplicaDistribution(c *AdminShowReplicaDistributionContext) + + // EnterAdminRebalanceDisk is called when entering the adminRebalanceDisk production. + EnterAdminRebalanceDisk(c *AdminRebalanceDiskContext) + + // EnterAdminCancelRebalanceDisk is called when entering the adminCancelRebalanceDisk production. + EnterAdminCancelRebalanceDisk(c *AdminCancelRebalanceDiskContext) + + // EnterAdminDiagnoseTablet is called when entering the adminDiagnoseTablet production. + EnterAdminDiagnoseTablet(c *AdminDiagnoseTabletContext) + + // EnterAdminShowReplicaStatus is called when entering the adminShowReplicaStatus production. + EnterAdminShowReplicaStatus(c *AdminShowReplicaStatusContext) + + // EnterAdminCompactTable is called when entering the adminCompactTable production. + EnterAdminCompactTable(c *AdminCompactTableContext) + + // EnterAdminCheckTablets is called when entering the adminCheckTablets production. + EnterAdminCheckTablets(c *AdminCheckTabletsContext) + + // EnterAdminShowTabletStorageFormat is called when entering the adminShowTabletStorageFormat production. + EnterAdminShowTabletStorageFormat(c *AdminShowTabletStorageFormatContext) + + // EnterAdminSetFrontendConfig is called when entering the adminSetFrontendConfig production. + EnterAdminSetFrontendConfig(c *AdminSetFrontendConfigContext) + + // EnterAdminCleanTrash is called when entering the adminCleanTrash production. + EnterAdminCleanTrash(c *AdminCleanTrashContext) + + // EnterAdminSetReplicaVersion is called when entering the adminSetReplicaVersion production. + EnterAdminSetReplicaVersion(c *AdminSetReplicaVersionContext) + + // EnterAdminSetTableStatus is called when entering the adminSetTableStatus production. + EnterAdminSetTableStatus(c *AdminSetTableStatusContext) + + // EnterAdminSetReplicaStatus is called when entering the adminSetReplicaStatus production. + EnterAdminSetReplicaStatus(c *AdminSetReplicaStatusContext) + + // EnterAdminRepairTable is called when entering the adminRepairTable production. + EnterAdminRepairTable(c *AdminRepairTableContext) + + // EnterAdminCancelRepairTable is called when entering the adminCancelRepairTable production. + EnterAdminCancelRepairTable(c *AdminCancelRepairTableContext) + + // EnterAdminCopyTablet is called when entering the adminCopyTablet production. + EnterAdminCopyTablet(c *AdminCopyTabletContext) + + // EnterAdminSetEncryptionRootKey is called when entering the adminSetEncryptionRootKey production. + EnterAdminSetEncryptionRootKey(c *AdminSetEncryptionRootKeyContext) + + // EnterAdminSetPartitionVersion is called when entering the adminSetPartitionVersion production. + EnterAdminSetPartitionVersion(c *AdminSetPartitionVersionContext) + + // EnterAdminCreateClusterSnapshot is called when entering the adminCreateClusterSnapshot production. + EnterAdminCreateClusterSnapshot(c *AdminCreateClusterSnapshotContext) + + // EnterAdminSetAutoClusterSnapshot is called when entering the adminSetAutoClusterSnapshot production. + EnterAdminSetAutoClusterSnapshot(c *AdminSetAutoClusterSnapshotContext) + + // EnterAdminDropClusterSnapshot is called when entering the adminDropClusterSnapshot production. + EnterAdminDropClusterSnapshot(c *AdminDropClusterSnapshotContext) + + // EnterAdminSetClusterSnapshotFeatureSwitch is called when entering the adminSetClusterSnapshotFeatureSwitch production. + EnterAdminSetClusterSnapshotFeatureSwitch(c *AdminSetClusterSnapshotFeatureSwitchContext) + + // EnterAdminRotateTdeRootKey is called when entering the adminRotateTdeRootKey production. + EnterAdminRotateTdeRootKey(c *AdminRotateTdeRootKeyContext) + + // EnterRecoverDatabase is called when entering the recoverDatabase production. + EnterRecoverDatabase(c *RecoverDatabaseContext) + + // EnterRecoverTable is called when entering the recoverTable production. + EnterRecoverTable(c *RecoverTableContext) + + // EnterRecoverPartition is called when entering the recoverPartition production. + EnterRecoverPartition(c *RecoverPartitionContext) + + // EnterBaseTableRef is called when entering the baseTableRef production. + EnterBaseTableRef(c *BaseTableRefContext) + + // EnterWildWhere is called when entering the wildWhere production. + EnterWildWhere(c *WildWhereContext) + + // EnterTransactionBegin is called when entering the transactionBegin production. + EnterTransactionBegin(c *TransactionBeginContext) + + // EnterTranscationCommit is called when entering the transcationCommit production. + EnterTranscationCommit(c *TranscationCommitContext) + + // EnterTransactionRollback is called when entering the transactionRollback production. + EnterTransactionRollback(c *TransactionRollbackContext) + + // EnterGrantTablePrivilege is called when entering the grantTablePrivilege production. + EnterGrantTablePrivilege(c *GrantTablePrivilegeContext) + + // EnterGrantResourcePrivilege is called when entering the grantResourcePrivilege production. + EnterGrantResourcePrivilege(c *GrantResourcePrivilegeContext) + + // EnterGrantRole is called when entering the grantRole production. + EnterGrantRole(c *GrantRoleContext) + + // EnterRevokeRole is called when entering the revokeRole production. + EnterRevokeRole(c *RevokeRoleContext) + + // EnterRevokeResourcePrivilege is called when entering the revokeResourcePrivilege production. + EnterRevokeResourcePrivilege(c *RevokeResourcePrivilegeContext) + + // EnterRevokeTablePrivilege is called when entering the revokeTablePrivilege production. + EnterRevokeTablePrivilege(c *RevokeTablePrivilegeContext) + + // EnterPrivilege is called when entering the privilege production. + EnterPrivilege(c *PrivilegeContext) + + // EnterPrivilegeList is called when entering the privilegeList production. + EnterPrivilegeList(c *PrivilegeListContext) + + // EnterAddBackendClause is called when entering the addBackendClause production. + EnterAddBackendClause(c *AddBackendClauseContext) + + // EnterDropBackendClause is called when entering the dropBackendClause production. + EnterDropBackendClause(c *DropBackendClauseContext) + + // EnterDecommissionBackendClause is called when entering the decommissionBackendClause production. + EnterDecommissionBackendClause(c *DecommissionBackendClauseContext) + + // EnterAddObserverClause is called when entering the addObserverClause production. + EnterAddObserverClause(c *AddObserverClauseContext) + + // EnterDropObserverClause is called when entering the dropObserverClause production. + EnterDropObserverClause(c *DropObserverClauseContext) + + // EnterAddFollowerClause is called when entering the addFollowerClause production. + EnterAddFollowerClause(c *AddFollowerClauseContext) + + // EnterDropFollowerClause is called when entering the dropFollowerClause production. + EnterDropFollowerClause(c *DropFollowerClauseContext) + + // EnterAddBrokerClause is called when entering the addBrokerClause production. + EnterAddBrokerClause(c *AddBrokerClauseContext) + + // EnterDropBrokerClause is called when entering the dropBrokerClause production. + EnterDropBrokerClause(c *DropBrokerClauseContext) + + // EnterDropAllBrokerClause is called when entering the dropAllBrokerClause production. + EnterDropAllBrokerClause(c *DropAllBrokerClauseContext) + + // EnterAlterLoadErrorUrlClause is called when entering the alterLoadErrorUrlClause production. + EnterAlterLoadErrorUrlClause(c *AlterLoadErrorUrlClauseContext) + + // EnterModifyBackendClause is called when entering the modifyBackendClause production. + EnterModifyBackendClause(c *ModifyBackendClauseContext) + + // EnterModifyFrontendOrBackendHostNameClause is called when entering the modifyFrontendOrBackendHostNameClause production. + EnterModifyFrontendOrBackendHostNameClause(c *ModifyFrontendOrBackendHostNameClauseContext) + + // EnterDropRollupClause is called when entering the dropRollupClause production. + EnterDropRollupClause(c *DropRollupClauseContext) + + // EnterAddRollupClause is called when entering the addRollupClause production. + EnterAddRollupClause(c *AddRollupClauseContext) + + // EnterAddColumnClause is called when entering the addColumnClause production. + EnterAddColumnClause(c *AddColumnClauseContext) + + // EnterAddColumnsClause is called when entering the addColumnsClause production. + EnterAddColumnsClause(c *AddColumnsClauseContext) + + // EnterDropColumnClause is called when entering the dropColumnClause production. + EnterDropColumnClause(c *DropColumnClauseContext) + + // EnterModifyColumnClause is called when entering the modifyColumnClause production. + EnterModifyColumnClause(c *ModifyColumnClauseContext) + + // EnterReorderColumnsClause is called when entering the reorderColumnsClause production. + EnterReorderColumnsClause(c *ReorderColumnsClauseContext) + + // EnterAddPartitionClause is called when entering the addPartitionClause production. + EnterAddPartitionClause(c *AddPartitionClauseContext) + + // EnterDropPartitionClause is called when entering the dropPartitionClause production. + EnterDropPartitionClause(c *DropPartitionClauseContext) + + // EnterModifyPartitionClause is called when entering the modifyPartitionClause production. + EnterModifyPartitionClause(c *ModifyPartitionClauseContext) + + // EnterReplacePartitionClause is called when entering the replacePartitionClause production. + EnterReplacePartitionClause(c *ReplacePartitionClauseContext) + + // EnterReplaceTableClause is called when entering the replaceTableClause production. + EnterReplaceTableClause(c *ReplaceTableClauseContext) + + // EnterRenameClause is called when entering the renameClause production. + EnterRenameClause(c *RenameClauseContext) + + // EnterRenameRollupClause is called when entering the renameRollupClause production. + EnterRenameRollupClause(c *RenameRollupClauseContext) + + // EnterRenamePartitionClause is called when entering the renamePartitionClause production. + EnterRenamePartitionClause(c *RenamePartitionClauseContext) + + // EnterRenameColumnClause is called when entering the renameColumnClause production. + EnterRenameColumnClause(c *RenameColumnClauseContext) + + // EnterAddIndexClause is called when entering the addIndexClause production. + EnterAddIndexClause(c *AddIndexClauseContext) + + // EnterDropIndexClause is called when entering the dropIndexClause production. + EnterDropIndexClause(c *DropIndexClauseContext) + + // EnterEnableFeatureClause is called when entering the enableFeatureClause production. + EnterEnableFeatureClause(c *EnableFeatureClauseContext) + + // EnterModifyDistributionClause is called when entering the modifyDistributionClause production. + EnterModifyDistributionClause(c *ModifyDistributionClauseContext) + + // EnterModifyTableCommentClause is called when entering the modifyTableCommentClause production. + EnterModifyTableCommentClause(c *ModifyTableCommentClauseContext) + + // EnterModifyColumnCommentClause is called when entering the modifyColumnCommentClause production. + EnterModifyColumnCommentClause(c *ModifyColumnCommentClauseContext) + + // EnterModifyEngineClause is called when entering the modifyEngineClause production. + EnterModifyEngineClause(c *ModifyEngineClauseContext) + + // EnterAlterMultiPartitionClause is called when entering the alterMultiPartitionClause production. + EnterAlterMultiPartitionClause(c *AlterMultiPartitionClauseContext) + + // EnterCreateOrReplaceTagClauses is called when entering the createOrReplaceTagClauses production. + EnterCreateOrReplaceTagClauses(c *CreateOrReplaceTagClausesContext) + + // EnterCreateOrReplaceBranchClauses is called when entering the createOrReplaceBranchClauses production. + EnterCreateOrReplaceBranchClauses(c *CreateOrReplaceBranchClausesContext) + + // EnterDropBranchClauses is called when entering the dropBranchClauses production. + EnterDropBranchClauses(c *DropBranchClausesContext) + + // EnterDropTagClauses is called when entering the dropTagClauses production. + EnterDropTagClauses(c *DropTagClausesContext) + + // EnterAddPartitionFieldClause is called when entering the addPartitionFieldClause production. + EnterAddPartitionFieldClause(c *AddPartitionFieldClauseContext) + + // EnterDropPartitionFieldClause is called when entering the dropPartitionFieldClause production. + EnterDropPartitionFieldClause(c *DropPartitionFieldClauseContext) + + // EnterReplacePartitionFieldClause is called when entering the replacePartitionFieldClause production. + EnterReplacePartitionFieldClause(c *ReplacePartitionFieldClauseContext) + + // EnterCreateOrReplaceTagClause is called when entering the createOrReplaceTagClause production. + EnterCreateOrReplaceTagClause(c *CreateOrReplaceTagClauseContext) + + // EnterCreateOrReplaceBranchClause is called when entering the createOrReplaceBranchClause production. + EnterCreateOrReplaceBranchClause(c *CreateOrReplaceBranchClauseContext) + + // EnterTagOptions is called when entering the tagOptions production. + EnterTagOptions(c *TagOptionsContext) + + // EnterBranchOptions is called when entering the branchOptions production. + EnterBranchOptions(c *BranchOptionsContext) + + // EnterRetainTime is called when entering the retainTime production. + EnterRetainTime(c *RetainTimeContext) + + // EnterRetentionSnapshot is called when entering the retentionSnapshot production. + EnterRetentionSnapshot(c *RetentionSnapshotContext) + + // EnterMinSnapshotsToKeep is called when entering the minSnapshotsToKeep production. + EnterMinSnapshotsToKeep(c *MinSnapshotsToKeepContext) + + // EnterTimeValueWithUnit is called when entering the timeValueWithUnit production. + EnterTimeValueWithUnit(c *TimeValueWithUnitContext) + + // EnterDropBranchClause is called when entering the dropBranchClause production. + EnterDropBranchClause(c *DropBranchClauseContext) + + // EnterDropTagClause is called when entering the dropTagClause production. + EnterDropTagClause(c *DropTagClauseContext) + + // EnterPartitionTransformWithArgs is called when entering the partitionTransformWithArgs production. + EnterPartitionTransformWithArgs(c *PartitionTransformWithArgsContext) + + // EnterPartitionTransformWithColumn is called when entering the partitionTransformWithColumn production. + EnterPartitionTransformWithColumn(c *PartitionTransformWithColumnContext) + + // EnterPartitionTransformIdentity is called when entering the partitionTransformIdentity production. + EnterPartitionTransformIdentity(c *PartitionTransformIdentityContext) + + // EnterColumnPosition is called when entering the columnPosition production. + EnterColumnPosition(c *ColumnPositionContext) + + // EnterToRollup is called when entering the toRollup production. + EnterToRollup(c *ToRollupContext) + + // EnterFromRollup is called when entering the fromRollup production. + EnterFromRollup(c *FromRollupContext) + + // EnterShowAnalyze is called when entering the showAnalyze production. + EnterShowAnalyze(c *ShowAnalyzeContext) + + // EnterShowQueuedAnalyzeJobs is called when entering the showQueuedAnalyzeJobs production. + EnterShowQueuedAnalyzeJobs(c *ShowQueuedAnalyzeJobsContext) + + // EnterShowColumnHistogramStats is called when entering the showColumnHistogramStats production. + EnterShowColumnHistogramStats(c *ShowColumnHistogramStatsContext) + + // EnterShowColumnStats is called when entering the showColumnStats production. + EnterShowColumnStats(c *ShowColumnStatsContext) + + // EnterShowAnalyzeTask is called when entering the showAnalyzeTask production. + EnterShowAnalyzeTask(c *ShowAnalyzeTaskContext) + + // EnterAnalyzeDatabase is called when entering the analyzeDatabase production. + EnterAnalyzeDatabase(c *AnalyzeDatabaseContext) + + // EnterAnalyzeTable is called when entering the analyzeTable production. + EnterAnalyzeTable(c *AnalyzeTableContext) + + // EnterAlterTableStats is called when entering the alterTableStats production. + EnterAlterTableStats(c *AlterTableStatsContext) + + // EnterAlterColumnStats is called when entering the alterColumnStats production. + EnterAlterColumnStats(c *AlterColumnStatsContext) + + // EnterShowIndexStats is called when entering the showIndexStats production. + EnterShowIndexStats(c *ShowIndexStatsContext) + + // EnterDropStats is called when entering the dropStats production. + EnterDropStats(c *DropStatsContext) + + // EnterDropCachedStats is called when entering the dropCachedStats production. + EnterDropCachedStats(c *DropCachedStatsContext) + + // EnterDropExpiredStats is called when entering the dropExpiredStats production. + EnterDropExpiredStats(c *DropExpiredStatsContext) + + // EnterKillAnalyzeJob is called when entering the killAnalyzeJob production. + EnterKillAnalyzeJob(c *KillAnalyzeJobContext) + + // EnterDropAnalyzeJob is called when entering the dropAnalyzeJob production. + EnterDropAnalyzeJob(c *DropAnalyzeJobContext) + + // EnterShowTableStats is called when entering the showTableStats production. + EnterShowTableStats(c *ShowTableStatsContext) + + // EnterAnalyzeProperties is called when entering the analyzeProperties production. + EnterAnalyzeProperties(c *AnalyzePropertiesContext) + + // EnterWorkloadPolicyActions is called when entering the workloadPolicyActions production. + EnterWorkloadPolicyActions(c *WorkloadPolicyActionsContext) + + // EnterWorkloadPolicyAction is called when entering the workloadPolicyAction production. + EnterWorkloadPolicyAction(c *WorkloadPolicyActionContext) + + // EnterWorkloadPolicyConditions is called when entering the workloadPolicyConditions production. + EnterWorkloadPolicyConditions(c *WorkloadPolicyConditionsContext) + + // EnterWorkloadPolicyCondition is called when entering the workloadPolicyCondition production. + EnterWorkloadPolicyCondition(c *WorkloadPolicyConditionContext) + + // EnterStorageBackend is called when entering the storageBackend production. + EnterStorageBackend(c *StorageBackendContext) + + // EnterPasswordOption is called when entering the passwordOption production. + EnterPasswordOption(c *PasswordOptionContext) + + // EnterFunctionArguments is called when entering the functionArguments production. + EnterFunctionArguments(c *FunctionArgumentsContext) + + // EnterDataTypeList is called when entering the dataTypeList production. + EnterDataTypeList(c *DataTypeListContext) + + // EnterSetOptions is called when entering the setOptions production. + EnterSetOptions(c *SetOptionsContext) + + // EnterSetDefaultStorageVault is called when entering the setDefaultStorageVault production. + EnterSetDefaultStorageVault(c *SetDefaultStorageVaultContext) + + // EnterSetUserProperties is called when entering the setUserProperties production. + EnterSetUserProperties(c *SetUserPropertiesContext) + + // EnterSetTransaction is called when entering the setTransaction production. + EnterSetTransaction(c *SetTransactionContext) + + // EnterSetVariableWithType is called when entering the setVariableWithType production. + EnterSetVariableWithType(c *SetVariableWithTypeContext) + + // EnterSetNames is called when entering the setNames production. + EnterSetNames(c *SetNamesContext) + + // EnterSetCharset is called when entering the setCharset production. + EnterSetCharset(c *SetCharsetContext) + + // EnterSetCollate is called when entering the setCollate production. + EnterSetCollate(c *SetCollateContext) + + // EnterSetPassword is called when entering the setPassword production. + EnterSetPassword(c *SetPasswordContext) + + // EnterSetLdapAdminPassword is called when entering the setLdapAdminPassword production. + EnterSetLdapAdminPassword(c *SetLdapAdminPasswordContext) + + // EnterSetVariableWithoutType is called when entering the setVariableWithoutType production. + EnterSetVariableWithoutType(c *SetVariableWithoutTypeContext) + + // EnterSetSystemVariable is called when entering the setSystemVariable production. + EnterSetSystemVariable(c *SetSystemVariableContext) + + // EnterSetUserVariable is called when entering the setUserVariable production. + EnterSetUserVariable(c *SetUserVariableContext) + + // EnterTransactionAccessMode is called when entering the transactionAccessMode production. + EnterTransactionAccessMode(c *TransactionAccessModeContext) + + // EnterIsolationLevel is called when entering the isolationLevel production. + EnterIsolationLevel(c *IsolationLevelContext) + + // EnterSupportedUnsetStatement is called when entering the supportedUnsetStatement production. + EnterSupportedUnsetStatement(c *SupportedUnsetStatementContext) + + // EnterSwitchCatalog is called when entering the switchCatalog production. + EnterSwitchCatalog(c *SwitchCatalogContext) + + // EnterUseDatabase is called when entering the useDatabase production. + EnterUseDatabase(c *UseDatabaseContext) + + // EnterUseCloudCluster is called when entering the useCloudCluster production. + EnterUseCloudCluster(c *UseCloudClusterContext) + + // EnterStageAndPattern is called when entering the stageAndPattern production. + EnterStageAndPattern(c *StageAndPatternContext) + + // EnterDescribeTableValuedFunction is called when entering the describeTableValuedFunction production. + EnterDescribeTableValuedFunction(c *DescribeTableValuedFunctionContext) + + // EnterDescribeTableAll is called when entering the describeTableAll production. + EnterDescribeTableAll(c *DescribeTableAllContext) + + // EnterDescribeTable is called when entering the describeTable production. + EnterDescribeTable(c *DescribeTableContext) + + // EnterDescribeDictionary is called when entering the describeDictionary production. + EnterDescribeDictionary(c *DescribeDictionaryContext) + + // EnterConstraint is called when entering the constraint production. + EnterConstraint(c *ConstraintContext) + + // EnterPartitionSpec is called when entering the partitionSpec production. + EnterPartitionSpec(c *PartitionSpecContext) + + // EnterPartitionTable is called when entering the partitionTable production. + EnterPartitionTable(c *PartitionTableContext) + + // EnterIdentityOrFunctionList is called when entering the identityOrFunctionList production. + EnterIdentityOrFunctionList(c *IdentityOrFunctionListContext) + + // EnterIdentityOrFunction is called when entering the identityOrFunction production. + EnterIdentityOrFunction(c *IdentityOrFunctionContext) + + // EnterDataDesc is called when entering the dataDesc production. + EnterDataDesc(c *DataDescContext) + + // EnterStatementScope is called when entering the statementScope production. + EnterStatementScope(c *StatementScopeContext) + + // EnterBuildMode is called when entering the buildMode production. + EnterBuildMode(c *BuildModeContext) + + // EnterRefreshTrigger is called when entering the refreshTrigger production. + EnterRefreshTrigger(c *RefreshTriggerContext) + + // EnterRefreshSchedule is called when entering the refreshSchedule production. + EnterRefreshSchedule(c *RefreshScheduleContext) + + // EnterRefreshMethod is called when entering the refreshMethod production. + EnterRefreshMethod(c *RefreshMethodContext) + + // EnterMvPartition is called when entering the mvPartition production. + EnterMvPartition(c *MvPartitionContext) + + // EnterIdentifierOrText is called when entering the identifierOrText production. + EnterIdentifierOrText(c *IdentifierOrTextContext) + + // EnterIdentifierOrTextOrAsterisk is called when entering the identifierOrTextOrAsterisk production. + EnterIdentifierOrTextOrAsterisk(c *IdentifierOrTextOrAsteriskContext) + + // EnterMultipartIdentifierOrAsterisk is called when entering the multipartIdentifierOrAsterisk production. + EnterMultipartIdentifierOrAsterisk(c *MultipartIdentifierOrAsteriskContext) + + // EnterIdentifierOrAsterisk is called when entering the identifierOrAsterisk production. + EnterIdentifierOrAsterisk(c *IdentifierOrAsteriskContext) + + // EnterUserIdentify is called when entering the userIdentify production. + EnterUserIdentify(c *UserIdentifyContext) + + // EnterGrantUserIdentify is called when entering the grantUserIdentify production. + EnterGrantUserIdentify(c *GrantUserIdentifyContext) + + // EnterExplain is called when entering the explain production. + EnterExplain(c *ExplainContext) + + // EnterExplainCommand is called when entering the explainCommand production. + EnterExplainCommand(c *ExplainCommandContext) + + // EnterPlanType is called when entering the planType production. + EnterPlanType(c *PlanTypeContext) + + // EnterReplayCommand is called when entering the replayCommand production. + EnterReplayCommand(c *ReplayCommandContext) + + // EnterReplayType is called when entering the replayType production. + EnterReplayType(c *ReplayTypeContext) + + // EnterMergeType is called when entering the mergeType production. + EnterMergeType(c *MergeTypeContext) + + // EnterPreFilterClause is called when entering the preFilterClause production. + EnterPreFilterClause(c *PreFilterClauseContext) + + // EnterDeleteOnClause is called when entering the deleteOnClause production. + EnterDeleteOnClause(c *DeleteOnClauseContext) + + // EnterSequenceColClause is called when entering the sequenceColClause production. + EnterSequenceColClause(c *SequenceColClauseContext) + + // EnterColFromPath is called when entering the colFromPath production. + EnterColFromPath(c *ColFromPathContext) + + // EnterColMappingList is called when entering the colMappingList production. + EnterColMappingList(c *ColMappingListContext) + + // EnterMappingExpr is called when entering the mappingExpr production. + EnterMappingExpr(c *MappingExprContext) + + // EnterWithRemoteStorageSystem is called when entering the withRemoteStorageSystem production. + EnterWithRemoteStorageSystem(c *WithRemoteStorageSystemContext) + + // EnterResourceDesc is called when entering the resourceDesc production. + EnterResourceDesc(c *ResourceDescContext) + + // EnterMysqlDataDesc is called when entering the mysqlDataDesc production. + EnterMysqlDataDesc(c *MysqlDataDescContext) + + // EnterSkipLines is called when entering the skipLines production. + EnterSkipLines(c *SkipLinesContext) + + // EnterOutFileClause is called when entering the outFileClause production. + EnterOutFileClause(c *OutFileClauseContext) + + // EnterQuery is called when entering the query production. + EnterQuery(c *QueryContext) + + // EnterQueryTermDefault is called when entering the queryTermDefault production. + EnterQueryTermDefault(c *QueryTermDefaultContext) + + // EnterSetOperation is called when entering the setOperation production. + EnterSetOperation(c *SetOperationContext) + + // EnterSetQuantifier is called when entering the setQuantifier production. + EnterSetQuantifier(c *SetQuantifierContext) + + // EnterQueryPrimaryDefault is called when entering the queryPrimaryDefault production. + EnterQueryPrimaryDefault(c *QueryPrimaryDefaultContext) + + // EnterSubquery is called when entering the subquery production. + EnterSubquery(c *SubqueryContext) + + // EnterValuesTable is called when entering the valuesTable production. + EnterValuesTable(c *ValuesTableContext) + + // EnterRegularQuerySpecification is called when entering the regularQuerySpecification production. + EnterRegularQuerySpecification(c *RegularQuerySpecificationContext) + + // EnterCte is called when entering the cte production. + EnterCte(c *CteContext) + + // EnterAliasQuery is called when entering the aliasQuery production. + EnterAliasQuery(c *AliasQueryContext) + + // EnterColumnAliases is called when entering the columnAliases production. + EnterColumnAliases(c *ColumnAliasesContext) + + // EnterSelectClause is called when entering the selectClause production. + EnterSelectClause(c *SelectClauseContext) + + // EnterSelectColumnClause is called when entering the selectColumnClause production. + EnterSelectColumnClause(c *SelectColumnClauseContext) + + // EnterWhereClause is called when entering the whereClause production. + EnterWhereClause(c *WhereClauseContext) + + // EnterFromClause is called when entering the fromClause production. + EnterFromClause(c *FromClauseContext) + + // EnterIntoClause is called when entering the intoClause production. + EnterIntoClause(c *IntoClauseContext) + + // EnterBulkCollectClause is called when entering the bulkCollectClause production. + EnterBulkCollectClause(c *BulkCollectClauseContext) + + // EnterTableRow is called when entering the tableRow production. + EnterTableRow(c *TableRowContext) + + // EnterRelations is called when entering the relations production. + EnterRelations(c *RelationsContext) + + // EnterRelation is called when entering the relation production. + EnterRelation(c *RelationContext) + + // EnterJoinRelation is called when entering the joinRelation production. + EnterJoinRelation(c *JoinRelationContext) + + // EnterDistributeType is called when entering the distributeType production. + EnterDistributeType(c *DistributeTypeContext) + + // EnterSkewHint is called when entering the skewHint production. + EnterSkewHint(c *SkewHintContext) + + // EnterConstantList is called when entering the constantList production. + EnterConstantList(c *ConstantListContext) + + // EnterBracketRelationHint is called when entering the bracketRelationHint production. + EnterBracketRelationHint(c *BracketRelationHintContext) + + // EnterCommentRelationHint is called when entering the commentRelationHint production. + EnterCommentRelationHint(c *CommentRelationHintContext) + + // EnterExpressionWithOrder is called when entering the expressionWithOrder production. + EnterExpressionWithOrder(c *ExpressionWithOrderContext) + + // EnterAggClause is called when entering the aggClause production. + EnterAggClause(c *AggClauseContext) + + // EnterGroupingElement is called when entering the groupingElement production. + EnterGroupingElement(c *GroupingElementContext) + + // EnterGroupingSet is called when entering the groupingSet production. + EnterGroupingSet(c *GroupingSetContext) + + // EnterHavingClause is called when entering the havingClause production. + EnterHavingClause(c *HavingClauseContext) + + // EnterQualifyClause is called when entering the qualifyClause production. + EnterQualifyClause(c *QualifyClauseContext) + + // EnterSelectHint is called when entering the selectHint production. + EnterSelectHint(c *SelectHintContext) + + // EnterHintStatement is called when entering the hintStatement production. + EnterHintStatement(c *HintStatementContext) + + // EnterHintName is called when entering the hintName production. + EnterHintName(c *HintNameContext) + + // EnterHintAssignment is called when entering the hintAssignment production. + EnterHintAssignment(c *HintAssignmentContext) + + // EnterUpdateAssignment is called when entering the updateAssignment production. + EnterUpdateAssignment(c *UpdateAssignmentContext) + + // EnterUpdateAssignmentSeq is called when entering the updateAssignmentSeq production. + EnterUpdateAssignmentSeq(c *UpdateAssignmentSeqContext) + + // EnterLateralView is called when entering the lateralView production. + EnterLateralView(c *LateralViewContext) + + // EnterQueryOrganization is called when entering the queryOrganization production. + EnterQueryOrganization(c *QueryOrganizationContext) + + // EnterSortClause is called when entering the sortClause production. + EnterSortClause(c *SortClauseContext) + + // EnterSortItem is called when entering the sortItem production. + EnterSortItem(c *SortItemContext) + + // EnterLimitClause is called when entering the limitClause production. + EnterLimitClause(c *LimitClauseContext) + + // EnterPartitionClause is called when entering the partitionClause production. + EnterPartitionClause(c *PartitionClauseContext) + + // EnterJoinType is called when entering the joinType production. + EnterJoinType(c *JoinTypeContext) + + // EnterJoinCriteria is called when entering the joinCriteria production. + EnterJoinCriteria(c *JoinCriteriaContext) + + // EnterIdentifierList is called when entering the identifierList production. + EnterIdentifierList(c *IdentifierListContext) + + // EnterIdentifierSeq is called when entering the identifierSeq production. + EnterIdentifierSeq(c *IdentifierSeqContext) + + // EnterOptScanParams is called when entering the optScanParams production. + EnterOptScanParams(c *OptScanParamsContext) + + // EnterTableName is called when entering the tableName production. + EnterTableName(c *TableNameContext) + + // EnterAliasedQuery is called when entering the aliasedQuery production. + EnterAliasedQuery(c *AliasedQueryContext) + + // EnterTableValuedFunction is called when entering the tableValuedFunction production. + EnterTableValuedFunction(c *TableValuedFunctionContext) + + // EnterRelationList is called when entering the relationList production. + EnterRelationList(c *RelationListContext) + + // EnterMaterializedViewName is called when entering the materializedViewName production. + EnterMaterializedViewName(c *MaterializedViewNameContext) + + // EnterPropertyClause is called when entering the propertyClause production. + EnterPropertyClause(c *PropertyClauseContext) + + // EnterPropertyItemList is called when entering the propertyItemList production. + EnterPropertyItemList(c *PropertyItemListContext) + + // EnterPropertyItem is called when entering the propertyItem production. + EnterPropertyItem(c *PropertyItemContext) + + // EnterPropertyKey is called when entering the propertyKey production. + EnterPropertyKey(c *PropertyKeyContext) + + // EnterPropertyValue is called when entering the propertyValue production. + EnterPropertyValue(c *PropertyValueContext) + + // EnterTableAlias is called when entering the tableAlias production. + EnterTableAlias(c *TableAliasContext) + + // EnterMultipartIdentifier is called when entering the multipartIdentifier production. + EnterMultipartIdentifier(c *MultipartIdentifierContext) + + // EnterSimpleColumnDefs is called when entering the simpleColumnDefs production. + EnterSimpleColumnDefs(c *SimpleColumnDefsContext) + + // EnterSimpleColumnDef is called when entering the simpleColumnDef production. + EnterSimpleColumnDef(c *SimpleColumnDefContext) + + // EnterColumnDefs is called when entering the columnDefs production. + EnterColumnDefs(c *ColumnDefsContext) + + // EnterColumnDef is called when entering the columnDef production. + EnterColumnDef(c *ColumnDefContext) + + // EnterIndexDefs is called when entering the indexDefs production. + EnterIndexDefs(c *IndexDefsContext) + + // EnterIndexDef is called when entering the indexDef production. + EnterIndexDef(c *IndexDefContext) + + // EnterPartitionsDef is called when entering the partitionsDef production. + EnterPartitionsDef(c *PartitionsDefContext) + + // EnterPartitionDef is called when entering the partitionDef production. + EnterPartitionDef(c *PartitionDefContext) + + // EnterLessThanPartitionDef is called when entering the lessThanPartitionDef production. + EnterLessThanPartitionDef(c *LessThanPartitionDefContext) + + // EnterFixedPartitionDef is called when entering the fixedPartitionDef production. + EnterFixedPartitionDef(c *FixedPartitionDefContext) + + // EnterStepPartitionDef is called when entering the stepPartitionDef production. + EnterStepPartitionDef(c *StepPartitionDefContext) + + // EnterInPartitionDef is called when entering the inPartitionDef production. + EnterInPartitionDef(c *InPartitionDefContext) + + // EnterPartitionValueList is called when entering the partitionValueList production. + EnterPartitionValueList(c *PartitionValueListContext) + + // EnterPartitionValueDef is called when entering the partitionValueDef production. + EnterPartitionValueDef(c *PartitionValueDefContext) + + // EnterRollupDefs is called when entering the rollupDefs production. + EnterRollupDefs(c *RollupDefsContext) + + // EnterRollupDef is called when entering the rollupDef production. + EnterRollupDef(c *RollupDefContext) + + // EnterAggTypeDef is called when entering the aggTypeDef production. + EnterAggTypeDef(c *AggTypeDefContext) + + // EnterTabletList is called when entering the tabletList production. + EnterTabletList(c *TabletListContext) + + // EnterInlineTable is called when entering the inlineTable production. + EnterInlineTable(c *InlineTableContext) + + // EnterNamedExpression is called when entering the namedExpression production. + EnterNamedExpression(c *NamedExpressionContext) + + // EnterNamedExpressionSeq is called when entering the namedExpressionSeq production. + EnterNamedExpressionSeq(c *NamedExpressionSeqContext) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterFuncExpression is called when entering the funcExpression production. + EnterFuncExpression(c *FuncExpressionContext) + + // EnterLambdaExpression is called when entering the lambdaExpression production. + EnterLambdaExpression(c *LambdaExpressionContext) + + // EnterExist is called when entering the exist production. + EnterExist(c *ExistContext) + + // EnterLogicalNot is called when entering the logicalNot production. + EnterLogicalNot(c *LogicalNotContext) + + // EnterPredicated is called when entering the predicated production. + EnterPredicated(c *PredicatedContext) + + // EnterIsnull is called when entering the isnull production. + EnterIsnull(c *IsnullContext) + + // EnterIs_not_null_pred is called when entering the is_not_null_pred production. + EnterIs_not_null_pred(c *Is_not_null_predContext) + + // EnterLogicalBinary is called when entering the logicalBinary production. + EnterLogicalBinary(c *LogicalBinaryContext) + + // EnterDoublePipes is called when entering the doublePipes production. + EnterDoublePipes(c *DoublePipesContext) + + // EnterRowConstructor is called when entering the rowConstructor production. + EnterRowConstructor(c *RowConstructorContext) + + // EnterRowConstructorItem is called when entering the rowConstructorItem production. + EnterRowConstructorItem(c *RowConstructorItemContext) + + // EnterPredicate is called when entering the predicate production. + EnterPredicate(c *PredicateContext) + + // EnterValueExpressionDefault is called when entering the valueExpressionDefault production. + EnterValueExpressionDefault(c *ValueExpressionDefaultContext) + + // EnterComparison is called when entering the comparison production. + EnterComparison(c *ComparisonContext) + + // EnterArithmeticBinary is called when entering the arithmeticBinary production. + EnterArithmeticBinary(c *ArithmeticBinaryContext) + + // EnterArithmeticUnary is called when entering the arithmeticUnary production. + EnterArithmeticUnary(c *ArithmeticUnaryContext) + + // EnterDereference is called when entering the dereference production. + EnterDereference(c *DereferenceContext) + + // EnterCurrentDate is called when entering the currentDate production. + EnterCurrentDate(c *CurrentDateContext) + + // EnterSubstring is called when entering the substring production. + EnterSubstring(c *SubstringContext) + + // EnterCast is called when entering the cast production. + EnterCast(c *CastContext) + + // EnterParenthesizedExpression is called when entering the parenthesizedExpression production. + EnterParenthesizedExpression(c *ParenthesizedExpressionContext) + + // EnterTrim is called when entering the trim production. + EnterTrim(c *TrimContext) + + // EnterUserVariable is called when entering the userVariable production. + EnterUserVariable(c *UserVariableContext) + + // EnterElementAt is called when entering the elementAt production. + EnterElementAt(c *ElementAtContext) + + // EnterLocalTimestamp is called when entering the localTimestamp production. + EnterLocalTimestamp(c *LocalTimestampContext) + + // EnterCharFunction is called when entering the charFunction production. + EnterCharFunction(c *CharFunctionContext) + + // EnterIntervalLiteral is called when entering the intervalLiteral production. + EnterIntervalLiteral(c *IntervalLiteralContext) + + // EnterGroupConcat is called when entering the groupConcat production. + EnterGroupConcat(c *GroupConcatContext) + + // EnterSimpleCase is called when entering the simpleCase production. + EnterSimpleCase(c *SimpleCaseContext) + + // EnterColumnReference is called when entering the columnReference production. + EnterColumnReference(c *ColumnReferenceContext) + + // EnterStar is called when entering the star production. + EnterStar(c *StarContext) + + // EnterGetFormatFunction is called when entering the getFormatFunction production. + EnterGetFormatFunction(c *GetFormatFunctionContext) + + // EnterSessionUser is called when entering the sessionUser production. + EnterSessionUser(c *SessionUserContext) + + // EnterConvertType is called when entering the convertType production. + EnterConvertType(c *ConvertTypeContext) + + // EnterConvertCharSet is called when entering the convertCharSet production. + EnterConvertCharSet(c *ConvertCharSetContext) + + // EnterSubqueryExpression is called when entering the subqueryExpression production. + EnterSubqueryExpression(c *SubqueryExpressionContext) + + // EnterEncryptKey is called when entering the encryptKey production. + EnterEncryptKey(c *EncryptKeyContext) + + // EnterCurrentTime is called when entering the currentTime production. + EnterCurrentTime(c *CurrentTimeContext) + + // EnterLocalTime is called when entering the localTime production. + EnterLocalTime(c *LocalTimeContext) + + // EnterSystemVariable is called when entering the systemVariable production. + EnterSystemVariable(c *SystemVariableContext) + + // EnterCollate is called when entering the collate production. + EnterCollate(c *CollateContext) + + // EnterCurrentUser is called when entering the currentUser production. + EnterCurrentUser(c *CurrentUserContext) + + // EnterConstantDefault is called when entering the constantDefault production. + EnterConstantDefault(c *ConstantDefaultContext) + + // EnterExtract is called when entering the extract production. + EnterExtract(c *ExtractContext) + + // EnterCurrentTimestamp is called when entering the currentTimestamp production. + EnterCurrentTimestamp(c *CurrentTimestampContext) + + // EnterFunctionCall is called when entering the functionCall production. + EnterFunctionCall(c *FunctionCallContext) + + // EnterArraySlice is called when entering the arraySlice production. + EnterArraySlice(c *ArraySliceContext) + + // EnterSearchedCase is called when entering the searchedCase production. + EnterSearchedCase(c *SearchedCaseContext) + + // EnterPosition is called when entering the position production. + EnterPosition(c *PositionContext) + + // EnterTryCast is called when entering the tryCast production. + EnterTryCast(c *TryCastContext) + + // EnterExcept is called when entering the except production. + EnterExcept(c *ExceptContext) + + // EnterReplace is called when entering the replace production. + EnterReplace(c *ReplaceContext) + + // EnterCastDataType is called when entering the castDataType production. + EnterCastDataType(c *CastDataTypeContext) + + // EnterFunctionCallExpression is called when entering the functionCallExpression production. + EnterFunctionCallExpression(c *FunctionCallExpressionContext) + + // EnterFunctionIdentifier is called when entering the functionIdentifier production. + EnterFunctionIdentifier(c *FunctionIdentifierContext) + + // EnterFunctionNameIdentifier is called when entering the functionNameIdentifier production. + EnterFunctionNameIdentifier(c *FunctionNameIdentifierContext) + + // EnterWindowSpec is called when entering the windowSpec production. + EnterWindowSpec(c *WindowSpecContext) + + // EnterWindowFrame is called when entering the windowFrame production. + EnterWindowFrame(c *WindowFrameContext) + + // EnterFrameUnits is called when entering the frameUnits production. + EnterFrameUnits(c *FrameUnitsContext) + + // EnterFrameBoundary is called when entering the frameBoundary production. + EnterFrameBoundary(c *FrameBoundaryContext) + + // EnterQualifiedName is called when entering the qualifiedName production. + EnterQualifiedName(c *QualifiedNameContext) + + // EnterSpecifiedPartition is called when entering the specifiedPartition production. + EnterSpecifiedPartition(c *SpecifiedPartitionContext) + + // EnterNullLiteral is called when entering the nullLiteral production. + EnterNullLiteral(c *NullLiteralContext) + + // EnterTypeConstructor is called when entering the typeConstructor production. + EnterTypeConstructor(c *TypeConstructorContext) + + // EnterNumericLiteral is called when entering the numericLiteral production. + EnterNumericLiteral(c *NumericLiteralContext) + + // EnterBooleanLiteral is called when entering the booleanLiteral production. + EnterBooleanLiteral(c *BooleanLiteralContext) + + // EnterStringLiteral is called when entering the stringLiteral production. + EnterStringLiteral(c *StringLiteralContext) + + // EnterVarbinaryLiteral is called when entering the varbinaryLiteral production. + EnterVarbinaryLiteral(c *VarbinaryLiteralContext) + + // EnterArrayLiteral is called when entering the arrayLiteral production. + EnterArrayLiteral(c *ArrayLiteralContext) + + // EnterMapLiteral is called when entering the mapLiteral production. + EnterMapLiteral(c *MapLiteralContext) + + // EnterStructLiteral is called when entering the structLiteral production. + EnterStructLiteral(c *StructLiteralContext) + + // EnterPlaceholder is called when entering the placeholder production. + EnterPlaceholder(c *PlaceholderContext) + + // EnterComparisonOperator is called when entering the comparisonOperator production. + EnterComparisonOperator(c *ComparisonOperatorContext) + + // EnterBooleanValue is called when entering the booleanValue production. + EnterBooleanValue(c *BooleanValueContext) + + // EnterWhenClause is called when entering the whenClause production. + EnterWhenClause(c *WhenClauseContext) + + // EnterInterval is called when entering the interval production. + EnterInterval(c *IntervalContext) + + // EnterUnitIdentifier is called when entering the unitIdentifier production. + EnterUnitIdentifier(c *UnitIdentifierContext) + + // EnterDataTypeWithNullable is called when entering the dataTypeWithNullable production. + EnterDataTypeWithNullable(c *DataTypeWithNullableContext) + + // EnterComplexDataType is called when entering the complexDataType production. + EnterComplexDataType(c *ComplexDataTypeContext) + + // EnterVariantPredefinedFields is called when entering the variantPredefinedFields production. + EnterVariantPredefinedFields(c *VariantPredefinedFieldsContext) + + // EnterAggStateDataType is called when entering the aggStateDataType production. + EnterAggStateDataType(c *AggStateDataTypeContext) + + // EnterPrimitiveDataType is called when entering the primitiveDataType production. + EnterPrimitiveDataType(c *PrimitiveDataTypeContext) + + // EnterPrimitiveColType is called when entering the primitiveColType production. + EnterPrimitiveColType(c *PrimitiveColTypeContext) + + // EnterComplexColTypeList is called when entering the complexColTypeList production. + EnterComplexColTypeList(c *ComplexColTypeListContext) + + // EnterComplexColType is called when entering the complexColType production. + EnterComplexColType(c *ComplexColTypeContext) + + // EnterVariant is called when entering the variant production. + EnterVariant(c *VariantContext) + + // EnterVariantSubColTypeList is called when entering the variantSubColTypeList production. + EnterVariantSubColTypeList(c *VariantSubColTypeListContext) + + // EnterVariantSubColType is called when entering the variantSubColType production. + EnterVariantSubColType(c *VariantSubColTypeContext) + + // EnterVariantSubColMatchType is called when entering the variantSubColMatchType production. + EnterVariantSubColMatchType(c *VariantSubColMatchTypeContext) + + // EnterCommentSpec is called when entering the commentSpec production. + EnterCommentSpec(c *CommentSpecContext) + + // EnterSample is called when entering the sample production. + EnterSample(c *SampleContext) + + // EnterSampleByPercentile is called when entering the sampleByPercentile production. + EnterSampleByPercentile(c *SampleByPercentileContext) + + // EnterSampleByRows is called when entering the sampleByRows production. + EnterSampleByRows(c *SampleByRowsContext) + + // EnterTableSnapshot is called when entering the tableSnapshot production. + EnterTableSnapshot(c *TableSnapshotContext) + + // EnterErrorCapturingIdentifier is called when entering the errorCapturingIdentifier production. + EnterErrorCapturingIdentifier(c *ErrorCapturingIdentifierContext) + + // EnterErrorIdent is called when entering the errorIdent production. + EnterErrorIdent(c *ErrorIdentContext) + + // EnterRealIdent is called when entering the realIdent production. + EnterRealIdent(c *RealIdentContext) + + // EnterIdentifier is called when entering the identifier production. + EnterIdentifier(c *IdentifierContext) + + // EnterUnquotedIdentifier is called when entering the unquotedIdentifier production. + EnterUnquotedIdentifier(c *UnquotedIdentifierContext) + + // EnterQuotedIdentifierAlternative is called when entering the quotedIdentifierAlternative production. + EnterQuotedIdentifierAlternative(c *QuotedIdentifierAlternativeContext) + + // EnterQuotedIdentifier is called when entering the quotedIdentifier production. + EnterQuotedIdentifier(c *QuotedIdentifierContext) + + // EnterIntegerLiteral is called when entering the integerLiteral production. + EnterIntegerLiteral(c *IntegerLiteralContext) + + // EnterDecimalLiteral is called when entering the decimalLiteral production. + EnterDecimalLiteral(c *DecimalLiteralContext) + + // EnterNonReserved is called when entering the nonReserved production. + EnterNonReserved(c *NonReservedContext) + + // ExitMultiStatements is called when exiting the multiStatements production. + ExitMultiStatements(c *MultiStatementsContext) + + // ExitSingleStatement is called when exiting the singleStatement production. + ExitSingleStatement(c *SingleStatementContext) + + // ExitExpressionWithEof is called when exiting the expressionWithEof production. + ExitExpressionWithEof(c *ExpressionWithEofContext) + + // ExitStatementBaseAlias is called when exiting the statementBaseAlias production. + ExitStatementBaseAlias(c *StatementBaseAliasContext) + + // ExitCallProcedure is called when exiting the callProcedure production. + ExitCallProcedure(c *CallProcedureContext) + + // ExitCreateProcedure is called when exiting the createProcedure production. + ExitCreateProcedure(c *CreateProcedureContext) + + // ExitDropProcedure is called when exiting the dropProcedure production. + ExitDropProcedure(c *DropProcedureContext) + + // ExitShowProcedureStatus is called when exiting the showProcedureStatus production. + ExitShowProcedureStatus(c *ShowProcedureStatusContext) + + // ExitShowCreateProcedure is called when exiting the showCreateProcedure production. + ExitShowCreateProcedure(c *ShowCreateProcedureContext) + + // ExitShowConfig is called when exiting the showConfig production. + ExitShowConfig(c *ShowConfigContext) + + // ExitStatementDefault is called when exiting the statementDefault production. + ExitStatementDefault(c *StatementDefaultContext) + + // ExitSupportedDmlStatementAlias is called when exiting the supportedDmlStatementAlias production. + ExitSupportedDmlStatementAlias(c *SupportedDmlStatementAliasContext) + + // ExitSupportedCreateStatementAlias is called when exiting the supportedCreateStatementAlias production. + ExitSupportedCreateStatementAlias(c *SupportedCreateStatementAliasContext) + + // ExitSupportedAlterStatementAlias is called when exiting the supportedAlterStatementAlias production. + ExitSupportedAlterStatementAlias(c *SupportedAlterStatementAliasContext) + + // ExitMaterializedViewStatementAlias is called when exiting the materializedViewStatementAlias production. + ExitMaterializedViewStatementAlias(c *MaterializedViewStatementAliasContext) + + // ExitSupportedJobStatementAlias is called when exiting the supportedJobStatementAlias production. + ExitSupportedJobStatementAlias(c *SupportedJobStatementAliasContext) + + // ExitConstraintStatementAlias is called when exiting the constraintStatementAlias production. + ExitConstraintStatementAlias(c *ConstraintStatementAliasContext) + + // ExitSupportedCleanStatementAlias is called when exiting the supportedCleanStatementAlias production. + ExitSupportedCleanStatementAlias(c *SupportedCleanStatementAliasContext) + + // ExitSupportedDescribeStatementAlias is called when exiting the supportedDescribeStatementAlias production. + ExitSupportedDescribeStatementAlias(c *SupportedDescribeStatementAliasContext) + + // ExitSupportedDropStatementAlias is called when exiting the supportedDropStatementAlias production. + ExitSupportedDropStatementAlias(c *SupportedDropStatementAliasContext) + + // ExitSupportedSetStatementAlias is called when exiting the supportedSetStatementAlias production. + ExitSupportedSetStatementAlias(c *SupportedSetStatementAliasContext) + + // ExitSupportedUnsetStatementAlias is called when exiting the supportedUnsetStatementAlias production. + ExitSupportedUnsetStatementAlias(c *SupportedUnsetStatementAliasContext) + + // ExitSupportedRefreshStatementAlias is called when exiting the supportedRefreshStatementAlias production. + ExitSupportedRefreshStatementAlias(c *SupportedRefreshStatementAliasContext) + + // ExitSupportedShowStatementAlias is called when exiting the supportedShowStatementAlias production. + ExitSupportedShowStatementAlias(c *SupportedShowStatementAliasContext) + + // ExitSupportedLoadStatementAlias is called when exiting the supportedLoadStatementAlias production. + ExitSupportedLoadStatementAlias(c *SupportedLoadStatementAliasContext) + + // ExitSupportedCancelStatementAlias is called when exiting the supportedCancelStatementAlias production. + ExitSupportedCancelStatementAlias(c *SupportedCancelStatementAliasContext) + + // ExitSupportedRecoverStatementAlias is called when exiting the supportedRecoverStatementAlias production. + ExitSupportedRecoverStatementAlias(c *SupportedRecoverStatementAliasContext) + + // ExitSupportedAdminStatementAlias is called when exiting the supportedAdminStatementAlias production. + ExitSupportedAdminStatementAlias(c *SupportedAdminStatementAliasContext) + + // ExitSupportedUseStatementAlias is called when exiting the supportedUseStatementAlias production. + ExitSupportedUseStatementAlias(c *SupportedUseStatementAliasContext) + + // ExitSupportedOtherStatementAlias is called when exiting the supportedOtherStatementAlias production. + ExitSupportedOtherStatementAlias(c *SupportedOtherStatementAliasContext) + + // ExitSupportedKillStatementAlias is called when exiting the supportedKillStatementAlias production. + ExitSupportedKillStatementAlias(c *SupportedKillStatementAliasContext) + + // ExitSupportedStatsStatementAlias is called when exiting the supportedStatsStatementAlias production. + ExitSupportedStatsStatementAlias(c *SupportedStatsStatementAliasContext) + + // ExitSupportedTransactionStatementAlias is called when exiting the supportedTransactionStatementAlias production. + ExitSupportedTransactionStatementAlias(c *SupportedTransactionStatementAliasContext) + + // ExitSupportedGrantRevokeStatementAlias is called when exiting the supportedGrantRevokeStatementAlias production. + ExitSupportedGrantRevokeStatementAlias(c *SupportedGrantRevokeStatementAliasContext) + + // ExitCreateMTMV is called when exiting the createMTMV production. + ExitCreateMTMV(c *CreateMTMVContext) + + // ExitRefreshMTMV is called when exiting the refreshMTMV production. + ExitRefreshMTMV(c *RefreshMTMVContext) + + // ExitAlterMTMV is called when exiting the alterMTMV production. + ExitAlterMTMV(c *AlterMTMVContext) + + // ExitDropMV is called when exiting the dropMV production. + ExitDropMV(c *DropMVContext) + + // ExitPauseMTMV is called when exiting the pauseMTMV production. + ExitPauseMTMV(c *PauseMTMVContext) + + // ExitResumeMTMV is called when exiting the resumeMTMV production. + ExitResumeMTMV(c *ResumeMTMVContext) + + // ExitCancelMTMVTask is called when exiting the cancelMTMVTask production. + ExitCancelMTMVTask(c *CancelMTMVTaskContext) + + // ExitShowCreateMTMV is called when exiting the showCreateMTMV production. + ExitShowCreateMTMV(c *ShowCreateMTMVContext) + + // ExitCreateScheduledJob is called when exiting the createScheduledJob production. + ExitCreateScheduledJob(c *CreateScheduledJobContext) + + // ExitPauseJob is called when exiting the pauseJob production. + ExitPauseJob(c *PauseJobContext) + + // ExitAlterJob is called when exiting the alterJob production. + ExitAlterJob(c *AlterJobContext) + + // ExitDropJob is called when exiting the dropJob production. + ExitDropJob(c *DropJobContext) + + // ExitResumeJob is called when exiting the resumeJob production. + ExitResumeJob(c *ResumeJobContext) + + // ExitCancelJobTask is called when exiting the cancelJobTask production. + ExitCancelJobTask(c *CancelJobTaskContext) + + // ExitAddConstraint is called when exiting the addConstraint production. + ExitAddConstraint(c *AddConstraintContext) + + // ExitDropConstraint is called when exiting the dropConstraint production. + ExitDropConstraint(c *DropConstraintContext) + + // ExitShowConstraint is called when exiting the showConstraint production. + ExitShowConstraint(c *ShowConstraintContext) + + // ExitOptSpecBranch is called when exiting the optSpecBranch production. + ExitOptSpecBranch(c *OptSpecBranchContext) + + // ExitInsertTable is called when exiting the insertTable production. + ExitInsertTable(c *InsertTableContext) + + // ExitUpdate is called when exiting the update production. + ExitUpdate(c *UpdateContext) + + // ExitDelete is called when exiting the delete production. + ExitDelete(c *DeleteContext) + + // ExitMergeInto is called when exiting the mergeInto production. + ExitMergeInto(c *MergeIntoContext) + + // ExitLoad is called when exiting the load production. + ExitLoad(c *LoadContext) + + // ExitExport is called when exiting the export production. + ExitExport(c *ExportContext) + + // ExitReplay is called when exiting the replay production. + ExitReplay(c *ReplayContext) + + // ExitCopyInto is called when exiting the copyInto production. + ExitCopyInto(c *CopyIntoContext) + + // ExitTruncateTable is called when exiting the truncateTable production. + ExitTruncateTable(c *TruncateTableContext) + + // ExitMergeMatchedClause is called when exiting the mergeMatchedClause production. + ExitMergeMatchedClause(c *MergeMatchedClauseContext) + + // ExitMergeNotMatchedClause is called when exiting the mergeNotMatchedClause production. + ExitMergeNotMatchedClause(c *MergeNotMatchedClauseContext) + + // ExitCreateTable is called when exiting the createTable production. + ExitCreateTable(c *CreateTableContext) + + // ExitCreateView is called when exiting the createView production. + ExitCreateView(c *CreateViewContext) + + // ExitCreateFile is called when exiting the createFile production. + ExitCreateFile(c *CreateFileContext) + + // ExitCreateTableLike is called when exiting the createTableLike production. + ExitCreateTableLike(c *CreateTableLikeContext) + + // ExitCreateRole is called when exiting the createRole production. + ExitCreateRole(c *CreateRoleContext) + + // ExitCreateWorkloadGroup is called when exiting the createWorkloadGroup production. + ExitCreateWorkloadGroup(c *CreateWorkloadGroupContext) + + // ExitCreateCatalog is called when exiting the createCatalog production. + ExitCreateCatalog(c *CreateCatalogContext) + + // ExitCreateRowPolicy is called when exiting the createRowPolicy production. + ExitCreateRowPolicy(c *CreateRowPolicyContext) + + // ExitCreateStoragePolicy is called when exiting the createStoragePolicy production. + ExitCreateStoragePolicy(c *CreateStoragePolicyContext) + + // ExitBuildIndex is called when exiting the buildIndex production. + ExitBuildIndex(c *BuildIndexContext) + + // ExitCreateIndex is called when exiting the createIndex production. + ExitCreateIndex(c *CreateIndexContext) + + // ExitCreateWorkloadPolicy is called when exiting the createWorkloadPolicy production. + ExitCreateWorkloadPolicy(c *CreateWorkloadPolicyContext) + + // ExitCreateSqlBlockRule is called when exiting the createSqlBlockRule production. + ExitCreateSqlBlockRule(c *CreateSqlBlockRuleContext) + + // ExitCreateEncryptkey is called when exiting the createEncryptkey production. + ExitCreateEncryptkey(c *CreateEncryptkeyContext) + + // ExitCreateUserDefineFunction is called when exiting the createUserDefineFunction production. + ExitCreateUserDefineFunction(c *CreateUserDefineFunctionContext) + + // ExitCreateAliasFunction is called when exiting the createAliasFunction production. + ExitCreateAliasFunction(c *CreateAliasFunctionContext) + + // ExitCreateUser is called when exiting the createUser production. + ExitCreateUser(c *CreateUserContext) + + // ExitCreateDatabase is called when exiting the createDatabase production. + ExitCreateDatabase(c *CreateDatabaseContext) + + // ExitCreateRepository is called when exiting the createRepository production. + ExitCreateRepository(c *CreateRepositoryContext) + + // ExitCreateResource is called when exiting the createResource production. + ExitCreateResource(c *CreateResourceContext) + + // ExitCreateDictionary is called when exiting the createDictionary production. + ExitCreateDictionary(c *CreateDictionaryContext) + + // ExitCreateStage is called when exiting the createStage production. + ExitCreateStage(c *CreateStageContext) + + // ExitCreateStorageVault is called when exiting the createStorageVault production. + ExitCreateStorageVault(c *CreateStorageVaultContext) + + // ExitCreateIndexAnalyzer is called when exiting the createIndexAnalyzer production. + ExitCreateIndexAnalyzer(c *CreateIndexAnalyzerContext) + + // ExitCreateIndexTokenizer is called when exiting the createIndexTokenizer production. + ExitCreateIndexTokenizer(c *CreateIndexTokenizerContext) + + // ExitCreateIndexTokenFilter is called when exiting the createIndexTokenFilter production. + ExitCreateIndexTokenFilter(c *CreateIndexTokenFilterContext) + + // ExitCreateIndexCharFilter is called when exiting the createIndexCharFilter production. + ExitCreateIndexCharFilter(c *CreateIndexCharFilterContext) + + // ExitDictionaryColumnDefs is called when exiting the dictionaryColumnDefs production. + ExitDictionaryColumnDefs(c *DictionaryColumnDefsContext) + + // ExitDictionaryColumnDef is called when exiting the dictionaryColumnDef production. + ExitDictionaryColumnDef(c *DictionaryColumnDefContext) + + // ExitAlterSystem is called when exiting the alterSystem production. + ExitAlterSystem(c *AlterSystemContext) + + // ExitAlterView is called when exiting the alterView production. + ExitAlterView(c *AlterViewContext) + + // ExitAlterCatalogRename is called when exiting the alterCatalogRename production. + ExitAlterCatalogRename(c *AlterCatalogRenameContext) + + // ExitAlterRole is called when exiting the alterRole production. + ExitAlterRole(c *AlterRoleContext) + + // ExitAlterStorageVault is called when exiting the alterStorageVault production. + ExitAlterStorageVault(c *AlterStorageVaultContext) + + // ExitAlterWorkloadGroup is called when exiting the alterWorkloadGroup production. + ExitAlterWorkloadGroup(c *AlterWorkloadGroupContext) + + // ExitAlterComputeGroup is called when exiting the alterComputeGroup production. + ExitAlterComputeGroup(c *AlterComputeGroupContext) + + // ExitAlterCatalogProperties is called when exiting the alterCatalogProperties production. + ExitAlterCatalogProperties(c *AlterCatalogPropertiesContext) + + // ExitAlterWorkloadPolicy is called when exiting the alterWorkloadPolicy production. + ExitAlterWorkloadPolicy(c *AlterWorkloadPolicyContext) + + // ExitAlterSqlBlockRule is called when exiting the alterSqlBlockRule production. + ExitAlterSqlBlockRule(c *AlterSqlBlockRuleContext) + + // ExitAlterCatalogComment is called when exiting the alterCatalogComment production. + ExitAlterCatalogComment(c *AlterCatalogCommentContext) + + // ExitAlterDatabaseRename is called when exiting the alterDatabaseRename production. + ExitAlterDatabaseRename(c *AlterDatabaseRenameContext) + + // ExitAlterStoragePolicy is called when exiting the alterStoragePolicy production. + ExitAlterStoragePolicy(c *AlterStoragePolicyContext) + + // ExitAlterTable is called when exiting the alterTable production. + ExitAlterTable(c *AlterTableContext) + + // ExitAlterTableExecute is called when exiting the alterTableExecute production. + ExitAlterTableExecute(c *AlterTableExecuteContext) + + // ExitAlterTableAddRollup is called when exiting the alterTableAddRollup production. + ExitAlterTableAddRollup(c *AlterTableAddRollupContext) + + // ExitAlterTableDropRollup is called when exiting the alterTableDropRollup production. + ExitAlterTableDropRollup(c *AlterTableDropRollupContext) + + // ExitAlterTableProperties is called when exiting the alterTableProperties production. + ExitAlterTableProperties(c *AlterTablePropertiesContext) + + // ExitAlterDatabaseSetQuota is called when exiting the alterDatabaseSetQuota production. + ExitAlterDatabaseSetQuota(c *AlterDatabaseSetQuotaContext) + + // ExitAlterDatabaseProperties is called when exiting the alterDatabaseProperties production. + ExitAlterDatabaseProperties(c *AlterDatabasePropertiesContext) + + // ExitAlterSystemRenameComputeGroup is called when exiting the alterSystemRenameComputeGroup production. + ExitAlterSystemRenameComputeGroup(c *AlterSystemRenameComputeGroupContext) + + // ExitAlterResource is called when exiting the alterResource production. + ExitAlterResource(c *AlterResourceContext) + + // ExitAlterRepository is called when exiting the alterRepository production. + ExitAlterRepository(c *AlterRepositoryContext) + + // ExitAlterRoutineLoad is called when exiting the alterRoutineLoad production. + ExitAlterRoutineLoad(c *AlterRoutineLoadContext) + + // ExitAlterColocateGroup is called when exiting the alterColocateGroup production. + ExitAlterColocateGroup(c *AlterColocateGroupContext) + + // ExitAlterUser is called when exiting the alterUser production. + ExitAlterUser(c *AlterUserContext) + + // ExitDropCatalogRecycleBin is called when exiting the dropCatalogRecycleBin production. + ExitDropCatalogRecycleBin(c *DropCatalogRecycleBinContext) + + // ExitDropEncryptkey is called when exiting the dropEncryptkey production. + ExitDropEncryptkey(c *DropEncryptkeyContext) + + // ExitDropRole is called when exiting the dropRole production. + ExitDropRole(c *DropRoleContext) + + // ExitDropSqlBlockRule is called when exiting the dropSqlBlockRule production. + ExitDropSqlBlockRule(c *DropSqlBlockRuleContext) + + // ExitDropUser is called when exiting the dropUser production. + ExitDropUser(c *DropUserContext) + + // ExitDropStoragePolicy is called when exiting the dropStoragePolicy production. + ExitDropStoragePolicy(c *DropStoragePolicyContext) + + // ExitDropWorkloadGroup is called when exiting the dropWorkloadGroup production. + ExitDropWorkloadGroup(c *DropWorkloadGroupContext) + + // ExitDropCatalog is called when exiting the dropCatalog production. + ExitDropCatalog(c *DropCatalogContext) + + // ExitDropFile is called when exiting the dropFile production. + ExitDropFile(c *DropFileContext) + + // ExitDropWorkloadPolicy is called when exiting the dropWorkloadPolicy production. + ExitDropWorkloadPolicy(c *DropWorkloadPolicyContext) + + // ExitDropRepository is called when exiting the dropRepository production. + ExitDropRepository(c *DropRepositoryContext) + + // ExitDropTable is called when exiting the dropTable production. + ExitDropTable(c *DropTableContext) + + // ExitDropDatabase is called when exiting the dropDatabase production. + ExitDropDatabase(c *DropDatabaseContext) + + // ExitDropFunction is called when exiting the dropFunction production. + ExitDropFunction(c *DropFunctionContext) + + // ExitDropIndex is called when exiting the dropIndex production. + ExitDropIndex(c *DropIndexContext) + + // ExitDropResource is called when exiting the dropResource production. + ExitDropResource(c *DropResourceContext) + + // ExitDropRowPolicy is called when exiting the dropRowPolicy production. + ExitDropRowPolicy(c *DropRowPolicyContext) + + // ExitDropDictionary is called when exiting the dropDictionary production. + ExitDropDictionary(c *DropDictionaryContext) + + // ExitDropStage is called when exiting the dropStage production. + ExitDropStage(c *DropStageContext) + + // ExitDropView is called when exiting the dropView production. + ExitDropView(c *DropViewContext) + + // ExitDropIndexAnalyzer is called when exiting the dropIndexAnalyzer production. + ExitDropIndexAnalyzer(c *DropIndexAnalyzerContext) + + // ExitDropIndexTokenizer is called when exiting the dropIndexTokenizer production. + ExitDropIndexTokenizer(c *DropIndexTokenizerContext) + + // ExitDropIndexTokenFilter is called when exiting the dropIndexTokenFilter production. + ExitDropIndexTokenFilter(c *DropIndexTokenFilterContext) + + // ExitDropIndexCharFilter is called when exiting the dropIndexCharFilter production. + ExitDropIndexCharFilter(c *DropIndexCharFilterContext) + + // ExitShowVariables is called when exiting the showVariables production. + ExitShowVariables(c *ShowVariablesContext) + + // ExitShowAuthors is called when exiting the showAuthors production. + ExitShowAuthors(c *ShowAuthorsContext) + + // ExitShowAlterTable is called when exiting the showAlterTable production. + ExitShowAlterTable(c *ShowAlterTableContext) + + // ExitShowCreateDatabase is called when exiting the showCreateDatabase production. + ExitShowCreateDatabase(c *ShowCreateDatabaseContext) + + // ExitShowBackup is called when exiting the showBackup production. + ExitShowBackup(c *ShowBackupContext) + + // ExitShowBroker is called when exiting the showBroker production. + ExitShowBroker(c *ShowBrokerContext) + + // ExitShowBuildIndex is called when exiting the showBuildIndex production. + ExitShowBuildIndex(c *ShowBuildIndexContext) + + // ExitShowDynamicPartition is called when exiting the showDynamicPartition production. + ExitShowDynamicPartition(c *ShowDynamicPartitionContext) + + // ExitShowEvents is called when exiting the showEvents production. + ExitShowEvents(c *ShowEventsContext) + + // ExitShowExport is called when exiting the showExport production. + ExitShowExport(c *ShowExportContext) + + // ExitShowLastInsert is called when exiting the showLastInsert production. + ExitShowLastInsert(c *ShowLastInsertContext) + + // ExitShowCharset is called when exiting the showCharset production. + ExitShowCharset(c *ShowCharsetContext) + + // ExitShowDelete is called when exiting the showDelete production. + ExitShowDelete(c *ShowDeleteContext) + + // ExitShowCreateFunction is called when exiting the showCreateFunction production. + ExitShowCreateFunction(c *ShowCreateFunctionContext) + + // ExitShowFunctions is called when exiting the showFunctions production. + ExitShowFunctions(c *ShowFunctionsContext) + + // ExitShowGlobalFunctions is called when exiting the showGlobalFunctions production. + ExitShowGlobalFunctions(c *ShowGlobalFunctionsContext) + + // ExitShowGrants is called when exiting the showGrants production. + ExitShowGrants(c *ShowGrantsContext) + + // ExitShowGrantsForUser is called when exiting the showGrantsForUser production. + ExitShowGrantsForUser(c *ShowGrantsForUserContext) + + // ExitShowCreateUser is called when exiting the showCreateUser production. + ExitShowCreateUser(c *ShowCreateUserContext) + + // ExitShowSnapshot is called when exiting the showSnapshot production. + ExitShowSnapshot(c *ShowSnapshotContext) + + // ExitShowLoadProfile is called when exiting the showLoadProfile production. + ExitShowLoadProfile(c *ShowLoadProfileContext) + + // ExitShowCreateRepository is called when exiting the showCreateRepository production. + ExitShowCreateRepository(c *ShowCreateRepositoryContext) + + // ExitShowView is called when exiting the showView production. + ExitShowView(c *ShowViewContext) + + // ExitShowPlugins is called when exiting the showPlugins production. + ExitShowPlugins(c *ShowPluginsContext) + + // ExitShowStorageVault is called when exiting the showStorageVault production. + ExitShowStorageVault(c *ShowStorageVaultContext) + + // ExitShowRepositories is called when exiting the showRepositories production. + ExitShowRepositories(c *ShowRepositoriesContext) + + // ExitShowEncryptKeys is called when exiting the showEncryptKeys production. + ExitShowEncryptKeys(c *ShowEncryptKeysContext) + + // ExitShowCreateTable is called when exiting the showCreateTable production. + ExitShowCreateTable(c *ShowCreateTableContext) + + // ExitShowProcessList is called when exiting the showProcessList production. + ExitShowProcessList(c *ShowProcessListContext) + + // ExitShowPartitions is called when exiting the showPartitions production. + ExitShowPartitions(c *ShowPartitionsContext) + + // ExitShowRestore is called when exiting the showRestore production. + ExitShowRestore(c *ShowRestoreContext) + + // ExitShowRoles is called when exiting the showRoles production. + ExitShowRoles(c *ShowRolesContext) + + // ExitShowPartitionId is called when exiting the showPartitionId production. + ExitShowPartitionId(c *ShowPartitionIdContext) + + // ExitShowPrivileges is called when exiting the showPrivileges production. + ExitShowPrivileges(c *ShowPrivilegesContext) + + // ExitShowProc is called when exiting the showProc production. + ExitShowProc(c *ShowProcContext) + + // ExitShowSmallFiles is called when exiting the showSmallFiles production. + ExitShowSmallFiles(c *ShowSmallFilesContext) + + // ExitShowStorageEngines is called when exiting the showStorageEngines production. + ExitShowStorageEngines(c *ShowStorageEnginesContext) + + // ExitShowCreateCatalog is called when exiting the showCreateCatalog production. + ExitShowCreateCatalog(c *ShowCreateCatalogContext) + + // ExitShowCatalog is called when exiting the showCatalog production. + ExitShowCatalog(c *ShowCatalogContext) + + // ExitShowCatalogs is called when exiting the showCatalogs production. + ExitShowCatalogs(c *ShowCatalogsContext) + + // ExitShowUserProperties is called when exiting the showUserProperties production. + ExitShowUserProperties(c *ShowUserPropertiesContext) + + // ExitShowAllProperties is called when exiting the showAllProperties production. + ExitShowAllProperties(c *ShowAllPropertiesContext) + + // ExitShowCollation is called when exiting the showCollation production. + ExitShowCollation(c *ShowCollationContext) + + // ExitShowRowPolicy is called when exiting the showRowPolicy production. + ExitShowRowPolicy(c *ShowRowPolicyContext) + + // ExitShowStoragePolicy is called when exiting the showStoragePolicy production. + ExitShowStoragePolicy(c *ShowStoragePolicyContext) + + // ExitShowSqlBlockRule is called when exiting the showSqlBlockRule production. + ExitShowSqlBlockRule(c *ShowSqlBlockRuleContext) + + // ExitShowCreateView is called when exiting the showCreateView production. + ExitShowCreateView(c *ShowCreateViewContext) + + // ExitShowCreateStorageVault is called when exiting the showCreateStorageVault production. + ExitShowCreateStorageVault(c *ShowCreateStorageVaultContext) + + // ExitShowDataTypes is called when exiting the showDataTypes production. + ExitShowDataTypes(c *ShowDataTypesContext) + + // ExitShowData is called when exiting the showData production. + ExitShowData(c *ShowDataContext) + + // ExitShowCreateMaterializedView is called when exiting the showCreateMaterializedView production. + ExitShowCreateMaterializedView(c *ShowCreateMaterializedViewContext) + + // ExitShowWarningErrors is called when exiting the showWarningErrors production. + ExitShowWarningErrors(c *ShowWarningErrorsContext) + + // ExitShowWarningErrorCount is called when exiting the showWarningErrorCount production. + ExitShowWarningErrorCount(c *ShowWarningErrorCountContext) + + // ExitShowBackends is called when exiting the showBackends production. + ExitShowBackends(c *ShowBackendsContext) + + // ExitShowStages is called when exiting the showStages production. + ExitShowStages(c *ShowStagesContext) + + // ExitShowReplicaDistribution is called when exiting the showReplicaDistribution production. + ExitShowReplicaDistribution(c *ShowReplicaDistributionContext) + + // ExitShowResources is called when exiting the showResources production. + ExitShowResources(c *ShowResourcesContext) + + // ExitShowLoad is called when exiting the showLoad production. + ExitShowLoad(c *ShowLoadContext) + + // ExitShowLoadWarings is called when exiting the showLoadWarings production. + ExitShowLoadWarings(c *ShowLoadWaringsContext) + + // ExitShowTriggers is called when exiting the showTriggers production. + ExitShowTriggers(c *ShowTriggersContext) + + // ExitShowDiagnoseTablet is called when exiting the showDiagnoseTablet production. + ExitShowDiagnoseTablet(c *ShowDiagnoseTabletContext) + + // ExitShowOpenTables is called when exiting the showOpenTables production. + ExitShowOpenTables(c *ShowOpenTablesContext) + + // ExitShowFrontends is called when exiting the showFrontends production. + ExitShowFrontends(c *ShowFrontendsContext) + + // ExitShowDatabaseId is called when exiting the showDatabaseId production. + ExitShowDatabaseId(c *ShowDatabaseIdContext) + + // ExitShowColumns is called when exiting the showColumns production. + ExitShowColumns(c *ShowColumnsContext) + + // ExitShowTableId is called when exiting the showTableId production. + ExitShowTableId(c *ShowTableIdContext) + + // ExitShowTrash is called when exiting the showTrash production. + ExitShowTrash(c *ShowTrashContext) + + // ExitShowTypeCast is called when exiting the showTypeCast production. + ExitShowTypeCast(c *ShowTypeCastContext) + + // ExitShowClusters is called when exiting the showClusters production. + ExitShowClusters(c *ShowClustersContext) + + // ExitShowStatus is called when exiting the showStatus production. + ExitShowStatus(c *ShowStatusContext) + + // ExitShowWhitelist is called when exiting the showWhitelist production. + ExitShowWhitelist(c *ShowWhitelistContext) + + // ExitShowTabletsBelong is called when exiting the showTabletsBelong production. + ExitShowTabletsBelong(c *ShowTabletsBelongContext) + + // ExitShowDataSkew is called when exiting the showDataSkew production. + ExitShowDataSkew(c *ShowDataSkewContext) + + // ExitShowTableCreation is called when exiting the showTableCreation production. + ExitShowTableCreation(c *ShowTableCreationContext) + + // ExitShowTabletStorageFormat is called when exiting the showTabletStorageFormat production. + ExitShowTabletStorageFormat(c *ShowTabletStorageFormatContext) + + // ExitShowQueryProfile is called when exiting the showQueryProfile production. + ExitShowQueryProfile(c *ShowQueryProfileContext) + + // ExitShowConvertLsc is called when exiting the showConvertLsc production. + ExitShowConvertLsc(c *ShowConvertLscContext) + + // ExitShowTables is called when exiting the showTables production. + ExitShowTables(c *ShowTablesContext) + + // ExitShowViews is called when exiting the showViews production. + ExitShowViews(c *ShowViewsContext) + + // ExitShowTableStatus is called when exiting the showTableStatus production. + ExitShowTableStatus(c *ShowTableStatusContext) + + // ExitShowDatabases is called when exiting the showDatabases production. + ExitShowDatabases(c *ShowDatabasesContext) + + // ExitShowTabletsFromTable is called when exiting the showTabletsFromTable production. + ExitShowTabletsFromTable(c *ShowTabletsFromTableContext) + + // ExitShowCatalogRecycleBin is called when exiting the showCatalogRecycleBin production. + ExitShowCatalogRecycleBin(c *ShowCatalogRecycleBinContext) + + // ExitShowTabletId is called when exiting the showTabletId production. + ExitShowTabletId(c *ShowTabletIdContext) + + // ExitShowDictionaries is called when exiting the showDictionaries production. + ExitShowDictionaries(c *ShowDictionariesContext) + + // ExitShowTransaction is called when exiting the showTransaction production. + ExitShowTransaction(c *ShowTransactionContext) + + // ExitShowReplicaStatus is called when exiting the showReplicaStatus production. + ExitShowReplicaStatus(c *ShowReplicaStatusContext) + + // ExitShowWorkloadGroups is called when exiting the showWorkloadGroups production. + ExitShowWorkloadGroups(c *ShowWorkloadGroupsContext) + + // ExitShowCopy is called when exiting the showCopy production. + ExitShowCopy(c *ShowCopyContext) + + // ExitShowQueryStats is called when exiting the showQueryStats production. + ExitShowQueryStats(c *ShowQueryStatsContext) + + // ExitShowIndex is called when exiting the showIndex production. + ExitShowIndex(c *ShowIndexContext) + + // ExitShowWarmUpJob is called when exiting the showWarmUpJob production. + ExitShowWarmUpJob(c *ShowWarmUpJobContext) + + // ExitSync is called when exiting the sync production. + ExitSync(c *SyncContext) + + // ExitShowCreateLoad is called when exiting the showCreateLoad production. + ExitShowCreateLoad(c *ShowCreateLoadContext) + + // ExitCreateRoutineLoadAlias is called when exiting the createRoutineLoadAlias production. + ExitCreateRoutineLoadAlias(c *CreateRoutineLoadAliasContext) + + // ExitMysqlLoad is called when exiting the mysqlLoad production. + ExitMysqlLoad(c *MysqlLoadContext) + + // ExitShowCreateRoutineLoad is called when exiting the showCreateRoutineLoad production. + ExitShowCreateRoutineLoad(c *ShowCreateRoutineLoadContext) + + // ExitPauseRoutineLoad is called when exiting the pauseRoutineLoad production. + ExitPauseRoutineLoad(c *PauseRoutineLoadContext) + + // ExitPauseAllRoutineLoad is called when exiting the pauseAllRoutineLoad production. + ExitPauseAllRoutineLoad(c *PauseAllRoutineLoadContext) + + // ExitResumeRoutineLoad is called when exiting the resumeRoutineLoad production. + ExitResumeRoutineLoad(c *ResumeRoutineLoadContext) + + // ExitResumeAllRoutineLoad is called when exiting the resumeAllRoutineLoad production. + ExitResumeAllRoutineLoad(c *ResumeAllRoutineLoadContext) + + // ExitStopRoutineLoad is called when exiting the stopRoutineLoad production. + ExitStopRoutineLoad(c *StopRoutineLoadContext) + + // ExitShowRoutineLoad is called when exiting the showRoutineLoad production. + ExitShowRoutineLoad(c *ShowRoutineLoadContext) + + // ExitShowRoutineLoadTask is called when exiting the showRoutineLoadTask production. + ExitShowRoutineLoadTask(c *ShowRoutineLoadTaskContext) + + // ExitShowIndexAnalyzer is called when exiting the showIndexAnalyzer production. + ExitShowIndexAnalyzer(c *ShowIndexAnalyzerContext) + + // ExitShowIndexTokenizer is called when exiting the showIndexTokenizer production. + ExitShowIndexTokenizer(c *ShowIndexTokenizerContext) + + // ExitShowIndexTokenFilter is called when exiting the showIndexTokenFilter production. + ExitShowIndexTokenFilter(c *ShowIndexTokenFilterContext) + + // ExitShowIndexCharFilter is called when exiting the showIndexCharFilter production. + ExitShowIndexCharFilter(c *ShowIndexCharFilterContext) + + // ExitKillConnection is called when exiting the killConnection production. + ExitKillConnection(c *KillConnectionContext) + + // ExitKillQuery is called when exiting the killQuery production. + ExitKillQuery(c *KillQueryContext) + + // ExitHelp is called when exiting the help production. + ExitHelp(c *HelpContext) + + // ExitUnlockTables is called when exiting the unlockTables production. + ExitUnlockTables(c *UnlockTablesContext) + + // ExitInstallPlugin is called when exiting the installPlugin production. + ExitInstallPlugin(c *InstallPluginContext) + + // ExitUninstallPlugin is called when exiting the uninstallPlugin production. + ExitUninstallPlugin(c *UninstallPluginContext) + + // ExitLockTables is called when exiting the lockTables production. + ExitLockTables(c *LockTablesContext) + + // ExitRestore is called when exiting the restore production. + ExitRestore(c *RestoreContext) + + // ExitWarmUpCluster is called when exiting the warmUpCluster production. + ExitWarmUpCluster(c *WarmUpClusterContext) + + // ExitWarmUpSelect is called when exiting the warmUpSelect production. + ExitWarmUpSelect(c *WarmUpSelectContext) + + // ExitBackup is called when exiting the backup production. + ExitBackup(c *BackupContext) + + // ExitUnsupportedStartTransaction is called when exiting the unsupportedStartTransaction production. + ExitUnsupportedStartTransaction(c *UnsupportedStartTransactionContext) + + // ExitWarmUpItem is called when exiting the warmUpItem production. + ExitWarmUpItem(c *WarmUpItemContext) + + // ExitWarmUpSingleTableRef is called when exiting the warmUpSingleTableRef production. + ExitWarmUpSingleTableRef(c *WarmUpSingleTableRefContext) + + // ExitLockTable is called when exiting the lockTable production. + ExitLockTable(c *LockTableContext) + + // ExitCreateRoutineLoad is called when exiting the createRoutineLoad production. + ExitCreateRoutineLoad(c *CreateRoutineLoadContext) + + // ExitSeparator is called when exiting the separator production. + ExitSeparator(c *SeparatorContext) + + // ExitImportColumns is called when exiting the importColumns production. + ExitImportColumns(c *ImportColumnsContext) + + // ExitImportPrecedingFilter is called when exiting the importPrecedingFilter production. + ExitImportPrecedingFilter(c *ImportPrecedingFilterContext) + + // ExitImportWhere is called when exiting the importWhere production. + ExitImportWhere(c *ImportWhereContext) + + // ExitImportDeleteOn is called when exiting the importDeleteOn production. + ExitImportDeleteOn(c *ImportDeleteOnContext) + + // ExitImportSequence is called when exiting the importSequence production. + ExitImportSequence(c *ImportSequenceContext) + + // ExitImportPartitions is called when exiting the importPartitions production. + ExitImportPartitions(c *ImportPartitionsContext) + + // ExitImportSequenceStatement is called when exiting the importSequenceStatement production. + ExitImportSequenceStatement(c *ImportSequenceStatementContext) + + // ExitImportDeleteOnStatement is called when exiting the importDeleteOnStatement production. + ExitImportDeleteOnStatement(c *ImportDeleteOnStatementContext) + + // ExitImportWhereStatement is called when exiting the importWhereStatement production. + ExitImportWhereStatement(c *ImportWhereStatementContext) + + // ExitImportPrecedingFilterStatement is called when exiting the importPrecedingFilterStatement production. + ExitImportPrecedingFilterStatement(c *ImportPrecedingFilterStatementContext) + + // ExitImportColumnsStatement is called when exiting the importColumnsStatement production. + ExitImportColumnsStatement(c *ImportColumnsStatementContext) + + // ExitImportColumnDesc is called when exiting the importColumnDesc production. + ExitImportColumnDesc(c *ImportColumnDescContext) + + // ExitRefreshCatalog is called when exiting the refreshCatalog production. + ExitRefreshCatalog(c *RefreshCatalogContext) + + // ExitRefreshDatabase is called when exiting the refreshDatabase production. + ExitRefreshDatabase(c *RefreshDatabaseContext) + + // ExitRefreshTable is called when exiting the refreshTable production. + ExitRefreshTable(c *RefreshTableContext) + + // ExitRefreshDictionary is called when exiting the refreshDictionary production. + ExitRefreshDictionary(c *RefreshDictionaryContext) + + // ExitRefreshLdap is called when exiting the refreshLdap production. + ExitRefreshLdap(c *RefreshLdapContext) + + // ExitCleanAllProfile is called when exiting the cleanAllProfile production. + ExitCleanAllProfile(c *CleanAllProfileContext) + + // ExitCleanLabel is called when exiting the cleanLabel production. + ExitCleanLabel(c *CleanLabelContext) + + // ExitCleanQueryStats is called when exiting the cleanQueryStats production. + ExitCleanQueryStats(c *CleanQueryStatsContext) + + // ExitCleanAllQueryStats is called when exiting the cleanAllQueryStats production. + ExitCleanAllQueryStats(c *CleanAllQueryStatsContext) + + // ExitCancelLoad is called when exiting the cancelLoad production. + ExitCancelLoad(c *CancelLoadContext) + + // ExitCancelExport is called when exiting the cancelExport production. + ExitCancelExport(c *CancelExportContext) + + // ExitCancelWarmUpJob is called when exiting the cancelWarmUpJob production. + ExitCancelWarmUpJob(c *CancelWarmUpJobContext) + + // ExitCancelDecommisionBackend is called when exiting the cancelDecommisionBackend production. + ExitCancelDecommisionBackend(c *CancelDecommisionBackendContext) + + // ExitCancelBackup is called when exiting the cancelBackup production. + ExitCancelBackup(c *CancelBackupContext) + + // ExitCancelRestore is called when exiting the cancelRestore production. + ExitCancelRestore(c *CancelRestoreContext) + + // ExitCancelBuildIndex is called when exiting the cancelBuildIndex production. + ExitCancelBuildIndex(c *CancelBuildIndexContext) + + // ExitCancelAlterTable is called when exiting the cancelAlterTable production. + ExitCancelAlterTable(c *CancelAlterTableContext) + + // ExitAdminShowReplicaDistribution is called when exiting the adminShowReplicaDistribution production. + ExitAdminShowReplicaDistribution(c *AdminShowReplicaDistributionContext) + + // ExitAdminRebalanceDisk is called when exiting the adminRebalanceDisk production. + ExitAdminRebalanceDisk(c *AdminRebalanceDiskContext) + + // ExitAdminCancelRebalanceDisk is called when exiting the adminCancelRebalanceDisk production. + ExitAdminCancelRebalanceDisk(c *AdminCancelRebalanceDiskContext) + + // ExitAdminDiagnoseTablet is called when exiting the adminDiagnoseTablet production. + ExitAdminDiagnoseTablet(c *AdminDiagnoseTabletContext) + + // ExitAdminShowReplicaStatus is called when exiting the adminShowReplicaStatus production. + ExitAdminShowReplicaStatus(c *AdminShowReplicaStatusContext) + + // ExitAdminCompactTable is called when exiting the adminCompactTable production. + ExitAdminCompactTable(c *AdminCompactTableContext) + + // ExitAdminCheckTablets is called when exiting the adminCheckTablets production. + ExitAdminCheckTablets(c *AdminCheckTabletsContext) + + // ExitAdminShowTabletStorageFormat is called when exiting the adminShowTabletStorageFormat production. + ExitAdminShowTabletStorageFormat(c *AdminShowTabletStorageFormatContext) + + // ExitAdminSetFrontendConfig is called when exiting the adminSetFrontendConfig production. + ExitAdminSetFrontendConfig(c *AdminSetFrontendConfigContext) + + // ExitAdminCleanTrash is called when exiting the adminCleanTrash production. + ExitAdminCleanTrash(c *AdminCleanTrashContext) + + // ExitAdminSetReplicaVersion is called when exiting the adminSetReplicaVersion production. + ExitAdminSetReplicaVersion(c *AdminSetReplicaVersionContext) + + // ExitAdminSetTableStatus is called when exiting the adminSetTableStatus production. + ExitAdminSetTableStatus(c *AdminSetTableStatusContext) + + // ExitAdminSetReplicaStatus is called when exiting the adminSetReplicaStatus production. + ExitAdminSetReplicaStatus(c *AdminSetReplicaStatusContext) + + // ExitAdminRepairTable is called when exiting the adminRepairTable production. + ExitAdminRepairTable(c *AdminRepairTableContext) + + // ExitAdminCancelRepairTable is called when exiting the adminCancelRepairTable production. + ExitAdminCancelRepairTable(c *AdminCancelRepairTableContext) + + // ExitAdminCopyTablet is called when exiting the adminCopyTablet production. + ExitAdminCopyTablet(c *AdminCopyTabletContext) + + // ExitAdminSetEncryptionRootKey is called when exiting the adminSetEncryptionRootKey production. + ExitAdminSetEncryptionRootKey(c *AdminSetEncryptionRootKeyContext) + + // ExitAdminSetPartitionVersion is called when exiting the adminSetPartitionVersion production. + ExitAdminSetPartitionVersion(c *AdminSetPartitionVersionContext) + + // ExitAdminCreateClusterSnapshot is called when exiting the adminCreateClusterSnapshot production. + ExitAdminCreateClusterSnapshot(c *AdminCreateClusterSnapshotContext) + + // ExitAdminSetAutoClusterSnapshot is called when exiting the adminSetAutoClusterSnapshot production. + ExitAdminSetAutoClusterSnapshot(c *AdminSetAutoClusterSnapshotContext) + + // ExitAdminDropClusterSnapshot is called when exiting the adminDropClusterSnapshot production. + ExitAdminDropClusterSnapshot(c *AdminDropClusterSnapshotContext) + + // ExitAdminSetClusterSnapshotFeatureSwitch is called when exiting the adminSetClusterSnapshotFeatureSwitch production. + ExitAdminSetClusterSnapshotFeatureSwitch(c *AdminSetClusterSnapshotFeatureSwitchContext) + + // ExitAdminRotateTdeRootKey is called when exiting the adminRotateTdeRootKey production. + ExitAdminRotateTdeRootKey(c *AdminRotateTdeRootKeyContext) + + // ExitRecoverDatabase is called when exiting the recoverDatabase production. + ExitRecoverDatabase(c *RecoverDatabaseContext) + + // ExitRecoverTable is called when exiting the recoverTable production. + ExitRecoverTable(c *RecoverTableContext) + + // ExitRecoverPartition is called when exiting the recoverPartition production. + ExitRecoverPartition(c *RecoverPartitionContext) + + // ExitBaseTableRef is called when exiting the baseTableRef production. + ExitBaseTableRef(c *BaseTableRefContext) + + // ExitWildWhere is called when exiting the wildWhere production. + ExitWildWhere(c *WildWhereContext) + + // ExitTransactionBegin is called when exiting the transactionBegin production. + ExitTransactionBegin(c *TransactionBeginContext) + + // ExitTranscationCommit is called when exiting the transcationCommit production. + ExitTranscationCommit(c *TranscationCommitContext) + + // ExitTransactionRollback is called when exiting the transactionRollback production. + ExitTransactionRollback(c *TransactionRollbackContext) + + // ExitGrantTablePrivilege is called when exiting the grantTablePrivilege production. + ExitGrantTablePrivilege(c *GrantTablePrivilegeContext) + + // ExitGrantResourcePrivilege is called when exiting the grantResourcePrivilege production. + ExitGrantResourcePrivilege(c *GrantResourcePrivilegeContext) + + // ExitGrantRole is called when exiting the grantRole production. + ExitGrantRole(c *GrantRoleContext) + + // ExitRevokeRole is called when exiting the revokeRole production. + ExitRevokeRole(c *RevokeRoleContext) + + // ExitRevokeResourcePrivilege is called when exiting the revokeResourcePrivilege production. + ExitRevokeResourcePrivilege(c *RevokeResourcePrivilegeContext) + + // ExitRevokeTablePrivilege is called when exiting the revokeTablePrivilege production. + ExitRevokeTablePrivilege(c *RevokeTablePrivilegeContext) + + // ExitPrivilege is called when exiting the privilege production. + ExitPrivilege(c *PrivilegeContext) + + // ExitPrivilegeList is called when exiting the privilegeList production. + ExitPrivilegeList(c *PrivilegeListContext) + + // ExitAddBackendClause is called when exiting the addBackendClause production. + ExitAddBackendClause(c *AddBackendClauseContext) + + // ExitDropBackendClause is called when exiting the dropBackendClause production. + ExitDropBackendClause(c *DropBackendClauseContext) + + // ExitDecommissionBackendClause is called when exiting the decommissionBackendClause production. + ExitDecommissionBackendClause(c *DecommissionBackendClauseContext) + + // ExitAddObserverClause is called when exiting the addObserverClause production. + ExitAddObserverClause(c *AddObserverClauseContext) + + // ExitDropObserverClause is called when exiting the dropObserverClause production. + ExitDropObserverClause(c *DropObserverClauseContext) + + // ExitAddFollowerClause is called when exiting the addFollowerClause production. + ExitAddFollowerClause(c *AddFollowerClauseContext) + + // ExitDropFollowerClause is called when exiting the dropFollowerClause production. + ExitDropFollowerClause(c *DropFollowerClauseContext) + + // ExitAddBrokerClause is called when exiting the addBrokerClause production. + ExitAddBrokerClause(c *AddBrokerClauseContext) + + // ExitDropBrokerClause is called when exiting the dropBrokerClause production. + ExitDropBrokerClause(c *DropBrokerClauseContext) + + // ExitDropAllBrokerClause is called when exiting the dropAllBrokerClause production. + ExitDropAllBrokerClause(c *DropAllBrokerClauseContext) + + // ExitAlterLoadErrorUrlClause is called when exiting the alterLoadErrorUrlClause production. + ExitAlterLoadErrorUrlClause(c *AlterLoadErrorUrlClauseContext) + + // ExitModifyBackendClause is called when exiting the modifyBackendClause production. + ExitModifyBackendClause(c *ModifyBackendClauseContext) + + // ExitModifyFrontendOrBackendHostNameClause is called when exiting the modifyFrontendOrBackendHostNameClause production. + ExitModifyFrontendOrBackendHostNameClause(c *ModifyFrontendOrBackendHostNameClauseContext) + + // ExitDropRollupClause is called when exiting the dropRollupClause production. + ExitDropRollupClause(c *DropRollupClauseContext) + + // ExitAddRollupClause is called when exiting the addRollupClause production. + ExitAddRollupClause(c *AddRollupClauseContext) + + // ExitAddColumnClause is called when exiting the addColumnClause production. + ExitAddColumnClause(c *AddColumnClauseContext) + + // ExitAddColumnsClause is called when exiting the addColumnsClause production. + ExitAddColumnsClause(c *AddColumnsClauseContext) + + // ExitDropColumnClause is called when exiting the dropColumnClause production. + ExitDropColumnClause(c *DropColumnClauseContext) + + // ExitModifyColumnClause is called when exiting the modifyColumnClause production. + ExitModifyColumnClause(c *ModifyColumnClauseContext) + + // ExitReorderColumnsClause is called when exiting the reorderColumnsClause production. + ExitReorderColumnsClause(c *ReorderColumnsClauseContext) + + // ExitAddPartitionClause is called when exiting the addPartitionClause production. + ExitAddPartitionClause(c *AddPartitionClauseContext) + + // ExitDropPartitionClause is called when exiting the dropPartitionClause production. + ExitDropPartitionClause(c *DropPartitionClauseContext) + + // ExitModifyPartitionClause is called when exiting the modifyPartitionClause production. + ExitModifyPartitionClause(c *ModifyPartitionClauseContext) + + // ExitReplacePartitionClause is called when exiting the replacePartitionClause production. + ExitReplacePartitionClause(c *ReplacePartitionClauseContext) + + // ExitReplaceTableClause is called when exiting the replaceTableClause production. + ExitReplaceTableClause(c *ReplaceTableClauseContext) + + // ExitRenameClause is called when exiting the renameClause production. + ExitRenameClause(c *RenameClauseContext) + + // ExitRenameRollupClause is called when exiting the renameRollupClause production. + ExitRenameRollupClause(c *RenameRollupClauseContext) + + // ExitRenamePartitionClause is called when exiting the renamePartitionClause production. + ExitRenamePartitionClause(c *RenamePartitionClauseContext) + + // ExitRenameColumnClause is called when exiting the renameColumnClause production. + ExitRenameColumnClause(c *RenameColumnClauseContext) + + // ExitAddIndexClause is called when exiting the addIndexClause production. + ExitAddIndexClause(c *AddIndexClauseContext) + + // ExitDropIndexClause is called when exiting the dropIndexClause production. + ExitDropIndexClause(c *DropIndexClauseContext) + + // ExitEnableFeatureClause is called when exiting the enableFeatureClause production. + ExitEnableFeatureClause(c *EnableFeatureClauseContext) + + // ExitModifyDistributionClause is called when exiting the modifyDistributionClause production. + ExitModifyDistributionClause(c *ModifyDistributionClauseContext) + + // ExitModifyTableCommentClause is called when exiting the modifyTableCommentClause production. + ExitModifyTableCommentClause(c *ModifyTableCommentClauseContext) + + // ExitModifyColumnCommentClause is called when exiting the modifyColumnCommentClause production. + ExitModifyColumnCommentClause(c *ModifyColumnCommentClauseContext) + + // ExitModifyEngineClause is called when exiting the modifyEngineClause production. + ExitModifyEngineClause(c *ModifyEngineClauseContext) + + // ExitAlterMultiPartitionClause is called when exiting the alterMultiPartitionClause production. + ExitAlterMultiPartitionClause(c *AlterMultiPartitionClauseContext) + + // ExitCreateOrReplaceTagClauses is called when exiting the createOrReplaceTagClauses production. + ExitCreateOrReplaceTagClauses(c *CreateOrReplaceTagClausesContext) + + // ExitCreateOrReplaceBranchClauses is called when exiting the createOrReplaceBranchClauses production. + ExitCreateOrReplaceBranchClauses(c *CreateOrReplaceBranchClausesContext) + + // ExitDropBranchClauses is called when exiting the dropBranchClauses production. + ExitDropBranchClauses(c *DropBranchClausesContext) + + // ExitDropTagClauses is called when exiting the dropTagClauses production. + ExitDropTagClauses(c *DropTagClausesContext) + + // ExitAddPartitionFieldClause is called when exiting the addPartitionFieldClause production. + ExitAddPartitionFieldClause(c *AddPartitionFieldClauseContext) + + // ExitDropPartitionFieldClause is called when exiting the dropPartitionFieldClause production. + ExitDropPartitionFieldClause(c *DropPartitionFieldClauseContext) + + // ExitReplacePartitionFieldClause is called when exiting the replacePartitionFieldClause production. + ExitReplacePartitionFieldClause(c *ReplacePartitionFieldClauseContext) + + // ExitCreateOrReplaceTagClause is called when exiting the createOrReplaceTagClause production. + ExitCreateOrReplaceTagClause(c *CreateOrReplaceTagClauseContext) + + // ExitCreateOrReplaceBranchClause is called when exiting the createOrReplaceBranchClause production. + ExitCreateOrReplaceBranchClause(c *CreateOrReplaceBranchClauseContext) + + // ExitTagOptions is called when exiting the tagOptions production. + ExitTagOptions(c *TagOptionsContext) + + // ExitBranchOptions is called when exiting the branchOptions production. + ExitBranchOptions(c *BranchOptionsContext) + + // ExitRetainTime is called when exiting the retainTime production. + ExitRetainTime(c *RetainTimeContext) + + // ExitRetentionSnapshot is called when exiting the retentionSnapshot production. + ExitRetentionSnapshot(c *RetentionSnapshotContext) + + // ExitMinSnapshotsToKeep is called when exiting the minSnapshotsToKeep production. + ExitMinSnapshotsToKeep(c *MinSnapshotsToKeepContext) + + // ExitTimeValueWithUnit is called when exiting the timeValueWithUnit production. + ExitTimeValueWithUnit(c *TimeValueWithUnitContext) + + // ExitDropBranchClause is called when exiting the dropBranchClause production. + ExitDropBranchClause(c *DropBranchClauseContext) + + // ExitDropTagClause is called when exiting the dropTagClause production. + ExitDropTagClause(c *DropTagClauseContext) + + // ExitPartitionTransformWithArgs is called when exiting the partitionTransformWithArgs production. + ExitPartitionTransformWithArgs(c *PartitionTransformWithArgsContext) + + // ExitPartitionTransformWithColumn is called when exiting the partitionTransformWithColumn production. + ExitPartitionTransformWithColumn(c *PartitionTransformWithColumnContext) + + // ExitPartitionTransformIdentity is called when exiting the partitionTransformIdentity production. + ExitPartitionTransformIdentity(c *PartitionTransformIdentityContext) + + // ExitColumnPosition is called when exiting the columnPosition production. + ExitColumnPosition(c *ColumnPositionContext) + + // ExitToRollup is called when exiting the toRollup production. + ExitToRollup(c *ToRollupContext) + + // ExitFromRollup is called when exiting the fromRollup production. + ExitFromRollup(c *FromRollupContext) + + // ExitShowAnalyze is called when exiting the showAnalyze production. + ExitShowAnalyze(c *ShowAnalyzeContext) + + // ExitShowQueuedAnalyzeJobs is called when exiting the showQueuedAnalyzeJobs production. + ExitShowQueuedAnalyzeJobs(c *ShowQueuedAnalyzeJobsContext) + + // ExitShowColumnHistogramStats is called when exiting the showColumnHistogramStats production. + ExitShowColumnHistogramStats(c *ShowColumnHistogramStatsContext) + + // ExitShowColumnStats is called when exiting the showColumnStats production. + ExitShowColumnStats(c *ShowColumnStatsContext) + + // ExitShowAnalyzeTask is called when exiting the showAnalyzeTask production. + ExitShowAnalyzeTask(c *ShowAnalyzeTaskContext) + + // ExitAnalyzeDatabase is called when exiting the analyzeDatabase production. + ExitAnalyzeDatabase(c *AnalyzeDatabaseContext) + + // ExitAnalyzeTable is called when exiting the analyzeTable production. + ExitAnalyzeTable(c *AnalyzeTableContext) + + // ExitAlterTableStats is called when exiting the alterTableStats production. + ExitAlterTableStats(c *AlterTableStatsContext) + + // ExitAlterColumnStats is called when exiting the alterColumnStats production. + ExitAlterColumnStats(c *AlterColumnStatsContext) + + // ExitShowIndexStats is called when exiting the showIndexStats production. + ExitShowIndexStats(c *ShowIndexStatsContext) + + // ExitDropStats is called when exiting the dropStats production. + ExitDropStats(c *DropStatsContext) + + // ExitDropCachedStats is called when exiting the dropCachedStats production. + ExitDropCachedStats(c *DropCachedStatsContext) + + // ExitDropExpiredStats is called when exiting the dropExpiredStats production. + ExitDropExpiredStats(c *DropExpiredStatsContext) + + // ExitKillAnalyzeJob is called when exiting the killAnalyzeJob production. + ExitKillAnalyzeJob(c *KillAnalyzeJobContext) + + // ExitDropAnalyzeJob is called when exiting the dropAnalyzeJob production. + ExitDropAnalyzeJob(c *DropAnalyzeJobContext) + + // ExitShowTableStats is called when exiting the showTableStats production. + ExitShowTableStats(c *ShowTableStatsContext) + + // ExitAnalyzeProperties is called when exiting the analyzeProperties production. + ExitAnalyzeProperties(c *AnalyzePropertiesContext) + + // ExitWorkloadPolicyActions is called when exiting the workloadPolicyActions production. + ExitWorkloadPolicyActions(c *WorkloadPolicyActionsContext) + + // ExitWorkloadPolicyAction is called when exiting the workloadPolicyAction production. + ExitWorkloadPolicyAction(c *WorkloadPolicyActionContext) + + // ExitWorkloadPolicyConditions is called when exiting the workloadPolicyConditions production. + ExitWorkloadPolicyConditions(c *WorkloadPolicyConditionsContext) + + // ExitWorkloadPolicyCondition is called when exiting the workloadPolicyCondition production. + ExitWorkloadPolicyCondition(c *WorkloadPolicyConditionContext) + + // ExitStorageBackend is called when exiting the storageBackend production. + ExitStorageBackend(c *StorageBackendContext) + + // ExitPasswordOption is called when exiting the passwordOption production. + ExitPasswordOption(c *PasswordOptionContext) + + // ExitFunctionArguments is called when exiting the functionArguments production. + ExitFunctionArguments(c *FunctionArgumentsContext) + + // ExitDataTypeList is called when exiting the dataTypeList production. + ExitDataTypeList(c *DataTypeListContext) + + // ExitSetOptions is called when exiting the setOptions production. + ExitSetOptions(c *SetOptionsContext) + + // ExitSetDefaultStorageVault is called when exiting the setDefaultStorageVault production. + ExitSetDefaultStorageVault(c *SetDefaultStorageVaultContext) + + // ExitSetUserProperties is called when exiting the setUserProperties production. + ExitSetUserProperties(c *SetUserPropertiesContext) + + // ExitSetTransaction is called when exiting the setTransaction production. + ExitSetTransaction(c *SetTransactionContext) + + // ExitSetVariableWithType is called when exiting the setVariableWithType production. + ExitSetVariableWithType(c *SetVariableWithTypeContext) + + // ExitSetNames is called when exiting the setNames production. + ExitSetNames(c *SetNamesContext) + + // ExitSetCharset is called when exiting the setCharset production. + ExitSetCharset(c *SetCharsetContext) + + // ExitSetCollate is called when exiting the setCollate production. + ExitSetCollate(c *SetCollateContext) + + // ExitSetPassword is called when exiting the setPassword production. + ExitSetPassword(c *SetPasswordContext) + + // ExitSetLdapAdminPassword is called when exiting the setLdapAdminPassword production. + ExitSetLdapAdminPassword(c *SetLdapAdminPasswordContext) + + // ExitSetVariableWithoutType is called when exiting the setVariableWithoutType production. + ExitSetVariableWithoutType(c *SetVariableWithoutTypeContext) + + // ExitSetSystemVariable is called when exiting the setSystemVariable production. + ExitSetSystemVariable(c *SetSystemVariableContext) + + // ExitSetUserVariable is called when exiting the setUserVariable production. + ExitSetUserVariable(c *SetUserVariableContext) + + // ExitTransactionAccessMode is called when exiting the transactionAccessMode production. + ExitTransactionAccessMode(c *TransactionAccessModeContext) + + // ExitIsolationLevel is called when exiting the isolationLevel production. + ExitIsolationLevel(c *IsolationLevelContext) + + // ExitSupportedUnsetStatement is called when exiting the supportedUnsetStatement production. + ExitSupportedUnsetStatement(c *SupportedUnsetStatementContext) + + // ExitSwitchCatalog is called when exiting the switchCatalog production. + ExitSwitchCatalog(c *SwitchCatalogContext) + + // ExitUseDatabase is called when exiting the useDatabase production. + ExitUseDatabase(c *UseDatabaseContext) + + // ExitUseCloudCluster is called when exiting the useCloudCluster production. + ExitUseCloudCluster(c *UseCloudClusterContext) + + // ExitStageAndPattern is called when exiting the stageAndPattern production. + ExitStageAndPattern(c *StageAndPatternContext) + + // ExitDescribeTableValuedFunction is called when exiting the describeTableValuedFunction production. + ExitDescribeTableValuedFunction(c *DescribeTableValuedFunctionContext) + + // ExitDescribeTableAll is called when exiting the describeTableAll production. + ExitDescribeTableAll(c *DescribeTableAllContext) + + // ExitDescribeTable is called when exiting the describeTable production. + ExitDescribeTable(c *DescribeTableContext) + + // ExitDescribeDictionary is called when exiting the describeDictionary production. + ExitDescribeDictionary(c *DescribeDictionaryContext) + + // ExitConstraint is called when exiting the constraint production. + ExitConstraint(c *ConstraintContext) + + // ExitPartitionSpec is called when exiting the partitionSpec production. + ExitPartitionSpec(c *PartitionSpecContext) + + // ExitPartitionTable is called when exiting the partitionTable production. + ExitPartitionTable(c *PartitionTableContext) + + // ExitIdentityOrFunctionList is called when exiting the identityOrFunctionList production. + ExitIdentityOrFunctionList(c *IdentityOrFunctionListContext) + + // ExitIdentityOrFunction is called when exiting the identityOrFunction production. + ExitIdentityOrFunction(c *IdentityOrFunctionContext) + + // ExitDataDesc is called when exiting the dataDesc production. + ExitDataDesc(c *DataDescContext) + + // ExitStatementScope is called when exiting the statementScope production. + ExitStatementScope(c *StatementScopeContext) + + // ExitBuildMode is called when exiting the buildMode production. + ExitBuildMode(c *BuildModeContext) + + // ExitRefreshTrigger is called when exiting the refreshTrigger production. + ExitRefreshTrigger(c *RefreshTriggerContext) + + // ExitRefreshSchedule is called when exiting the refreshSchedule production. + ExitRefreshSchedule(c *RefreshScheduleContext) + + // ExitRefreshMethod is called when exiting the refreshMethod production. + ExitRefreshMethod(c *RefreshMethodContext) + + // ExitMvPartition is called when exiting the mvPartition production. + ExitMvPartition(c *MvPartitionContext) + + // ExitIdentifierOrText is called when exiting the identifierOrText production. + ExitIdentifierOrText(c *IdentifierOrTextContext) + + // ExitIdentifierOrTextOrAsterisk is called when exiting the identifierOrTextOrAsterisk production. + ExitIdentifierOrTextOrAsterisk(c *IdentifierOrTextOrAsteriskContext) + + // ExitMultipartIdentifierOrAsterisk is called when exiting the multipartIdentifierOrAsterisk production. + ExitMultipartIdentifierOrAsterisk(c *MultipartIdentifierOrAsteriskContext) + + // ExitIdentifierOrAsterisk is called when exiting the identifierOrAsterisk production. + ExitIdentifierOrAsterisk(c *IdentifierOrAsteriskContext) + + // ExitUserIdentify is called when exiting the userIdentify production. + ExitUserIdentify(c *UserIdentifyContext) + + // ExitGrantUserIdentify is called when exiting the grantUserIdentify production. + ExitGrantUserIdentify(c *GrantUserIdentifyContext) + + // ExitExplain is called when exiting the explain production. + ExitExplain(c *ExplainContext) + + // ExitExplainCommand is called when exiting the explainCommand production. + ExitExplainCommand(c *ExplainCommandContext) + + // ExitPlanType is called when exiting the planType production. + ExitPlanType(c *PlanTypeContext) + + // ExitReplayCommand is called when exiting the replayCommand production. + ExitReplayCommand(c *ReplayCommandContext) + + // ExitReplayType is called when exiting the replayType production. + ExitReplayType(c *ReplayTypeContext) + + // ExitMergeType is called when exiting the mergeType production. + ExitMergeType(c *MergeTypeContext) + + // ExitPreFilterClause is called when exiting the preFilterClause production. + ExitPreFilterClause(c *PreFilterClauseContext) + + // ExitDeleteOnClause is called when exiting the deleteOnClause production. + ExitDeleteOnClause(c *DeleteOnClauseContext) + + // ExitSequenceColClause is called when exiting the sequenceColClause production. + ExitSequenceColClause(c *SequenceColClauseContext) + + // ExitColFromPath is called when exiting the colFromPath production. + ExitColFromPath(c *ColFromPathContext) + + // ExitColMappingList is called when exiting the colMappingList production. + ExitColMappingList(c *ColMappingListContext) + + // ExitMappingExpr is called when exiting the mappingExpr production. + ExitMappingExpr(c *MappingExprContext) + + // ExitWithRemoteStorageSystem is called when exiting the withRemoteStorageSystem production. + ExitWithRemoteStorageSystem(c *WithRemoteStorageSystemContext) + + // ExitResourceDesc is called when exiting the resourceDesc production. + ExitResourceDesc(c *ResourceDescContext) + + // ExitMysqlDataDesc is called when exiting the mysqlDataDesc production. + ExitMysqlDataDesc(c *MysqlDataDescContext) + + // ExitSkipLines is called when exiting the skipLines production. + ExitSkipLines(c *SkipLinesContext) + + // ExitOutFileClause is called when exiting the outFileClause production. + ExitOutFileClause(c *OutFileClauseContext) + + // ExitQuery is called when exiting the query production. + ExitQuery(c *QueryContext) + + // ExitQueryTermDefault is called when exiting the queryTermDefault production. + ExitQueryTermDefault(c *QueryTermDefaultContext) + + // ExitSetOperation is called when exiting the setOperation production. + ExitSetOperation(c *SetOperationContext) + + // ExitSetQuantifier is called when exiting the setQuantifier production. + ExitSetQuantifier(c *SetQuantifierContext) + + // ExitQueryPrimaryDefault is called when exiting the queryPrimaryDefault production. + ExitQueryPrimaryDefault(c *QueryPrimaryDefaultContext) + + // ExitSubquery is called when exiting the subquery production. + ExitSubquery(c *SubqueryContext) + + // ExitValuesTable is called when exiting the valuesTable production. + ExitValuesTable(c *ValuesTableContext) + + // ExitRegularQuerySpecification is called when exiting the regularQuerySpecification production. + ExitRegularQuerySpecification(c *RegularQuerySpecificationContext) + + // ExitCte is called when exiting the cte production. + ExitCte(c *CteContext) + + // ExitAliasQuery is called when exiting the aliasQuery production. + ExitAliasQuery(c *AliasQueryContext) + + // ExitColumnAliases is called when exiting the columnAliases production. + ExitColumnAliases(c *ColumnAliasesContext) + + // ExitSelectClause is called when exiting the selectClause production. + ExitSelectClause(c *SelectClauseContext) + + // ExitSelectColumnClause is called when exiting the selectColumnClause production. + ExitSelectColumnClause(c *SelectColumnClauseContext) + + // ExitWhereClause is called when exiting the whereClause production. + ExitWhereClause(c *WhereClauseContext) + + // ExitFromClause is called when exiting the fromClause production. + ExitFromClause(c *FromClauseContext) + + // ExitIntoClause is called when exiting the intoClause production. + ExitIntoClause(c *IntoClauseContext) + + // ExitBulkCollectClause is called when exiting the bulkCollectClause production. + ExitBulkCollectClause(c *BulkCollectClauseContext) + + // ExitTableRow is called when exiting the tableRow production. + ExitTableRow(c *TableRowContext) + + // ExitRelations is called when exiting the relations production. + ExitRelations(c *RelationsContext) + + // ExitRelation is called when exiting the relation production. + ExitRelation(c *RelationContext) + + // ExitJoinRelation is called when exiting the joinRelation production. + ExitJoinRelation(c *JoinRelationContext) + + // ExitDistributeType is called when exiting the distributeType production. + ExitDistributeType(c *DistributeTypeContext) + + // ExitSkewHint is called when exiting the skewHint production. + ExitSkewHint(c *SkewHintContext) + + // ExitConstantList is called when exiting the constantList production. + ExitConstantList(c *ConstantListContext) + + // ExitBracketRelationHint is called when exiting the bracketRelationHint production. + ExitBracketRelationHint(c *BracketRelationHintContext) + + // ExitCommentRelationHint is called when exiting the commentRelationHint production. + ExitCommentRelationHint(c *CommentRelationHintContext) + + // ExitExpressionWithOrder is called when exiting the expressionWithOrder production. + ExitExpressionWithOrder(c *ExpressionWithOrderContext) + + // ExitAggClause is called when exiting the aggClause production. + ExitAggClause(c *AggClauseContext) + + // ExitGroupingElement is called when exiting the groupingElement production. + ExitGroupingElement(c *GroupingElementContext) + + // ExitGroupingSet is called when exiting the groupingSet production. + ExitGroupingSet(c *GroupingSetContext) + + // ExitHavingClause is called when exiting the havingClause production. + ExitHavingClause(c *HavingClauseContext) + + // ExitQualifyClause is called when exiting the qualifyClause production. + ExitQualifyClause(c *QualifyClauseContext) + + // ExitSelectHint is called when exiting the selectHint production. + ExitSelectHint(c *SelectHintContext) + + // ExitHintStatement is called when exiting the hintStatement production. + ExitHintStatement(c *HintStatementContext) + + // ExitHintName is called when exiting the hintName production. + ExitHintName(c *HintNameContext) + + // ExitHintAssignment is called when exiting the hintAssignment production. + ExitHintAssignment(c *HintAssignmentContext) + + // ExitUpdateAssignment is called when exiting the updateAssignment production. + ExitUpdateAssignment(c *UpdateAssignmentContext) + + // ExitUpdateAssignmentSeq is called when exiting the updateAssignmentSeq production. + ExitUpdateAssignmentSeq(c *UpdateAssignmentSeqContext) + + // ExitLateralView is called when exiting the lateralView production. + ExitLateralView(c *LateralViewContext) + + // ExitQueryOrganization is called when exiting the queryOrganization production. + ExitQueryOrganization(c *QueryOrganizationContext) + + // ExitSortClause is called when exiting the sortClause production. + ExitSortClause(c *SortClauseContext) + + // ExitSortItem is called when exiting the sortItem production. + ExitSortItem(c *SortItemContext) + + // ExitLimitClause is called when exiting the limitClause production. + ExitLimitClause(c *LimitClauseContext) + + // ExitPartitionClause is called when exiting the partitionClause production. + ExitPartitionClause(c *PartitionClauseContext) + + // ExitJoinType is called when exiting the joinType production. + ExitJoinType(c *JoinTypeContext) + + // ExitJoinCriteria is called when exiting the joinCriteria production. + ExitJoinCriteria(c *JoinCriteriaContext) + + // ExitIdentifierList is called when exiting the identifierList production. + ExitIdentifierList(c *IdentifierListContext) + + // ExitIdentifierSeq is called when exiting the identifierSeq production. + ExitIdentifierSeq(c *IdentifierSeqContext) + + // ExitOptScanParams is called when exiting the optScanParams production. + ExitOptScanParams(c *OptScanParamsContext) + + // ExitTableName is called when exiting the tableName production. + ExitTableName(c *TableNameContext) + + // ExitAliasedQuery is called when exiting the aliasedQuery production. + ExitAliasedQuery(c *AliasedQueryContext) + + // ExitTableValuedFunction is called when exiting the tableValuedFunction production. + ExitTableValuedFunction(c *TableValuedFunctionContext) + + // ExitRelationList is called when exiting the relationList production. + ExitRelationList(c *RelationListContext) + + // ExitMaterializedViewName is called when exiting the materializedViewName production. + ExitMaterializedViewName(c *MaterializedViewNameContext) + + // ExitPropertyClause is called when exiting the propertyClause production. + ExitPropertyClause(c *PropertyClauseContext) + + // ExitPropertyItemList is called when exiting the propertyItemList production. + ExitPropertyItemList(c *PropertyItemListContext) + + // ExitPropertyItem is called when exiting the propertyItem production. + ExitPropertyItem(c *PropertyItemContext) + + // ExitPropertyKey is called when exiting the propertyKey production. + ExitPropertyKey(c *PropertyKeyContext) + + // ExitPropertyValue is called when exiting the propertyValue production. + ExitPropertyValue(c *PropertyValueContext) + + // ExitTableAlias is called when exiting the tableAlias production. + ExitTableAlias(c *TableAliasContext) + + // ExitMultipartIdentifier is called when exiting the multipartIdentifier production. + ExitMultipartIdentifier(c *MultipartIdentifierContext) + + // ExitSimpleColumnDefs is called when exiting the simpleColumnDefs production. + ExitSimpleColumnDefs(c *SimpleColumnDefsContext) + + // ExitSimpleColumnDef is called when exiting the simpleColumnDef production. + ExitSimpleColumnDef(c *SimpleColumnDefContext) + + // ExitColumnDefs is called when exiting the columnDefs production. + ExitColumnDefs(c *ColumnDefsContext) + + // ExitColumnDef is called when exiting the columnDef production. + ExitColumnDef(c *ColumnDefContext) + + // ExitIndexDefs is called when exiting the indexDefs production. + ExitIndexDefs(c *IndexDefsContext) + + // ExitIndexDef is called when exiting the indexDef production. + ExitIndexDef(c *IndexDefContext) + + // ExitPartitionsDef is called when exiting the partitionsDef production. + ExitPartitionsDef(c *PartitionsDefContext) + + // ExitPartitionDef is called when exiting the partitionDef production. + ExitPartitionDef(c *PartitionDefContext) + + // ExitLessThanPartitionDef is called when exiting the lessThanPartitionDef production. + ExitLessThanPartitionDef(c *LessThanPartitionDefContext) + + // ExitFixedPartitionDef is called when exiting the fixedPartitionDef production. + ExitFixedPartitionDef(c *FixedPartitionDefContext) + + // ExitStepPartitionDef is called when exiting the stepPartitionDef production. + ExitStepPartitionDef(c *StepPartitionDefContext) + + // ExitInPartitionDef is called when exiting the inPartitionDef production. + ExitInPartitionDef(c *InPartitionDefContext) + + // ExitPartitionValueList is called when exiting the partitionValueList production. + ExitPartitionValueList(c *PartitionValueListContext) + + // ExitPartitionValueDef is called when exiting the partitionValueDef production. + ExitPartitionValueDef(c *PartitionValueDefContext) + + // ExitRollupDefs is called when exiting the rollupDefs production. + ExitRollupDefs(c *RollupDefsContext) + + // ExitRollupDef is called when exiting the rollupDef production. + ExitRollupDef(c *RollupDefContext) + + // ExitAggTypeDef is called when exiting the aggTypeDef production. + ExitAggTypeDef(c *AggTypeDefContext) + + // ExitTabletList is called when exiting the tabletList production. + ExitTabletList(c *TabletListContext) + + // ExitInlineTable is called when exiting the inlineTable production. + ExitInlineTable(c *InlineTableContext) + + // ExitNamedExpression is called when exiting the namedExpression production. + ExitNamedExpression(c *NamedExpressionContext) + + // ExitNamedExpressionSeq is called when exiting the namedExpressionSeq production. + ExitNamedExpressionSeq(c *NamedExpressionSeqContext) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitFuncExpression is called when exiting the funcExpression production. + ExitFuncExpression(c *FuncExpressionContext) + + // ExitLambdaExpression is called when exiting the lambdaExpression production. + ExitLambdaExpression(c *LambdaExpressionContext) + + // ExitExist is called when exiting the exist production. + ExitExist(c *ExistContext) + + // ExitLogicalNot is called when exiting the logicalNot production. + ExitLogicalNot(c *LogicalNotContext) + + // ExitPredicated is called when exiting the predicated production. + ExitPredicated(c *PredicatedContext) + + // ExitIsnull is called when exiting the isnull production. + ExitIsnull(c *IsnullContext) + + // ExitIs_not_null_pred is called when exiting the is_not_null_pred production. + ExitIs_not_null_pred(c *Is_not_null_predContext) + + // ExitLogicalBinary is called when exiting the logicalBinary production. + ExitLogicalBinary(c *LogicalBinaryContext) + + // ExitDoublePipes is called when exiting the doublePipes production. + ExitDoublePipes(c *DoublePipesContext) + + // ExitRowConstructor is called when exiting the rowConstructor production. + ExitRowConstructor(c *RowConstructorContext) + + // ExitRowConstructorItem is called when exiting the rowConstructorItem production. + ExitRowConstructorItem(c *RowConstructorItemContext) + + // ExitPredicate is called when exiting the predicate production. + ExitPredicate(c *PredicateContext) + + // ExitValueExpressionDefault is called when exiting the valueExpressionDefault production. + ExitValueExpressionDefault(c *ValueExpressionDefaultContext) + + // ExitComparison is called when exiting the comparison production. + ExitComparison(c *ComparisonContext) + + // ExitArithmeticBinary is called when exiting the arithmeticBinary production. + ExitArithmeticBinary(c *ArithmeticBinaryContext) + + // ExitArithmeticUnary is called when exiting the arithmeticUnary production. + ExitArithmeticUnary(c *ArithmeticUnaryContext) + + // ExitDereference is called when exiting the dereference production. + ExitDereference(c *DereferenceContext) + + // ExitCurrentDate is called when exiting the currentDate production. + ExitCurrentDate(c *CurrentDateContext) + + // ExitSubstring is called when exiting the substring production. + ExitSubstring(c *SubstringContext) + + // ExitCast is called when exiting the cast production. + ExitCast(c *CastContext) + + // ExitParenthesizedExpression is called when exiting the parenthesizedExpression production. + ExitParenthesizedExpression(c *ParenthesizedExpressionContext) + + // ExitTrim is called when exiting the trim production. + ExitTrim(c *TrimContext) + + // ExitUserVariable is called when exiting the userVariable production. + ExitUserVariable(c *UserVariableContext) + + // ExitElementAt is called when exiting the elementAt production. + ExitElementAt(c *ElementAtContext) + + // ExitLocalTimestamp is called when exiting the localTimestamp production. + ExitLocalTimestamp(c *LocalTimestampContext) + + // ExitCharFunction is called when exiting the charFunction production. + ExitCharFunction(c *CharFunctionContext) + + // ExitIntervalLiteral is called when exiting the intervalLiteral production. + ExitIntervalLiteral(c *IntervalLiteralContext) + + // ExitGroupConcat is called when exiting the groupConcat production. + ExitGroupConcat(c *GroupConcatContext) + + // ExitSimpleCase is called when exiting the simpleCase production. + ExitSimpleCase(c *SimpleCaseContext) + + // ExitColumnReference is called when exiting the columnReference production. + ExitColumnReference(c *ColumnReferenceContext) + + // ExitStar is called when exiting the star production. + ExitStar(c *StarContext) + + // ExitGetFormatFunction is called when exiting the getFormatFunction production. + ExitGetFormatFunction(c *GetFormatFunctionContext) + + // ExitSessionUser is called when exiting the sessionUser production. + ExitSessionUser(c *SessionUserContext) + + // ExitConvertType is called when exiting the convertType production. + ExitConvertType(c *ConvertTypeContext) + + // ExitConvertCharSet is called when exiting the convertCharSet production. + ExitConvertCharSet(c *ConvertCharSetContext) + + // ExitSubqueryExpression is called when exiting the subqueryExpression production. + ExitSubqueryExpression(c *SubqueryExpressionContext) + + // ExitEncryptKey is called when exiting the encryptKey production. + ExitEncryptKey(c *EncryptKeyContext) + + // ExitCurrentTime is called when exiting the currentTime production. + ExitCurrentTime(c *CurrentTimeContext) + + // ExitLocalTime is called when exiting the localTime production. + ExitLocalTime(c *LocalTimeContext) + + // ExitSystemVariable is called when exiting the systemVariable production. + ExitSystemVariable(c *SystemVariableContext) + + // ExitCollate is called when exiting the collate production. + ExitCollate(c *CollateContext) + + // ExitCurrentUser is called when exiting the currentUser production. + ExitCurrentUser(c *CurrentUserContext) + + // ExitConstantDefault is called when exiting the constantDefault production. + ExitConstantDefault(c *ConstantDefaultContext) + + // ExitExtract is called when exiting the extract production. + ExitExtract(c *ExtractContext) + + // ExitCurrentTimestamp is called when exiting the currentTimestamp production. + ExitCurrentTimestamp(c *CurrentTimestampContext) + + // ExitFunctionCall is called when exiting the functionCall production. + ExitFunctionCall(c *FunctionCallContext) + + // ExitArraySlice is called when exiting the arraySlice production. + ExitArraySlice(c *ArraySliceContext) + + // ExitSearchedCase is called when exiting the searchedCase production. + ExitSearchedCase(c *SearchedCaseContext) + + // ExitPosition is called when exiting the position production. + ExitPosition(c *PositionContext) + + // ExitTryCast is called when exiting the tryCast production. + ExitTryCast(c *TryCastContext) + + // ExitExcept is called when exiting the except production. + ExitExcept(c *ExceptContext) + + // ExitReplace is called when exiting the replace production. + ExitReplace(c *ReplaceContext) + + // ExitCastDataType is called when exiting the castDataType production. + ExitCastDataType(c *CastDataTypeContext) + + // ExitFunctionCallExpression is called when exiting the functionCallExpression production. + ExitFunctionCallExpression(c *FunctionCallExpressionContext) + + // ExitFunctionIdentifier is called when exiting the functionIdentifier production. + ExitFunctionIdentifier(c *FunctionIdentifierContext) + + // ExitFunctionNameIdentifier is called when exiting the functionNameIdentifier production. + ExitFunctionNameIdentifier(c *FunctionNameIdentifierContext) + + // ExitWindowSpec is called when exiting the windowSpec production. + ExitWindowSpec(c *WindowSpecContext) + + // ExitWindowFrame is called when exiting the windowFrame production. + ExitWindowFrame(c *WindowFrameContext) + + // ExitFrameUnits is called when exiting the frameUnits production. + ExitFrameUnits(c *FrameUnitsContext) + + // ExitFrameBoundary is called when exiting the frameBoundary production. + ExitFrameBoundary(c *FrameBoundaryContext) + + // ExitQualifiedName is called when exiting the qualifiedName production. + ExitQualifiedName(c *QualifiedNameContext) + + // ExitSpecifiedPartition is called when exiting the specifiedPartition production. + ExitSpecifiedPartition(c *SpecifiedPartitionContext) + + // ExitNullLiteral is called when exiting the nullLiteral production. + ExitNullLiteral(c *NullLiteralContext) + + // ExitTypeConstructor is called when exiting the typeConstructor production. + ExitTypeConstructor(c *TypeConstructorContext) + + // ExitNumericLiteral is called when exiting the numericLiteral production. + ExitNumericLiteral(c *NumericLiteralContext) + + // ExitBooleanLiteral is called when exiting the booleanLiteral production. + ExitBooleanLiteral(c *BooleanLiteralContext) + + // ExitStringLiteral is called when exiting the stringLiteral production. + ExitStringLiteral(c *StringLiteralContext) + + // ExitVarbinaryLiteral is called when exiting the varbinaryLiteral production. + ExitVarbinaryLiteral(c *VarbinaryLiteralContext) + + // ExitArrayLiteral is called when exiting the arrayLiteral production. + ExitArrayLiteral(c *ArrayLiteralContext) + + // ExitMapLiteral is called when exiting the mapLiteral production. + ExitMapLiteral(c *MapLiteralContext) + + // ExitStructLiteral is called when exiting the structLiteral production. + ExitStructLiteral(c *StructLiteralContext) + + // ExitPlaceholder is called when exiting the placeholder production. + ExitPlaceholder(c *PlaceholderContext) + + // ExitComparisonOperator is called when exiting the comparisonOperator production. + ExitComparisonOperator(c *ComparisonOperatorContext) + + // ExitBooleanValue is called when exiting the booleanValue production. + ExitBooleanValue(c *BooleanValueContext) + + // ExitWhenClause is called when exiting the whenClause production. + ExitWhenClause(c *WhenClauseContext) + + // ExitInterval is called when exiting the interval production. + ExitInterval(c *IntervalContext) + + // ExitUnitIdentifier is called when exiting the unitIdentifier production. + ExitUnitIdentifier(c *UnitIdentifierContext) + + // ExitDataTypeWithNullable is called when exiting the dataTypeWithNullable production. + ExitDataTypeWithNullable(c *DataTypeWithNullableContext) + + // ExitComplexDataType is called when exiting the complexDataType production. + ExitComplexDataType(c *ComplexDataTypeContext) + + // ExitVariantPredefinedFields is called when exiting the variantPredefinedFields production. + ExitVariantPredefinedFields(c *VariantPredefinedFieldsContext) + + // ExitAggStateDataType is called when exiting the aggStateDataType production. + ExitAggStateDataType(c *AggStateDataTypeContext) + + // ExitPrimitiveDataType is called when exiting the primitiveDataType production. + ExitPrimitiveDataType(c *PrimitiveDataTypeContext) + + // ExitPrimitiveColType is called when exiting the primitiveColType production. + ExitPrimitiveColType(c *PrimitiveColTypeContext) + + // ExitComplexColTypeList is called when exiting the complexColTypeList production. + ExitComplexColTypeList(c *ComplexColTypeListContext) + + // ExitComplexColType is called when exiting the complexColType production. + ExitComplexColType(c *ComplexColTypeContext) + + // ExitVariant is called when exiting the variant production. + ExitVariant(c *VariantContext) + + // ExitVariantSubColTypeList is called when exiting the variantSubColTypeList production. + ExitVariantSubColTypeList(c *VariantSubColTypeListContext) + + // ExitVariantSubColType is called when exiting the variantSubColType production. + ExitVariantSubColType(c *VariantSubColTypeContext) + + // ExitVariantSubColMatchType is called when exiting the variantSubColMatchType production. + ExitVariantSubColMatchType(c *VariantSubColMatchTypeContext) + + // ExitCommentSpec is called when exiting the commentSpec production. + ExitCommentSpec(c *CommentSpecContext) + + // ExitSample is called when exiting the sample production. + ExitSample(c *SampleContext) + + // ExitSampleByPercentile is called when exiting the sampleByPercentile production. + ExitSampleByPercentile(c *SampleByPercentileContext) + + // ExitSampleByRows is called when exiting the sampleByRows production. + ExitSampleByRows(c *SampleByRowsContext) + + // ExitTableSnapshot is called when exiting the tableSnapshot production. + ExitTableSnapshot(c *TableSnapshotContext) + + // ExitErrorCapturingIdentifier is called when exiting the errorCapturingIdentifier production. + ExitErrorCapturingIdentifier(c *ErrorCapturingIdentifierContext) + + // ExitErrorIdent is called when exiting the errorIdent production. + ExitErrorIdent(c *ErrorIdentContext) + + // ExitRealIdent is called when exiting the realIdent production. + ExitRealIdent(c *RealIdentContext) + + // ExitIdentifier is called when exiting the identifier production. + ExitIdentifier(c *IdentifierContext) + + // ExitUnquotedIdentifier is called when exiting the unquotedIdentifier production. + ExitUnquotedIdentifier(c *UnquotedIdentifierContext) + + // ExitQuotedIdentifierAlternative is called when exiting the quotedIdentifierAlternative production. + ExitQuotedIdentifierAlternative(c *QuotedIdentifierAlternativeContext) + + // ExitQuotedIdentifier is called when exiting the quotedIdentifier production. + ExitQuotedIdentifier(c *QuotedIdentifierContext) + + // ExitIntegerLiteral is called when exiting the integerLiteral production. + ExitIntegerLiteral(c *IntegerLiteralContext) + + // ExitDecimalLiteral is called when exiting the decimalLiteral production. + ExitDecimalLiteral(c *DecimalLiteralContext) + + // ExitNonReserved is called when exiting the nonReserved production. + ExitNonReserved(c *NonReservedContext) +} diff --git a/doris/dorisparser_visitor.go b/doris/dorisparser_visitor.go new file mode 100644 index 0000000..1f3feea --- /dev/null +++ b/doris/dorisparser_visitor.go @@ -0,0 +1,2007 @@ +// Code generated from DorisParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package doris // DorisParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by DorisParser. +type DorisParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by DorisParser#multiStatements. + VisitMultiStatements(ctx *MultiStatementsContext) interface{} + + // Visit a parse tree produced by DorisParser#singleStatement. + VisitSingleStatement(ctx *SingleStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#expressionWithEof. + VisitExpressionWithEof(ctx *ExpressionWithEofContext) interface{} + + // Visit a parse tree produced by DorisParser#statementBaseAlias. + VisitStatementBaseAlias(ctx *StatementBaseAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#callProcedure. + VisitCallProcedure(ctx *CallProcedureContext) interface{} + + // Visit a parse tree produced by DorisParser#createProcedure. + VisitCreateProcedure(ctx *CreateProcedureContext) interface{} + + // Visit a parse tree produced by DorisParser#dropProcedure. + VisitDropProcedure(ctx *DropProcedureContext) interface{} + + // Visit a parse tree produced by DorisParser#showProcedureStatus. + VisitShowProcedureStatus(ctx *ShowProcedureStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateProcedure. + VisitShowCreateProcedure(ctx *ShowCreateProcedureContext) interface{} + + // Visit a parse tree produced by DorisParser#showConfig. + VisitShowConfig(ctx *ShowConfigContext) interface{} + + // Visit a parse tree produced by DorisParser#statementDefault. + VisitStatementDefault(ctx *StatementDefaultContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedDmlStatementAlias. + VisitSupportedDmlStatementAlias(ctx *SupportedDmlStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedCreateStatementAlias. + VisitSupportedCreateStatementAlias(ctx *SupportedCreateStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedAlterStatementAlias. + VisitSupportedAlterStatementAlias(ctx *SupportedAlterStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#materializedViewStatementAlias. + VisitMaterializedViewStatementAlias(ctx *MaterializedViewStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedJobStatementAlias. + VisitSupportedJobStatementAlias(ctx *SupportedJobStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#constraintStatementAlias. + VisitConstraintStatementAlias(ctx *ConstraintStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedCleanStatementAlias. + VisitSupportedCleanStatementAlias(ctx *SupportedCleanStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedDescribeStatementAlias. + VisitSupportedDescribeStatementAlias(ctx *SupportedDescribeStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedDropStatementAlias. + VisitSupportedDropStatementAlias(ctx *SupportedDropStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedSetStatementAlias. + VisitSupportedSetStatementAlias(ctx *SupportedSetStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedUnsetStatementAlias. + VisitSupportedUnsetStatementAlias(ctx *SupportedUnsetStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedRefreshStatementAlias. + VisitSupportedRefreshStatementAlias(ctx *SupportedRefreshStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedShowStatementAlias. + VisitSupportedShowStatementAlias(ctx *SupportedShowStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedLoadStatementAlias. + VisitSupportedLoadStatementAlias(ctx *SupportedLoadStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedCancelStatementAlias. + VisitSupportedCancelStatementAlias(ctx *SupportedCancelStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedRecoverStatementAlias. + VisitSupportedRecoverStatementAlias(ctx *SupportedRecoverStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedAdminStatementAlias. + VisitSupportedAdminStatementAlias(ctx *SupportedAdminStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedUseStatementAlias. + VisitSupportedUseStatementAlias(ctx *SupportedUseStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedOtherStatementAlias. + VisitSupportedOtherStatementAlias(ctx *SupportedOtherStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedKillStatementAlias. + VisitSupportedKillStatementAlias(ctx *SupportedKillStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedStatsStatementAlias. + VisitSupportedStatsStatementAlias(ctx *SupportedStatsStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedTransactionStatementAlias. + VisitSupportedTransactionStatementAlias(ctx *SupportedTransactionStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedGrantRevokeStatementAlias. + VisitSupportedGrantRevokeStatementAlias(ctx *SupportedGrantRevokeStatementAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#createMTMV. + VisitCreateMTMV(ctx *CreateMTMVContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshMTMV. + VisitRefreshMTMV(ctx *RefreshMTMVContext) interface{} + + // Visit a parse tree produced by DorisParser#alterMTMV. + VisitAlterMTMV(ctx *AlterMTMVContext) interface{} + + // Visit a parse tree produced by DorisParser#dropMV. + VisitDropMV(ctx *DropMVContext) interface{} + + // Visit a parse tree produced by DorisParser#pauseMTMV. + VisitPauseMTMV(ctx *PauseMTMVContext) interface{} + + // Visit a parse tree produced by DorisParser#resumeMTMV. + VisitResumeMTMV(ctx *ResumeMTMVContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelMTMVTask. + VisitCancelMTMVTask(ctx *CancelMTMVTaskContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateMTMV. + VisitShowCreateMTMV(ctx *ShowCreateMTMVContext) interface{} + + // Visit a parse tree produced by DorisParser#createScheduledJob. + VisitCreateScheduledJob(ctx *CreateScheduledJobContext) interface{} + + // Visit a parse tree produced by DorisParser#pauseJob. + VisitPauseJob(ctx *PauseJobContext) interface{} + + // Visit a parse tree produced by DorisParser#alterJob. + VisitAlterJob(ctx *AlterJobContext) interface{} + + // Visit a parse tree produced by DorisParser#dropJob. + VisitDropJob(ctx *DropJobContext) interface{} + + // Visit a parse tree produced by DorisParser#resumeJob. + VisitResumeJob(ctx *ResumeJobContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelJobTask. + VisitCancelJobTask(ctx *CancelJobTaskContext) interface{} + + // Visit a parse tree produced by DorisParser#addConstraint. + VisitAddConstraint(ctx *AddConstraintContext) interface{} + + // Visit a parse tree produced by DorisParser#dropConstraint. + VisitDropConstraint(ctx *DropConstraintContext) interface{} + + // Visit a parse tree produced by DorisParser#showConstraint. + VisitShowConstraint(ctx *ShowConstraintContext) interface{} + + // Visit a parse tree produced by DorisParser#optSpecBranch. + VisitOptSpecBranch(ctx *OptSpecBranchContext) interface{} + + // Visit a parse tree produced by DorisParser#insertTable. + VisitInsertTable(ctx *InsertTableContext) interface{} + + // Visit a parse tree produced by DorisParser#update. + VisitUpdate(ctx *UpdateContext) interface{} + + // Visit a parse tree produced by DorisParser#delete. + VisitDelete(ctx *DeleteContext) interface{} + + // Visit a parse tree produced by DorisParser#mergeInto. + VisitMergeInto(ctx *MergeIntoContext) interface{} + + // Visit a parse tree produced by DorisParser#load. + VisitLoad(ctx *LoadContext) interface{} + + // Visit a parse tree produced by DorisParser#export. + VisitExport(ctx *ExportContext) interface{} + + // Visit a parse tree produced by DorisParser#replay. + VisitReplay(ctx *ReplayContext) interface{} + + // Visit a parse tree produced by DorisParser#copyInto. + VisitCopyInto(ctx *CopyIntoContext) interface{} + + // Visit a parse tree produced by DorisParser#truncateTable. + VisitTruncateTable(ctx *TruncateTableContext) interface{} + + // Visit a parse tree produced by DorisParser#mergeMatchedClause. + VisitMergeMatchedClause(ctx *MergeMatchedClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#mergeNotMatchedClause. + VisitMergeNotMatchedClause(ctx *MergeNotMatchedClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#createTable. + VisitCreateTable(ctx *CreateTableContext) interface{} + + // Visit a parse tree produced by DorisParser#createView. + VisitCreateView(ctx *CreateViewContext) interface{} + + // Visit a parse tree produced by DorisParser#createFile. + VisitCreateFile(ctx *CreateFileContext) interface{} + + // Visit a parse tree produced by DorisParser#createTableLike. + VisitCreateTableLike(ctx *CreateTableLikeContext) interface{} + + // Visit a parse tree produced by DorisParser#createRole. + VisitCreateRole(ctx *CreateRoleContext) interface{} + + // Visit a parse tree produced by DorisParser#createWorkloadGroup. + VisitCreateWorkloadGroup(ctx *CreateWorkloadGroupContext) interface{} + + // Visit a parse tree produced by DorisParser#createCatalog. + VisitCreateCatalog(ctx *CreateCatalogContext) interface{} + + // Visit a parse tree produced by DorisParser#createRowPolicy. + VisitCreateRowPolicy(ctx *CreateRowPolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#createStoragePolicy. + VisitCreateStoragePolicy(ctx *CreateStoragePolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#buildIndex. + VisitBuildIndex(ctx *BuildIndexContext) interface{} + + // Visit a parse tree produced by DorisParser#createIndex. + VisitCreateIndex(ctx *CreateIndexContext) interface{} + + // Visit a parse tree produced by DorisParser#createWorkloadPolicy. + VisitCreateWorkloadPolicy(ctx *CreateWorkloadPolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#createSqlBlockRule. + VisitCreateSqlBlockRule(ctx *CreateSqlBlockRuleContext) interface{} + + // Visit a parse tree produced by DorisParser#createEncryptkey. + VisitCreateEncryptkey(ctx *CreateEncryptkeyContext) interface{} + + // Visit a parse tree produced by DorisParser#createUserDefineFunction. + VisitCreateUserDefineFunction(ctx *CreateUserDefineFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#createAliasFunction. + VisitCreateAliasFunction(ctx *CreateAliasFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#createUser. + VisitCreateUser(ctx *CreateUserContext) interface{} + + // Visit a parse tree produced by DorisParser#createDatabase. + VisitCreateDatabase(ctx *CreateDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#createRepository. + VisitCreateRepository(ctx *CreateRepositoryContext) interface{} + + // Visit a parse tree produced by DorisParser#createResource. + VisitCreateResource(ctx *CreateResourceContext) interface{} + + // Visit a parse tree produced by DorisParser#createDictionary. + VisitCreateDictionary(ctx *CreateDictionaryContext) interface{} + + // Visit a parse tree produced by DorisParser#createStage. + VisitCreateStage(ctx *CreateStageContext) interface{} + + // Visit a parse tree produced by DorisParser#createStorageVault. + VisitCreateStorageVault(ctx *CreateStorageVaultContext) interface{} + + // Visit a parse tree produced by DorisParser#createIndexAnalyzer. + VisitCreateIndexAnalyzer(ctx *CreateIndexAnalyzerContext) interface{} + + // Visit a parse tree produced by DorisParser#createIndexTokenizer. + VisitCreateIndexTokenizer(ctx *CreateIndexTokenizerContext) interface{} + + // Visit a parse tree produced by DorisParser#createIndexTokenFilter. + VisitCreateIndexTokenFilter(ctx *CreateIndexTokenFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#createIndexCharFilter. + VisitCreateIndexCharFilter(ctx *CreateIndexCharFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#dictionaryColumnDefs. + VisitDictionaryColumnDefs(ctx *DictionaryColumnDefsContext) interface{} + + // Visit a parse tree produced by DorisParser#dictionaryColumnDef. + VisitDictionaryColumnDef(ctx *DictionaryColumnDefContext) interface{} + + // Visit a parse tree produced by DorisParser#alterSystem. + VisitAlterSystem(ctx *AlterSystemContext) interface{} + + // Visit a parse tree produced by DorisParser#alterView. + VisitAlterView(ctx *AlterViewContext) interface{} + + // Visit a parse tree produced by DorisParser#alterCatalogRename. + VisitAlterCatalogRename(ctx *AlterCatalogRenameContext) interface{} + + // Visit a parse tree produced by DorisParser#alterRole. + VisitAlterRole(ctx *AlterRoleContext) interface{} + + // Visit a parse tree produced by DorisParser#alterStorageVault. + VisitAlterStorageVault(ctx *AlterStorageVaultContext) interface{} + + // Visit a parse tree produced by DorisParser#alterWorkloadGroup. + VisitAlterWorkloadGroup(ctx *AlterWorkloadGroupContext) interface{} + + // Visit a parse tree produced by DorisParser#alterComputeGroup. + VisitAlterComputeGroup(ctx *AlterComputeGroupContext) interface{} + + // Visit a parse tree produced by DorisParser#alterCatalogProperties. + VisitAlterCatalogProperties(ctx *AlterCatalogPropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#alterWorkloadPolicy. + VisitAlterWorkloadPolicy(ctx *AlterWorkloadPolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#alterSqlBlockRule. + VisitAlterSqlBlockRule(ctx *AlterSqlBlockRuleContext) interface{} + + // Visit a parse tree produced by DorisParser#alterCatalogComment. + VisitAlterCatalogComment(ctx *AlterCatalogCommentContext) interface{} + + // Visit a parse tree produced by DorisParser#alterDatabaseRename. + VisitAlterDatabaseRename(ctx *AlterDatabaseRenameContext) interface{} + + // Visit a parse tree produced by DorisParser#alterStoragePolicy. + VisitAlterStoragePolicy(ctx *AlterStoragePolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#alterTable. + VisitAlterTable(ctx *AlterTableContext) interface{} + + // Visit a parse tree produced by DorisParser#alterTableExecute. + VisitAlterTableExecute(ctx *AlterTableExecuteContext) interface{} + + // Visit a parse tree produced by DorisParser#alterTableAddRollup. + VisitAlterTableAddRollup(ctx *AlterTableAddRollupContext) interface{} + + // Visit a parse tree produced by DorisParser#alterTableDropRollup. + VisitAlterTableDropRollup(ctx *AlterTableDropRollupContext) interface{} + + // Visit a parse tree produced by DorisParser#alterTableProperties. + VisitAlterTableProperties(ctx *AlterTablePropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#alterDatabaseSetQuota. + VisitAlterDatabaseSetQuota(ctx *AlterDatabaseSetQuotaContext) interface{} + + // Visit a parse tree produced by DorisParser#alterDatabaseProperties. + VisitAlterDatabaseProperties(ctx *AlterDatabasePropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#alterSystemRenameComputeGroup. + VisitAlterSystemRenameComputeGroup(ctx *AlterSystemRenameComputeGroupContext) interface{} + + // Visit a parse tree produced by DorisParser#alterResource. + VisitAlterResource(ctx *AlterResourceContext) interface{} + + // Visit a parse tree produced by DorisParser#alterRepository. + VisitAlterRepository(ctx *AlterRepositoryContext) interface{} + + // Visit a parse tree produced by DorisParser#alterRoutineLoad. + VisitAlterRoutineLoad(ctx *AlterRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#alterColocateGroup. + VisitAlterColocateGroup(ctx *AlterColocateGroupContext) interface{} + + // Visit a parse tree produced by DorisParser#alterUser. + VisitAlterUser(ctx *AlterUserContext) interface{} + + // Visit a parse tree produced by DorisParser#dropCatalogRecycleBin. + VisitDropCatalogRecycleBin(ctx *DropCatalogRecycleBinContext) interface{} + + // Visit a parse tree produced by DorisParser#dropEncryptkey. + VisitDropEncryptkey(ctx *DropEncryptkeyContext) interface{} + + // Visit a parse tree produced by DorisParser#dropRole. + VisitDropRole(ctx *DropRoleContext) interface{} + + // Visit a parse tree produced by DorisParser#dropSqlBlockRule. + VisitDropSqlBlockRule(ctx *DropSqlBlockRuleContext) interface{} + + // Visit a parse tree produced by DorisParser#dropUser. + VisitDropUser(ctx *DropUserContext) interface{} + + // Visit a parse tree produced by DorisParser#dropStoragePolicy. + VisitDropStoragePolicy(ctx *DropStoragePolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#dropWorkloadGroup. + VisitDropWorkloadGroup(ctx *DropWorkloadGroupContext) interface{} + + // Visit a parse tree produced by DorisParser#dropCatalog. + VisitDropCatalog(ctx *DropCatalogContext) interface{} + + // Visit a parse tree produced by DorisParser#dropFile. + VisitDropFile(ctx *DropFileContext) interface{} + + // Visit a parse tree produced by DorisParser#dropWorkloadPolicy. + VisitDropWorkloadPolicy(ctx *DropWorkloadPolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#dropRepository. + VisitDropRepository(ctx *DropRepositoryContext) interface{} + + // Visit a parse tree produced by DorisParser#dropTable. + VisitDropTable(ctx *DropTableContext) interface{} + + // Visit a parse tree produced by DorisParser#dropDatabase. + VisitDropDatabase(ctx *DropDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropFunction. + VisitDropFunction(ctx *DropFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#dropIndex. + VisitDropIndex(ctx *DropIndexContext) interface{} + + // Visit a parse tree produced by DorisParser#dropResource. + VisitDropResource(ctx *DropResourceContext) interface{} + + // Visit a parse tree produced by DorisParser#dropRowPolicy. + VisitDropRowPolicy(ctx *DropRowPolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#dropDictionary. + VisitDropDictionary(ctx *DropDictionaryContext) interface{} + + // Visit a parse tree produced by DorisParser#dropStage. + VisitDropStage(ctx *DropStageContext) interface{} + + // Visit a parse tree produced by DorisParser#dropView. + VisitDropView(ctx *DropViewContext) interface{} + + // Visit a parse tree produced by DorisParser#dropIndexAnalyzer. + VisitDropIndexAnalyzer(ctx *DropIndexAnalyzerContext) interface{} + + // Visit a parse tree produced by DorisParser#dropIndexTokenizer. + VisitDropIndexTokenizer(ctx *DropIndexTokenizerContext) interface{} + + // Visit a parse tree produced by DorisParser#dropIndexTokenFilter. + VisitDropIndexTokenFilter(ctx *DropIndexTokenFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#dropIndexCharFilter. + VisitDropIndexCharFilter(ctx *DropIndexCharFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#showVariables. + VisitShowVariables(ctx *ShowVariablesContext) interface{} + + // Visit a parse tree produced by DorisParser#showAuthors. + VisitShowAuthors(ctx *ShowAuthorsContext) interface{} + + // Visit a parse tree produced by DorisParser#showAlterTable. + VisitShowAlterTable(ctx *ShowAlterTableContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateDatabase. + VisitShowCreateDatabase(ctx *ShowCreateDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#showBackup. + VisitShowBackup(ctx *ShowBackupContext) interface{} + + // Visit a parse tree produced by DorisParser#showBroker. + VisitShowBroker(ctx *ShowBrokerContext) interface{} + + // Visit a parse tree produced by DorisParser#showBuildIndex. + VisitShowBuildIndex(ctx *ShowBuildIndexContext) interface{} + + // Visit a parse tree produced by DorisParser#showDynamicPartition. + VisitShowDynamicPartition(ctx *ShowDynamicPartitionContext) interface{} + + // Visit a parse tree produced by DorisParser#showEvents. + VisitShowEvents(ctx *ShowEventsContext) interface{} + + // Visit a parse tree produced by DorisParser#showExport. + VisitShowExport(ctx *ShowExportContext) interface{} + + // Visit a parse tree produced by DorisParser#showLastInsert. + VisitShowLastInsert(ctx *ShowLastInsertContext) interface{} + + // Visit a parse tree produced by DorisParser#showCharset. + VisitShowCharset(ctx *ShowCharsetContext) interface{} + + // Visit a parse tree produced by DorisParser#showDelete. + VisitShowDelete(ctx *ShowDeleteContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateFunction. + VisitShowCreateFunction(ctx *ShowCreateFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#showFunctions. + VisitShowFunctions(ctx *ShowFunctionsContext) interface{} + + // Visit a parse tree produced by DorisParser#showGlobalFunctions. + VisitShowGlobalFunctions(ctx *ShowGlobalFunctionsContext) interface{} + + // Visit a parse tree produced by DorisParser#showGrants. + VisitShowGrants(ctx *ShowGrantsContext) interface{} + + // Visit a parse tree produced by DorisParser#showGrantsForUser. + VisitShowGrantsForUser(ctx *ShowGrantsForUserContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateUser. + VisitShowCreateUser(ctx *ShowCreateUserContext) interface{} + + // Visit a parse tree produced by DorisParser#showSnapshot. + VisitShowSnapshot(ctx *ShowSnapshotContext) interface{} + + // Visit a parse tree produced by DorisParser#showLoadProfile. + VisitShowLoadProfile(ctx *ShowLoadProfileContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateRepository. + VisitShowCreateRepository(ctx *ShowCreateRepositoryContext) interface{} + + // Visit a parse tree produced by DorisParser#showView. + VisitShowView(ctx *ShowViewContext) interface{} + + // Visit a parse tree produced by DorisParser#showPlugins. + VisitShowPlugins(ctx *ShowPluginsContext) interface{} + + // Visit a parse tree produced by DorisParser#showStorageVault. + VisitShowStorageVault(ctx *ShowStorageVaultContext) interface{} + + // Visit a parse tree produced by DorisParser#showRepositories. + VisitShowRepositories(ctx *ShowRepositoriesContext) interface{} + + // Visit a parse tree produced by DorisParser#showEncryptKeys. + VisitShowEncryptKeys(ctx *ShowEncryptKeysContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateTable. + VisitShowCreateTable(ctx *ShowCreateTableContext) interface{} + + // Visit a parse tree produced by DorisParser#showProcessList. + VisitShowProcessList(ctx *ShowProcessListContext) interface{} + + // Visit a parse tree produced by DorisParser#showPartitions. + VisitShowPartitions(ctx *ShowPartitionsContext) interface{} + + // Visit a parse tree produced by DorisParser#showRestore. + VisitShowRestore(ctx *ShowRestoreContext) interface{} + + // Visit a parse tree produced by DorisParser#showRoles. + VisitShowRoles(ctx *ShowRolesContext) interface{} + + // Visit a parse tree produced by DorisParser#showPartitionId. + VisitShowPartitionId(ctx *ShowPartitionIdContext) interface{} + + // Visit a parse tree produced by DorisParser#showPrivileges. + VisitShowPrivileges(ctx *ShowPrivilegesContext) interface{} + + // Visit a parse tree produced by DorisParser#showProc. + VisitShowProc(ctx *ShowProcContext) interface{} + + // Visit a parse tree produced by DorisParser#showSmallFiles. + VisitShowSmallFiles(ctx *ShowSmallFilesContext) interface{} + + // Visit a parse tree produced by DorisParser#showStorageEngines. + VisitShowStorageEngines(ctx *ShowStorageEnginesContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateCatalog. + VisitShowCreateCatalog(ctx *ShowCreateCatalogContext) interface{} + + // Visit a parse tree produced by DorisParser#showCatalog. + VisitShowCatalog(ctx *ShowCatalogContext) interface{} + + // Visit a parse tree produced by DorisParser#showCatalogs. + VisitShowCatalogs(ctx *ShowCatalogsContext) interface{} + + // Visit a parse tree produced by DorisParser#showUserProperties. + VisitShowUserProperties(ctx *ShowUserPropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#showAllProperties. + VisitShowAllProperties(ctx *ShowAllPropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#showCollation. + VisitShowCollation(ctx *ShowCollationContext) interface{} + + // Visit a parse tree produced by DorisParser#showRowPolicy. + VisitShowRowPolicy(ctx *ShowRowPolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#showStoragePolicy. + VisitShowStoragePolicy(ctx *ShowStoragePolicyContext) interface{} + + // Visit a parse tree produced by DorisParser#showSqlBlockRule. + VisitShowSqlBlockRule(ctx *ShowSqlBlockRuleContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateView. + VisitShowCreateView(ctx *ShowCreateViewContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateStorageVault. + VisitShowCreateStorageVault(ctx *ShowCreateStorageVaultContext) interface{} + + // Visit a parse tree produced by DorisParser#showDataTypes. + VisitShowDataTypes(ctx *ShowDataTypesContext) interface{} + + // Visit a parse tree produced by DorisParser#showData. + VisitShowData(ctx *ShowDataContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateMaterializedView. + VisitShowCreateMaterializedView(ctx *ShowCreateMaterializedViewContext) interface{} + + // Visit a parse tree produced by DorisParser#showWarningErrors. + VisitShowWarningErrors(ctx *ShowWarningErrorsContext) interface{} + + // Visit a parse tree produced by DorisParser#showWarningErrorCount. + VisitShowWarningErrorCount(ctx *ShowWarningErrorCountContext) interface{} + + // Visit a parse tree produced by DorisParser#showBackends. + VisitShowBackends(ctx *ShowBackendsContext) interface{} + + // Visit a parse tree produced by DorisParser#showStages. + VisitShowStages(ctx *ShowStagesContext) interface{} + + // Visit a parse tree produced by DorisParser#showReplicaDistribution. + VisitShowReplicaDistribution(ctx *ShowReplicaDistributionContext) interface{} + + // Visit a parse tree produced by DorisParser#showResources. + VisitShowResources(ctx *ShowResourcesContext) interface{} + + // Visit a parse tree produced by DorisParser#showLoad. + VisitShowLoad(ctx *ShowLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#showLoadWarings. + VisitShowLoadWarings(ctx *ShowLoadWaringsContext) interface{} + + // Visit a parse tree produced by DorisParser#showTriggers. + VisitShowTriggers(ctx *ShowTriggersContext) interface{} + + // Visit a parse tree produced by DorisParser#showDiagnoseTablet. + VisitShowDiagnoseTablet(ctx *ShowDiagnoseTabletContext) interface{} + + // Visit a parse tree produced by DorisParser#showOpenTables. + VisitShowOpenTables(ctx *ShowOpenTablesContext) interface{} + + // Visit a parse tree produced by DorisParser#showFrontends. + VisitShowFrontends(ctx *ShowFrontendsContext) interface{} + + // Visit a parse tree produced by DorisParser#showDatabaseId. + VisitShowDatabaseId(ctx *ShowDatabaseIdContext) interface{} + + // Visit a parse tree produced by DorisParser#showColumns. + VisitShowColumns(ctx *ShowColumnsContext) interface{} + + // Visit a parse tree produced by DorisParser#showTableId. + VisitShowTableId(ctx *ShowTableIdContext) interface{} + + // Visit a parse tree produced by DorisParser#showTrash. + VisitShowTrash(ctx *ShowTrashContext) interface{} + + // Visit a parse tree produced by DorisParser#showTypeCast. + VisitShowTypeCast(ctx *ShowTypeCastContext) interface{} + + // Visit a parse tree produced by DorisParser#showClusters. + VisitShowClusters(ctx *ShowClustersContext) interface{} + + // Visit a parse tree produced by DorisParser#showStatus. + VisitShowStatus(ctx *ShowStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#showWhitelist. + VisitShowWhitelist(ctx *ShowWhitelistContext) interface{} + + // Visit a parse tree produced by DorisParser#showTabletsBelong. + VisitShowTabletsBelong(ctx *ShowTabletsBelongContext) interface{} + + // Visit a parse tree produced by DorisParser#showDataSkew. + VisitShowDataSkew(ctx *ShowDataSkewContext) interface{} + + // Visit a parse tree produced by DorisParser#showTableCreation. + VisitShowTableCreation(ctx *ShowTableCreationContext) interface{} + + // Visit a parse tree produced by DorisParser#showTabletStorageFormat. + VisitShowTabletStorageFormat(ctx *ShowTabletStorageFormatContext) interface{} + + // Visit a parse tree produced by DorisParser#showQueryProfile. + VisitShowQueryProfile(ctx *ShowQueryProfileContext) interface{} + + // Visit a parse tree produced by DorisParser#showConvertLsc. + VisitShowConvertLsc(ctx *ShowConvertLscContext) interface{} + + // Visit a parse tree produced by DorisParser#showTables. + VisitShowTables(ctx *ShowTablesContext) interface{} + + // Visit a parse tree produced by DorisParser#showViews. + VisitShowViews(ctx *ShowViewsContext) interface{} + + // Visit a parse tree produced by DorisParser#showTableStatus. + VisitShowTableStatus(ctx *ShowTableStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#showDatabases. + VisitShowDatabases(ctx *ShowDatabasesContext) interface{} + + // Visit a parse tree produced by DorisParser#showTabletsFromTable. + VisitShowTabletsFromTable(ctx *ShowTabletsFromTableContext) interface{} + + // Visit a parse tree produced by DorisParser#showCatalogRecycleBin. + VisitShowCatalogRecycleBin(ctx *ShowCatalogRecycleBinContext) interface{} + + // Visit a parse tree produced by DorisParser#showTabletId. + VisitShowTabletId(ctx *ShowTabletIdContext) interface{} + + // Visit a parse tree produced by DorisParser#showDictionaries. + VisitShowDictionaries(ctx *ShowDictionariesContext) interface{} + + // Visit a parse tree produced by DorisParser#showTransaction. + VisitShowTransaction(ctx *ShowTransactionContext) interface{} + + // Visit a parse tree produced by DorisParser#showReplicaStatus. + VisitShowReplicaStatus(ctx *ShowReplicaStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#showWorkloadGroups. + VisitShowWorkloadGroups(ctx *ShowWorkloadGroupsContext) interface{} + + // Visit a parse tree produced by DorisParser#showCopy. + VisitShowCopy(ctx *ShowCopyContext) interface{} + + // Visit a parse tree produced by DorisParser#showQueryStats. + VisitShowQueryStats(ctx *ShowQueryStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#showIndex. + VisitShowIndex(ctx *ShowIndexContext) interface{} + + // Visit a parse tree produced by DorisParser#showWarmUpJob. + VisitShowWarmUpJob(ctx *ShowWarmUpJobContext) interface{} + + // Visit a parse tree produced by DorisParser#sync. + VisitSync(ctx *SyncContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateLoad. + VisitShowCreateLoad(ctx *ShowCreateLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#createRoutineLoadAlias. + VisitCreateRoutineLoadAlias(ctx *CreateRoutineLoadAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#mysqlLoad. + VisitMysqlLoad(ctx *MysqlLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#showCreateRoutineLoad. + VisitShowCreateRoutineLoad(ctx *ShowCreateRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#pauseRoutineLoad. + VisitPauseRoutineLoad(ctx *PauseRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#pauseAllRoutineLoad. + VisitPauseAllRoutineLoad(ctx *PauseAllRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#resumeRoutineLoad. + VisitResumeRoutineLoad(ctx *ResumeRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#resumeAllRoutineLoad. + VisitResumeAllRoutineLoad(ctx *ResumeAllRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#stopRoutineLoad. + VisitStopRoutineLoad(ctx *StopRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#showRoutineLoad. + VisitShowRoutineLoad(ctx *ShowRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#showRoutineLoadTask. + VisitShowRoutineLoadTask(ctx *ShowRoutineLoadTaskContext) interface{} + + // Visit a parse tree produced by DorisParser#showIndexAnalyzer. + VisitShowIndexAnalyzer(ctx *ShowIndexAnalyzerContext) interface{} + + // Visit a parse tree produced by DorisParser#showIndexTokenizer. + VisitShowIndexTokenizer(ctx *ShowIndexTokenizerContext) interface{} + + // Visit a parse tree produced by DorisParser#showIndexTokenFilter. + VisitShowIndexTokenFilter(ctx *ShowIndexTokenFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#showIndexCharFilter. + VisitShowIndexCharFilter(ctx *ShowIndexCharFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#killConnection. + VisitKillConnection(ctx *KillConnectionContext) interface{} + + // Visit a parse tree produced by DorisParser#killQuery. + VisitKillQuery(ctx *KillQueryContext) interface{} + + // Visit a parse tree produced by DorisParser#help. + VisitHelp(ctx *HelpContext) interface{} + + // Visit a parse tree produced by DorisParser#unlockTables. + VisitUnlockTables(ctx *UnlockTablesContext) interface{} + + // Visit a parse tree produced by DorisParser#installPlugin. + VisitInstallPlugin(ctx *InstallPluginContext) interface{} + + // Visit a parse tree produced by DorisParser#uninstallPlugin. + VisitUninstallPlugin(ctx *UninstallPluginContext) interface{} + + // Visit a parse tree produced by DorisParser#lockTables. + VisitLockTables(ctx *LockTablesContext) interface{} + + // Visit a parse tree produced by DorisParser#restore. + VisitRestore(ctx *RestoreContext) interface{} + + // Visit a parse tree produced by DorisParser#warmUpCluster. + VisitWarmUpCluster(ctx *WarmUpClusterContext) interface{} + + // Visit a parse tree produced by DorisParser#warmUpSelect. + VisitWarmUpSelect(ctx *WarmUpSelectContext) interface{} + + // Visit a parse tree produced by DorisParser#backup. + VisitBackup(ctx *BackupContext) interface{} + + // Visit a parse tree produced by DorisParser#unsupportedStartTransaction. + VisitUnsupportedStartTransaction(ctx *UnsupportedStartTransactionContext) interface{} + + // Visit a parse tree produced by DorisParser#warmUpItem. + VisitWarmUpItem(ctx *WarmUpItemContext) interface{} + + // Visit a parse tree produced by DorisParser#warmUpSingleTableRef. + VisitWarmUpSingleTableRef(ctx *WarmUpSingleTableRefContext) interface{} + + // Visit a parse tree produced by DorisParser#lockTable. + VisitLockTable(ctx *LockTableContext) interface{} + + // Visit a parse tree produced by DorisParser#createRoutineLoad. + VisitCreateRoutineLoad(ctx *CreateRoutineLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#separator. + VisitSeparator(ctx *SeparatorContext) interface{} + + // Visit a parse tree produced by DorisParser#importColumns. + VisitImportColumns(ctx *ImportColumnsContext) interface{} + + // Visit a parse tree produced by DorisParser#importPrecedingFilter. + VisitImportPrecedingFilter(ctx *ImportPrecedingFilterContext) interface{} + + // Visit a parse tree produced by DorisParser#importWhere. + VisitImportWhere(ctx *ImportWhereContext) interface{} + + // Visit a parse tree produced by DorisParser#importDeleteOn. + VisitImportDeleteOn(ctx *ImportDeleteOnContext) interface{} + + // Visit a parse tree produced by DorisParser#importSequence. + VisitImportSequence(ctx *ImportSequenceContext) interface{} + + // Visit a parse tree produced by DorisParser#importPartitions. + VisitImportPartitions(ctx *ImportPartitionsContext) interface{} + + // Visit a parse tree produced by DorisParser#importSequenceStatement. + VisitImportSequenceStatement(ctx *ImportSequenceStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#importDeleteOnStatement. + VisitImportDeleteOnStatement(ctx *ImportDeleteOnStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#importWhereStatement. + VisitImportWhereStatement(ctx *ImportWhereStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#importPrecedingFilterStatement. + VisitImportPrecedingFilterStatement(ctx *ImportPrecedingFilterStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#importColumnsStatement. + VisitImportColumnsStatement(ctx *ImportColumnsStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#importColumnDesc. + VisitImportColumnDesc(ctx *ImportColumnDescContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshCatalog. + VisitRefreshCatalog(ctx *RefreshCatalogContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshDatabase. + VisitRefreshDatabase(ctx *RefreshDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshTable. + VisitRefreshTable(ctx *RefreshTableContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshDictionary. + VisitRefreshDictionary(ctx *RefreshDictionaryContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshLdap. + VisitRefreshLdap(ctx *RefreshLdapContext) interface{} + + // Visit a parse tree produced by DorisParser#cleanAllProfile. + VisitCleanAllProfile(ctx *CleanAllProfileContext) interface{} + + // Visit a parse tree produced by DorisParser#cleanLabel. + VisitCleanLabel(ctx *CleanLabelContext) interface{} + + // Visit a parse tree produced by DorisParser#cleanQueryStats. + VisitCleanQueryStats(ctx *CleanQueryStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#cleanAllQueryStats. + VisitCleanAllQueryStats(ctx *CleanAllQueryStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelLoad. + VisitCancelLoad(ctx *CancelLoadContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelExport. + VisitCancelExport(ctx *CancelExportContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelWarmUpJob. + VisitCancelWarmUpJob(ctx *CancelWarmUpJobContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelDecommisionBackend. + VisitCancelDecommisionBackend(ctx *CancelDecommisionBackendContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelBackup. + VisitCancelBackup(ctx *CancelBackupContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelRestore. + VisitCancelRestore(ctx *CancelRestoreContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelBuildIndex. + VisitCancelBuildIndex(ctx *CancelBuildIndexContext) interface{} + + // Visit a parse tree produced by DorisParser#cancelAlterTable. + VisitCancelAlterTable(ctx *CancelAlterTableContext) interface{} + + // Visit a parse tree produced by DorisParser#adminShowReplicaDistribution. + VisitAdminShowReplicaDistribution(ctx *AdminShowReplicaDistributionContext) interface{} + + // Visit a parse tree produced by DorisParser#adminRebalanceDisk. + VisitAdminRebalanceDisk(ctx *AdminRebalanceDiskContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCancelRebalanceDisk. + VisitAdminCancelRebalanceDisk(ctx *AdminCancelRebalanceDiskContext) interface{} + + // Visit a parse tree produced by DorisParser#adminDiagnoseTablet. + VisitAdminDiagnoseTablet(ctx *AdminDiagnoseTabletContext) interface{} + + // Visit a parse tree produced by DorisParser#adminShowReplicaStatus. + VisitAdminShowReplicaStatus(ctx *AdminShowReplicaStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCompactTable. + VisitAdminCompactTable(ctx *AdminCompactTableContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCheckTablets. + VisitAdminCheckTablets(ctx *AdminCheckTabletsContext) interface{} + + // Visit a parse tree produced by DorisParser#adminShowTabletStorageFormat. + VisitAdminShowTabletStorageFormat(ctx *AdminShowTabletStorageFormatContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetFrontendConfig. + VisitAdminSetFrontendConfig(ctx *AdminSetFrontendConfigContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCleanTrash. + VisitAdminCleanTrash(ctx *AdminCleanTrashContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetReplicaVersion. + VisitAdminSetReplicaVersion(ctx *AdminSetReplicaVersionContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetTableStatus. + VisitAdminSetTableStatus(ctx *AdminSetTableStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetReplicaStatus. + VisitAdminSetReplicaStatus(ctx *AdminSetReplicaStatusContext) interface{} + + // Visit a parse tree produced by DorisParser#adminRepairTable. + VisitAdminRepairTable(ctx *AdminRepairTableContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCancelRepairTable. + VisitAdminCancelRepairTable(ctx *AdminCancelRepairTableContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCopyTablet. + VisitAdminCopyTablet(ctx *AdminCopyTabletContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetEncryptionRootKey. + VisitAdminSetEncryptionRootKey(ctx *AdminSetEncryptionRootKeyContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetPartitionVersion. + VisitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) interface{} + + // Visit a parse tree produced by DorisParser#adminCreateClusterSnapshot. + VisitAdminCreateClusterSnapshot(ctx *AdminCreateClusterSnapshotContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetAutoClusterSnapshot. + VisitAdminSetAutoClusterSnapshot(ctx *AdminSetAutoClusterSnapshotContext) interface{} + + // Visit a parse tree produced by DorisParser#adminDropClusterSnapshot. + VisitAdminDropClusterSnapshot(ctx *AdminDropClusterSnapshotContext) interface{} + + // Visit a parse tree produced by DorisParser#adminSetClusterSnapshotFeatureSwitch. + VisitAdminSetClusterSnapshotFeatureSwitch(ctx *AdminSetClusterSnapshotFeatureSwitchContext) interface{} + + // Visit a parse tree produced by DorisParser#adminRotateTdeRootKey. + VisitAdminRotateTdeRootKey(ctx *AdminRotateTdeRootKeyContext) interface{} + + // Visit a parse tree produced by DorisParser#recoverDatabase. + VisitRecoverDatabase(ctx *RecoverDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#recoverTable. + VisitRecoverTable(ctx *RecoverTableContext) interface{} + + // Visit a parse tree produced by DorisParser#recoverPartition. + VisitRecoverPartition(ctx *RecoverPartitionContext) interface{} + + // Visit a parse tree produced by DorisParser#baseTableRef. + VisitBaseTableRef(ctx *BaseTableRefContext) interface{} + + // Visit a parse tree produced by DorisParser#wildWhere. + VisitWildWhere(ctx *WildWhereContext) interface{} + + // Visit a parse tree produced by DorisParser#transactionBegin. + VisitTransactionBegin(ctx *TransactionBeginContext) interface{} + + // Visit a parse tree produced by DorisParser#transcationCommit. + VisitTranscationCommit(ctx *TranscationCommitContext) interface{} + + // Visit a parse tree produced by DorisParser#transactionRollback. + VisitTransactionRollback(ctx *TransactionRollbackContext) interface{} + + // Visit a parse tree produced by DorisParser#grantTablePrivilege. + VisitGrantTablePrivilege(ctx *GrantTablePrivilegeContext) interface{} + + // Visit a parse tree produced by DorisParser#grantResourcePrivilege. + VisitGrantResourcePrivilege(ctx *GrantResourcePrivilegeContext) interface{} + + // Visit a parse tree produced by DorisParser#grantRole. + VisitGrantRole(ctx *GrantRoleContext) interface{} + + // Visit a parse tree produced by DorisParser#revokeRole. + VisitRevokeRole(ctx *RevokeRoleContext) interface{} + + // Visit a parse tree produced by DorisParser#revokeResourcePrivilege. + VisitRevokeResourcePrivilege(ctx *RevokeResourcePrivilegeContext) interface{} + + // Visit a parse tree produced by DorisParser#revokeTablePrivilege. + VisitRevokeTablePrivilege(ctx *RevokeTablePrivilegeContext) interface{} + + // Visit a parse tree produced by DorisParser#privilege. + VisitPrivilege(ctx *PrivilegeContext) interface{} + + // Visit a parse tree produced by DorisParser#privilegeList. + VisitPrivilegeList(ctx *PrivilegeListContext) interface{} + + // Visit a parse tree produced by DorisParser#addBackendClause. + VisitAddBackendClause(ctx *AddBackendClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropBackendClause. + VisitDropBackendClause(ctx *DropBackendClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#decommissionBackendClause. + VisitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addObserverClause. + VisitAddObserverClause(ctx *AddObserverClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropObserverClause. + VisitDropObserverClause(ctx *DropObserverClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addFollowerClause. + VisitAddFollowerClause(ctx *AddFollowerClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropFollowerClause. + VisitDropFollowerClause(ctx *DropFollowerClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addBrokerClause. + VisitAddBrokerClause(ctx *AddBrokerClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropBrokerClause. + VisitDropBrokerClause(ctx *DropBrokerClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropAllBrokerClause. + VisitDropAllBrokerClause(ctx *DropAllBrokerClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#alterLoadErrorUrlClause. + VisitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyBackendClause. + VisitModifyBackendClause(ctx *ModifyBackendClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyFrontendOrBackendHostNameClause. + VisitModifyFrontendOrBackendHostNameClause(ctx *ModifyFrontendOrBackendHostNameClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropRollupClause. + VisitDropRollupClause(ctx *DropRollupClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addRollupClause. + VisitAddRollupClause(ctx *AddRollupClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addColumnClause. + VisitAddColumnClause(ctx *AddColumnClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addColumnsClause. + VisitAddColumnsClause(ctx *AddColumnsClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropColumnClause. + VisitDropColumnClause(ctx *DropColumnClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyColumnClause. + VisitModifyColumnClause(ctx *ModifyColumnClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#reorderColumnsClause. + VisitReorderColumnsClause(ctx *ReorderColumnsClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addPartitionClause. + VisitAddPartitionClause(ctx *AddPartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropPartitionClause. + VisitDropPartitionClause(ctx *DropPartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyPartitionClause. + VisitModifyPartitionClause(ctx *ModifyPartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#replacePartitionClause. + VisitReplacePartitionClause(ctx *ReplacePartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#replaceTableClause. + VisitReplaceTableClause(ctx *ReplaceTableClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#renameClause. + VisitRenameClause(ctx *RenameClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#renameRollupClause. + VisitRenameRollupClause(ctx *RenameRollupClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#renamePartitionClause. + VisitRenamePartitionClause(ctx *RenamePartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#renameColumnClause. + VisitRenameColumnClause(ctx *RenameColumnClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#addIndexClause. + VisitAddIndexClause(ctx *AddIndexClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropIndexClause. + VisitDropIndexClause(ctx *DropIndexClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#enableFeatureClause. + VisitEnableFeatureClause(ctx *EnableFeatureClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyDistributionClause. + VisitModifyDistributionClause(ctx *ModifyDistributionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyTableCommentClause. + VisitModifyTableCommentClause(ctx *ModifyTableCommentClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyColumnCommentClause. + VisitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#modifyEngineClause. + VisitModifyEngineClause(ctx *ModifyEngineClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#alterMultiPartitionClause. + VisitAlterMultiPartitionClause(ctx *AlterMultiPartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#createOrReplaceTagClauses. + VisitCreateOrReplaceTagClauses(ctx *CreateOrReplaceTagClausesContext) interface{} + + // Visit a parse tree produced by DorisParser#createOrReplaceBranchClauses. + VisitCreateOrReplaceBranchClauses(ctx *CreateOrReplaceBranchClausesContext) interface{} + + // Visit a parse tree produced by DorisParser#dropBranchClauses. + VisitDropBranchClauses(ctx *DropBranchClausesContext) interface{} + + // Visit a parse tree produced by DorisParser#dropTagClauses. + VisitDropTagClauses(ctx *DropTagClausesContext) interface{} + + // Visit a parse tree produced by DorisParser#addPartitionFieldClause. + VisitAddPartitionFieldClause(ctx *AddPartitionFieldClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropPartitionFieldClause. + VisitDropPartitionFieldClause(ctx *DropPartitionFieldClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#replacePartitionFieldClause. + VisitReplacePartitionFieldClause(ctx *ReplacePartitionFieldClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#createOrReplaceTagClause. + VisitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#createOrReplaceBranchClause. + VisitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#tagOptions. + VisitTagOptions(ctx *TagOptionsContext) interface{} + + // Visit a parse tree produced by DorisParser#branchOptions. + VisitBranchOptions(ctx *BranchOptionsContext) interface{} + + // Visit a parse tree produced by DorisParser#retainTime. + VisitRetainTime(ctx *RetainTimeContext) interface{} + + // Visit a parse tree produced by DorisParser#retentionSnapshot. + VisitRetentionSnapshot(ctx *RetentionSnapshotContext) interface{} + + // Visit a parse tree produced by DorisParser#minSnapshotsToKeep. + VisitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) interface{} + + // Visit a parse tree produced by DorisParser#timeValueWithUnit. + VisitTimeValueWithUnit(ctx *TimeValueWithUnitContext) interface{} + + // Visit a parse tree produced by DorisParser#dropBranchClause. + VisitDropBranchClause(ctx *DropBranchClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#dropTagClause. + VisitDropTagClause(ctx *DropTagClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionTransformWithArgs. + VisitPartitionTransformWithArgs(ctx *PartitionTransformWithArgsContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionTransformWithColumn. + VisitPartitionTransformWithColumn(ctx *PartitionTransformWithColumnContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionTransformIdentity. + VisitPartitionTransformIdentity(ctx *PartitionTransformIdentityContext) interface{} + + // Visit a parse tree produced by DorisParser#columnPosition. + VisitColumnPosition(ctx *ColumnPositionContext) interface{} + + // Visit a parse tree produced by DorisParser#toRollup. + VisitToRollup(ctx *ToRollupContext) interface{} + + // Visit a parse tree produced by DorisParser#fromRollup. + VisitFromRollup(ctx *FromRollupContext) interface{} + + // Visit a parse tree produced by DorisParser#showAnalyze. + VisitShowAnalyze(ctx *ShowAnalyzeContext) interface{} + + // Visit a parse tree produced by DorisParser#showQueuedAnalyzeJobs. + VisitShowQueuedAnalyzeJobs(ctx *ShowQueuedAnalyzeJobsContext) interface{} + + // Visit a parse tree produced by DorisParser#showColumnHistogramStats. + VisitShowColumnHistogramStats(ctx *ShowColumnHistogramStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#showColumnStats. + VisitShowColumnStats(ctx *ShowColumnStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#showAnalyzeTask. + VisitShowAnalyzeTask(ctx *ShowAnalyzeTaskContext) interface{} + + // Visit a parse tree produced by DorisParser#analyzeDatabase. + VisitAnalyzeDatabase(ctx *AnalyzeDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#analyzeTable. + VisitAnalyzeTable(ctx *AnalyzeTableContext) interface{} + + // Visit a parse tree produced by DorisParser#alterTableStats. + VisitAlterTableStats(ctx *AlterTableStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#alterColumnStats. + VisitAlterColumnStats(ctx *AlterColumnStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#showIndexStats. + VisitShowIndexStats(ctx *ShowIndexStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#dropStats. + VisitDropStats(ctx *DropStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#dropCachedStats. + VisitDropCachedStats(ctx *DropCachedStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#dropExpiredStats. + VisitDropExpiredStats(ctx *DropExpiredStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#killAnalyzeJob. + VisitKillAnalyzeJob(ctx *KillAnalyzeJobContext) interface{} + + // Visit a parse tree produced by DorisParser#dropAnalyzeJob. + VisitDropAnalyzeJob(ctx *DropAnalyzeJobContext) interface{} + + // Visit a parse tree produced by DorisParser#showTableStats. + VisitShowTableStats(ctx *ShowTableStatsContext) interface{} + + // Visit a parse tree produced by DorisParser#analyzeProperties. + VisitAnalyzeProperties(ctx *AnalyzePropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#workloadPolicyActions. + VisitWorkloadPolicyActions(ctx *WorkloadPolicyActionsContext) interface{} + + // Visit a parse tree produced by DorisParser#workloadPolicyAction. + VisitWorkloadPolicyAction(ctx *WorkloadPolicyActionContext) interface{} + + // Visit a parse tree produced by DorisParser#workloadPolicyConditions. + VisitWorkloadPolicyConditions(ctx *WorkloadPolicyConditionsContext) interface{} + + // Visit a parse tree produced by DorisParser#workloadPolicyCondition. + VisitWorkloadPolicyCondition(ctx *WorkloadPolicyConditionContext) interface{} + + // Visit a parse tree produced by DorisParser#storageBackend. + VisitStorageBackend(ctx *StorageBackendContext) interface{} + + // Visit a parse tree produced by DorisParser#passwordOption. + VisitPasswordOption(ctx *PasswordOptionContext) interface{} + + // Visit a parse tree produced by DorisParser#functionArguments. + VisitFunctionArguments(ctx *FunctionArgumentsContext) interface{} + + // Visit a parse tree produced by DorisParser#dataTypeList. + VisitDataTypeList(ctx *DataTypeListContext) interface{} + + // Visit a parse tree produced by DorisParser#setOptions. + VisitSetOptions(ctx *SetOptionsContext) interface{} + + // Visit a parse tree produced by DorisParser#setDefaultStorageVault. + VisitSetDefaultStorageVault(ctx *SetDefaultStorageVaultContext) interface{} + + // Visit a parse tree produced by DorisParser#setUserProperties. + VisitSetUserProperties(ctx *SetUserPropertiesContext) interface{} + + // Visit a parse tree produced by DorisParser#setTransaction. + VisitSetTransaction(ctx *SetTransactionContext) interface{} + + // Visit a parse tree produced by DorisParser#setVariableWithType. + VisitSetVariableWithType(ctx *SetVariableWithTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#setNames. + VisitSetNames(ctx *SetNamesContext) interface{} + + // Visit a parse tree produced by DorisParser#setCharset. + VisitSetCharset(ctx *SetCharsetContext) interface{} + + // Visit a parse tree produced by DorisParser#setCollate. + VisitSetCollate(ctx *SetCollateContext) interface{} + + // Visit a parse tree produced by DorisParser#setPassword. + VisitSetPassword(ctx *SetPasswordContext) interface{} + + // Visit a parse tree produced by DorisParser#setLdapAdminPassword. + VisitSetLdapAdminPassword(ctx *SetLdapAdminPasswordContext) interface{} + + // Visit a parse tree produced by DorisParser#setVariableWithoutType. + VisitSetVariableWithoutType(ctx *SetVariableWithoutTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#setSystemVariable. + VisitSetSystemVariable(ctx *SetSystemVariableContext) interface{} + + // Visit a parse tree produced by DorisParser#setUserVariable. + VisitSetUserVariable(ctx *SetUserVariableContext) interface{} + + // Visit a parse tree produced by DorisParser#transactionAccessMode. + VisitTransactionAccessMode(ctx *TransactionAccessModeContext) interface{} + + // Visit a parse tree produced by DorisParser#isolationLevel. + VisitIsolationLevel(ctx *IsolationLevelContext) interface{} + + // Visit a parse tree produced by DorisParser#supportedUnsetStatement. + VisitSupportedUnsetStatement(ctx *SupportedUnsetStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#switchCatalog. + VisitSwitchCatalog(ctx *SwitchCatalogContext) interface{} + + // Visit a parse tree produced by DorisParser#useDatabase. + VisitUseDatabase(ctx *UseDatabaseContext) interface{} + + // Visit a parse tree produced by DorisParser#useCloudCluster. + VisitUseCloudCluster(ctx *UseCloudClusterContext) interface{} + + // Visit a parse tree produced by DorisParser#stageAndPattern. + VisitStageAndPattern(ctx *StageAndPatternContext) interface{} + + // Visit a parse tree produced by DorisParser#describeTableValuedFunction. + VisitDescribeTableValuedFunction(ctx *DescribeTableValuedFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#describeTableAll. + VisitDescribeTableAll(ctx *DescribeTableAllContext) interface{} + + // Visit a parse tree produced by DorisParser#describeTable. + VisitDescribeTable(ctx *DescribeTableContext) interface{} + + // Visit a parse tree produced by DorisParser#describeDictionary. + VisitDescribeDictionary(ctx *DescribeDictionaryContext) interface{} + + // Visit a parse tree produced by DorisParser#constraint. + VisitConstraint(ctx *ConstraintContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionSpec. + VisitPartitionSpec(ctx *PartitionSpecContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionTable. + VisitPartitionTable(ctx *PartitionTableContext) interface{} + + // Visit a parse tree produced by DorisParser#identityOrFunctionList. + VisitIdentityOrFunctionList(ctx *IdentityOrFunctionListContext) interface{} + + // Visit a parse tree produced by DorisParser#identityOrFunction. + VisitIdentityOrFunction(ctx *IdentityOrFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#dataDesc. + VisitDataDesc(ctx *DataDescContext) interface{} + + // Visit a parse tree produced by DorisParser#statementScope. + VisitStatementScope(ctx *StatementScopeContext) interface{} + + // Visit a parse tree produced by DorisParser#buildMode. + VisitBuildMode(ctx *BuildModeContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshTrigger. + VisitRefreshTrigger(ctx *RefreshTriggerContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshSchedule. + VisitRefreshSchedule(ctx *RefreshScheduleContext) interface{} + + // Visit a parse tree produced by DorisParser#refreshMethod. + VisitRefreshMethod(ctx *RefreshMethodContext) interface{} + + // Visit a parse tree produced by DorisParser#mvPartition. + VisitMvPartition(ctx *MvPartitionContext) interface{} + + // Visit a parse tree produced by DorisParser#identifierOrText. + VisitIdentifierOrText(ctx *IdentifierOrTextContext) interface{} + + // Visit a parse tree produced by DorisParser#identifierOrTextOrAsterisk. + VisitIdentifierOrTextOrAsterisk(ctx *IdentifierOrTextOrAsteriskContext) interface{} + + // Visit a parse tree produced by DorisParser#multipartIdentifierOrAsterisk. + VisitMultipartIdentifierOrAsterisk(ctx *MultipartIdentifierOrAsteriskContext) interface{} + + // Visit a parse tree produced by DorisParser#identifierOrAsterisk. + VisitIdentifierOrAsterisk(ctx *IdentifierOrAsteriskContext) interface{} + + // Visit a parse tree produced by DorisParser#userIdentify. + VisitUserIdentify(ctx *UserIdentifyContext) interface{} + + // Visit a parse tree produced by DorisParser#grantUserIdentify. + VisitGrantUserIdentify(ctx *GrantUserIdentifyContext) interface{} + + // Visit a parse tree produced by DorisParser#explain. + VisitExplain(ctx *ExplainContext) interface{} + + // Visit a parse tree produced by DorisParser#explainCommand. + VisitExplainCommand(ctx *ExplainCommandContext) interface{} + + // Visit a parse tree produced by DorisParser#planType. + VisitPlanType(ctx *PlanTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#replayCommand. + VisitReplayCommand(ctx *ReplayCommandContext) interface{} + + // Visit a parse tree produced by DorisParser#replayType. + VisitReplayType(ctx *ReplayTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#mergeType. + VisitMergeType(ctx *MergeTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#preFilterClause. + VisitPreFilterClause(ctx *PreFilterClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#deleteOnClause. + VisitDeleteOnClause(ctx *DeleteOnClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#sequenceColClause. + VisitSequenceColClause(ctx *SequenceColClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#colFromPath. + VisitColFromPath(ctx *ColFromPathContext) interface{} + + // Visit a parse tree produced by DorisParser#colMappingList. + VisitColMappingList(ctx *ColMappingListContext) interface{} + + // Visit a parse tree produced by DorisParser#mappingExpr. + VisitMappingExpr(ctx *MappingExprContext) interface{} + + // Visit a parse tree produced by DorisParser#withRemoteStorageSystem. + VisitWithRemoteStorageSystem(ctx *WithRemoteStorageSystemContext) interface{} + + // Visit a parse tree produced by DorisParser#resourceDesc. + VisitResourceDesc(ctx *ResourceDescContext) interface{} + + // Visit a parse tree produced by DorisParser#mysqlDataDesc. + VisitMysqlDataDesc(ctx *MysqlDataDescContext) interface{} + + // Visit a parse tree produced by DorisParser#skipLines. + VisitSkipLines(ctx *SkipLinesContext) interface{} + + // Visit a parse tree produced by DorisParser#outFileClause. + VisitOutFileClause(ctx *OutFileClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#query. + VisitQuery(ctx *QueryContext) interface{} + + // Visit a parse tree produced by DorisParser#queryTermDefault. + VisitQueryTermDefault(ctx *QueryTermDefaultContext) interface{} + + // Visit a parse tree produced by DorisParser#setOperation. + VisitSetOperation(ctx *SetOperationContext) interface{} + + // Visit a parse tree produced by DorisParser#setQuantifier. + VisitSetQuantifier(ctx *SetQuantifierContext) interface{} + + // Visit a parse tree produced by DorisParser#queryPrimaryDefault. + VisitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) interface{} + + // Visit a parse tree produced by DorisParser#subquery. + VisitSubquery(ctx *SubqueryContext) interface{} + + // Visit a parse tree produced by DorisParser#valuesTable. + VisitValuesTable(ctx *ValuesTableContext) interface{} + + // Visit a parse tree produced by DorisParser#regularQuerySpecification. + VisitRegularQuerySpecification(ctx *RegularQuerySpecificationContext) interface{} + + // Visit a parse tree produced by DorisParser#cte. + VisitCte(ctx *CteContext) interface{} + + // Visit a parse tree produced by DorisParser#aliasQuery. + VisitAliasQuery(ctx *AliasQueryContext) interface{} + + // Visit a parse tree produced by DorisParser#columnAliases. + VisitColumnAliases(ctx *ColumnAliasesContext) interface{} + + // Visit a parse tree produced by DorisParser#selectClause. + VisitSelectClause(ctx *SelectClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#selectColumnClause. + VisitSelectColumnClause(ctx *SelectColumnClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#whereClause. + VisitWhereClause(ctx *WhereClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#fromClause. + VisitFromClause(ctx *FromClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#intoClause. + VisitIntoClause(ctx *IntoClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#bulkCollectClause. + VisitBulkCollectClause(ctx *BulkCollectClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#tableRow. + VisitTableRow(ctx *TableRowContext) interface{} + + // Visit a parse tree produced by DorisParser#relations. + VisitRelations(ctx *RelationsContext) interface{} + + // Visit a parse tree produced by DorisParser#relation. + VisitRelation(ctx *RelationContext) interface{} + + // Visit a parse tree produced by DorisParser#joinRelation. + VisitJoinRelation(ctx *JoinRelationContext) interface{} + + // Visit a parse tree produced by DorisParser#distributeType. + VisitDistributeType(ctx *DistributeTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#skewHint. + VisitSkewHint(ctx *SkewHintContext) interface{} + + // Visit a parse tree produced by DorisParser#constantList. + VisitConstantList(ctx *ConstantListContext) interface{} + + // Visit a parse tree produced by DorisParser#bracketRelationHint. + VisitBracketRelationHint(ctx *BracketRelationHintContext) interface{} + + // Visit a parse tree produced by DorisParser#commentRelationHint. + VisitCommentRelationHint(ctx *CommentRelationHintContext) interface{} + + // Visit a parse tree produced by DorisParser#expressionWithOrder. + VisitExpressionWithOrder(ctx *ExpressionWithOrderContext) interface{} + + // Visit a parse tree produced by DorisParser#aggClause. + VisitAggClause(ctx *AggClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#groupingElement. + VisitGroupingElement(ctx *GroupingElementContext) interface{} + + // Visit a parse tree produced by DorisParser#groupingSet. + VisitGroupingSet(ctx *GroupingSetContext) interface{} + + // Visit a parse tree produced by DorisParser#havingClause. + VisitHavingClause(ctx *HavingClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#qualifyClause. + VisitQualifyClause(ctx *QualifyClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#selectHint. + VisitSelectHint(ctx *SelectHintContext) interface{} + + // Visit a parse tree produced by DorisParser#hintStatement. + VisitHintStatement(ctx *HintStatementContext) interface{} + + // Visit a parse tree produced by DorisParser#hintName. + VisitHintName(ctx *HintNameContext) interface{} + + // Visit a parse tree produced by DorisParser#hintAssignment. + VisitHintAssignment(ctx *HintAssignmentContext) interface{} + + // Visit a parse tree produced by DorisParser#updateAssignment. + VisitUpdateAssignment(ctx *UpdateAssignmentContext) interface{} + + // Visit a parse tree produced by DorisParser#updateAssignmentSeq. + VisitUpdateAssignmentSeq(ctx *UpdateAssignmentSeqContext) interface{} + + // Visit a parse tree produced by DorisParser#lateralView. + VisitLateralView(ctx *LateralViewContext) interface{} + + // Visit a parse tree produced by DorisParser#queryOrganization. + VisitQueryOrganization(ctx *QueryOrganizationContext) interface{} + + // Visit a parse tree produced by DorisParser#sortClause. + VisitSortClause(ctx *SortClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#sortItem. + VisitSortItem(ctx *SortItemContext) interface{} + + // Visit a parse tree produced by DorisParser#limitClause. + VisitLimitClause(ctx *LimitClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionClause. + VisitPartitionClause(ctx *PartitionClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#joinType. + VisitJoinType(ctx *JoinTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#joinCriteria. + VisitJoinCriteria(ctx *JoinCriteriaContext) interface{} + + // Visit a parse tree produced by DorisParser#identifierList. + VisitIdentifierList(ctx *IdentifierListContext) interface{} + + // Visit a parse tree produced by DorisParser#identifierSeq. + VisitIdentifierSeq(ctx *IdentifierSeqContext) interface{} + + // Visit a parse tree produced by DorisParser#optScanParams. + VisitOptScanParams(ctx *OptScanParamsContext) interface{} + + // Visit a parse tree produced by DorisParser#tableName. + VisitTableName(ctx *TableNameContext) interface{} + + // Visit a parse tree produced by DorisParser#aliasedQuery. + VisitAliasedQuery(ctx *AliasedQueryContext) interface{} + + // Visit a parse tree produced by DorisParser#tableValuedFunction. + VisitTableValuedFunction(ctx *TableValuedFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#relationList. + VisitRelationList(ctx *RelationListContext) interface{} + + // Visit a parse tree produced by DorisParser#materializedViewName. + VisitMaterializedViewName(ctx *MaterializedViewNameContext) interface{} + + // Visit a parse tree produced by DorisParser#propertyClause. + VisitPropertyClause(ctx *PropertyClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#propertyItemList. + VisitPropertyItemList(ctx *PropertyItemListContext) interface{} + + // Visit a parse tree produced by DorisParser#propertyItem. + VisitPropertyItem(ctx *PropertyItemContext) interface{} + + // Visit a parse tree produced by DorisParser#propertyKey. + VisitPropertyKey(ctx *PropertyKeyContext) interface{} + + // Visit a parse tree produced by DorisParser#propertyValue. + VisitPropertyValue(ctx *PropertyValueContext) interface{} + + // Visit a parse tree produced by DorisParser#tableAlias. + VisitTableAlias(ctx *TableAliasContext) interface{} + + // Visit a parse tree produced by DorisParser#multipartIdentifier. + VisitMultipartIdentifier(ctx *MultipartIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#simpleColumnDefs. + VisitSimpleColumnDefs(ctx *SimpleColumnDefsContext) interface{} + + // Visit a parse tree produced by DorisParser#simpleColumnDef. + VisitSimpleColumnDef(ctx *SimpleColumnDefContext) interface{} + + // Visit a parse tree produced by DorisParser#columnDefs. + VisitColumnDefs(ctx *ColumnDefsContext) interface{} + + // Visit a parse tree produced by DorisParser#columnDef. + VisitColumnDef(ctx *ColumnDefContext) interface{} + + // Visit a parse tree produced by DorisParser#indexDefs. + VisitIndexDefs(ctx *IndexDefsContext) interface{} + + // Visit a parse tree produced by DorisParser#indexDef. + VisitIndexDef(ctx *IndexDefContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionsDef. + VisitPartitionsDef(ctx *PartitionsDefContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionDef. + VisitPartitionDef(ctx *PartitionDefContext) interface{} + + // Visit a parse tree produced by DorisParser#lessThanPartitionDef. + VisitLessThanPartitionDef(ctx *LessThanPartitionDefContext) interface{} + + // Visit a parse tree produced by DorisParser#fixedPartitionDef. + VisitFixedPartitionDef(ctx *FixedPartitionDefContext) interface{} + + // Visit a parse tree produced by DorisParser#stepPartitionDef. + VisitStepPartitionDef(ctx *StepPartitionDefContext) interface{} + + // Visit a parse tree produced by DorisParser#inPartitionDef. + VisitInPartitionDef(ctx *InPartitionDefContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionValueList. + VisitPartitionValueList(ctx *PartitionValueListContext) interface{} + + // Visit a parse tree produced by DorisParser#partitionValueDef. + VisitPartitionValueDef(ctx *PartitionValueDefContext) interface{} + + // Visit a parse tree produced by DorisParser#rollupDefs. + VisitRollupDefs(ctx *RollupDefsContext) interface{} + + // Visit a parse tree produced by DorisParser#rollupDef. + VisitRollupDef(ctx *RollupDefContext) interface{} + + // Visit a parse tree produced by DorisParser#aggTypeDef. + VisitAggTypeDef(ctx *AggTypeDefContext) interface{} + + // Visit a parse tree produced by DorisParser#tabletList. + VisitTabletList(ctx *TabletListContext) interface{} + + // Visit a parse tree produced by DorisParser#inlineTable. + VisitInlineTable(ctx *InlineTableContext) interface{} + + // Visit a parse tree produced by DorisParser#namedExpression. + VisitNamedExpression(ctx *NamedExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#namedExpressionSeq. + VisitNamedExpressionSeq(ctx *NamedExpressionSeqContext) interface{} + + // Visit a parse tree produced by DorisParser#expression. + VisitExpression(ctx *ExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#funcExpression. + VisitFuncExpression(ctx *FuncExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#lambdaExpression. + VisitLambdaExpression(ctx *LambdaExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#exist. + VisitExist(ctx *ExistContext) interface{} + + // Visit a parse tree produced by DorisParser#logicalNot. + VisitLogicalNot(ctx *LogicalNotContext) interface{} + + // Visit a parse tree produced by DorisParser#predicated. + VisitPredicated(ctx *PredicatedContext) interface{} + + // Visit a parse tree produced by DorisParser#isnull. + VisitIsnull(ctx *IsnullContext) interface{} + + // Visit a parse tree produced by DorisParser#is_not_null_pred. + VisitIs_not_null_pred(ctx *Is_not_null_predContext) interface{} + + // Visit a parse tree produced by DorisParser#logicalBinary. + VisitLogicalBinary(ctx *LogicalBinaryContext) interface{} + + // Visit a parse tree produced by DorisParser#doublePipes. + VisitDoublePipes(ctx *DoublePipesContext) interface{} + + // Visit a parse tree produced by DorisParser#rowConstructor. + VisitRowConstructor(ctx *RowConstructorContext) interface{} + + // Visit a parse tree produced by DorisParser#rowConstructorItem. + VisitRowConstructorItem(ctx *RowConstructorItemContext) interface{} + + // Visit a parse tree produced by DorisParser#predicate. + VisitPredicate(ctx *PredicateContext) interface{} + + // Visit a parse tree produced by DorisParser#valueExpressionDefault. + VisitValueExpressionDefault(ctx *ValueExpressionDefaultContext) interface{} + + // Visit a parse tree produced by DorisParser#comparison. + VisitComparison(ctx *ComparisonContext) interface{} + + // Visit a parse tree produced by DorisParser#arithmeticBinary. + VisitArithmeticBinary(ctx *ArithmeticBinaryContext) interface{} + + // Visit a parse tree produced by DorisParser#arithmeticUnary. + VisitArithmeticUnary(ctx *ArithmeticUnaryContext) interface{} + + // Visit a parse tree produced by DorisParser#dereference. + VisitDereference(ctx *DereferenceContext) interface{} + + // Visit a parse tree produced by DorisParser#currentDate. + VisitCurrentDate(ctx *CurrentDateContext) interface{} + + // Visit a parse tree produced by DorisParser#substring. + VisitSubstring(ctx *SubstringContext) interface{} + + // Visit a parse tree produced by DorisParser#cast. + VisitCast(ctx *CastContext) interface{} + + // Visit a parse tree produced by DorisParser#parenthesizedExpression. + VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#trim. + VisitTrim(ctx *TrimContext) interface{} + + // Visit a parse tree produced by DorisParser#userVariable. + VisitUserVariable(ctx *UserVariableContext) interface{} + + // Visit a parse tree produced by DorisParser#elementAt. + VisitElementAt(ctx *ElementAtContext) interface{} + + // Visit a parse tree produced by DorisParser#localTimestamp. + VisitLocalTimestamp(ctx *LocalTimestampContext) interface{} + + // Visit a parse tree produced by DorisParser#charFunction. + VisitCharFunction(ctx *CharFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#intervalLiteral. + VisitIntervalLiteral(ctx *IntervalLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#groupConcat. + VisitGroupConcat(ctx *GroupConcatContext) interface{} + + // Visit a parse tree produced by DorisParser#simpleCase. + VisitSimpleCase(ctx *SimpleCaseContext) interface{} + + // Visit a parse tree produced by DorisParser#columnReference. + VisitColumnReference(ctx *ColumnReferenceContext) interface{} + + // Visit a parse tree produced by DorisParser#star. + VisitStar(ctx *StarContext) interface{} + + // Visit a parse tree produced by DorisParser#getFormatFunction. + VisitGetFormatFunction(ctx *GetFormatFunctionContext) interface{} + + // Visit a parse tree produced by DorisParser#sessionUser. + VisitSessionUser(ctx *SessionUserContext) interface{} + + // Visit a parse tree produced by DorisParser#convertType. + VisitConvertType(ctx *ConvertTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#convertCharSet. + VisitConvertCharSet(ctx *ConvertCharSetContext) interface{} + + // Visit a parse tree produced by DorisParser#subqueryExpression. + VisitSubqueryExpression(ctx *SubqueryExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#encryptKey. + VisitEncryptKey(ctx *EncryptKeyContext) interface{} + + // Visit a parse tree produced by DorisParser#currentTime. + VisitCurrentTime(ctx *CurrentTimeContext) interface{} + + // Visit a parse tree produced by DorisParser#localTime. + VisitLocalTime(ctx *LocalTimeContext) interface{} + + // Visit a parse tree produced by DorisParser#systemVariable. + VisitSystemVariable(ctx *SystemVariableContext) interface{} + + // Visit a parse tree produced by DorisParser#collate. + VisitCollate(ctx *CollateContext) interface{} + + // Visit a parse tree produced by DorisParser#currentUser. + VisitCurrentUser(ctx *CurrentUserContext) interface{} + + // Visit a parse tree produced by DorisParser#constantDefault. + VisitConstantDefault(ctx *ConstantDefaultContext) interface{} + + // Visit a parse tree produced by DorisParser#extract. + VisitExtract(ctx *ExtractContext) interface{} + + // Visit a parse tree produced by DorisParser#currentTimestamp. + VisitCurrentTimestamp(ctx *CurrentTimestampContext) interface{} + + // Visit a parse tree produced by DorisParser#functionCall. + VisitFunctionCall(ctx *FunctionCallContext) interface{} + + // Visit a parse tree produced by DorisParser#arraySlice. + VisitArraySlice(ctx *ArraySliceContext) interface{} + + // Visit a parse tree produced by DorisParser#searchedCase. + VisitSearchedCase(ctx *SearchedCaseContext) interface{} + + // Visit a parse tree produced by DorisParser#position. + VisitPosition(ctx *PositionContext) interface{} + + // Visit a parse tree produced by DorisParser#tryCast. + VisitTryCast(ctx *TryCastContext) interface{} + + // Visit a parse tree produced by DorisParser#except. + VisitExcept(ctx *ExceptContext) interface{} + + // Visit a parse tree produced by DorisParser#replace. + VisitReplace(ctx *ReplaceContext) interface{} + + // Visit a parse tree produced by DorisParser#castDataType. + VisitCastDataType(ctx *CastDataTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#functionCallExpression. + VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{} + + // Visit a parse tree produced by DorisParser#functionIdentifier. + VisitFunctionIdentifier(ctx *FunctionIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#functionNameIdentifier. + VisitFunctionNameIdentifier(ctx *FunctionNameIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#windowSpec. + VisitWindowSpec(ctx *WindowSpecContext) interface{} + + // Visit a parse tree produced by DorisParser#windowFrame. + VisitWindowFrame(ctx *WindowFrameContext) interface{} + + // Visit a parse tree produced by DorisParser#frameUnits. + VisitFrameUnits(ctx *FrameUnitsContext) interface{} + + // Visit a parse tree produced by DorisParser#frameBoundary. + VisitFrameBoundary(ctx *FrameBoundaryContext) interface{} + + // Visit a parse tree produced by DorisParser#qualifiedName. + VisitQualifiedName(ctx *QualifiedNameContext) interface{} + + // Visit a parse tree produced by DorisParser#specifiedPartition. + VisitSpecifiedPartition(ctx *SpecifiedPartitionContext) interface{} + + // Visit a parse tree produced by DorisParser#nullLiteral. + VisitNullLiteral(ctx *NullLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#typeConstructor. + VisitTypeConstructor(ctx *TypeConstructorContext) interface{} + + // Visit a parse tree produced by DorisParser#numericLiteral. + VisitNumericLiteral(ctx *NumericLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#booleanLiteral. + VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#stringLiteral. + VisitStringLiteral(ctx *StringLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#varbinaryLiteral. + VisitVarbinaryLiteral(ctx *VarbinaryLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#arrayLiteral. + VisitArrayLiteral(ctx *ArrayLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#mapLiteral. + VisitMapLiteral(ctx *MapLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#structLiteral. + VisitStructLiteral(ctx *StructLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#placeholder. + VisitPlaceholder(ctx *PlaceholderContext) interface{} + + // Visit a parse tree produced by DorisParser#comparisonOperator. + VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{} + + // Visit a parse tree produced by DorisParser#booleanValue. + VisitBooleanValue(ctx *BooleanValueContext) interface{} + + // Visit a parse tree produced by DorisParser#whenClause. + VisitWhenClause(ctx *WhenClauseContext) interface{} + + // Visit a parse tree produced by DorisParser#interval. + VisitInterval(ctx *IntervalContext) interface{} + + // Visit a parse tree produced by DorisParser#unitIdentifier. + VisitUnitIdentifier(ctx *UnitIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#dataTypeWithNullable. + VisitDataTypeWithNullable(ctx *DataTypeWithNullableContext) interface{} + + // Visit a parse tree produced by DorisParser#complexDataType. + VisitComplexDataType(ctx *ComplexDataTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#variantPredefinedFields. + VisitVariantPredefinedFields(ctx *VariantPredefinedFieldsContext) interface{} + + // Visit a parse tree produced by DorisParser#aggStateDataType. + VisitAggStateDataType(ctx *AggStateDataTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#primitiveDataType. + VisitPrimitiveDataType(ctx *PrimitiveDataTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#primitiveColType. + VisitPrimitiveColType(ctx *PrimitiveColTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#complexColTypeList. + VisitComplexColTypeList(ctx *ComplexColTypeListContext) interface{} + + // Visit a parse tree produced by DorisParser#complexColType. + VisitComplexColType(ctx *ComplexColTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#variant. + VisitVariant(ctx *VariantContext) interface{} + + // Visit a parse tree produced by DorisParser#variantSubColTypeList. + VisitVariantSubColTypeList(ctx *VariantSubColTypeListContext) interface{} + + // Visit a parse tree produced by DorisParser#variantSubColType. + VisitVariantSubColType(ctx *VariantSubColTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#variantSubColMatchType. + VisitVariantSubColMatchType(ctx *VariantSubColMatchTypeContext) interface{} + + // Visit a parse tree produced by DorisParser#commentSpec. + VisitCommentSpec(ctx *CommentSpecContext) interface{} + + // Visit a parse tree produced by DorisParser#sample. + VisitSample(ctx *SampleContext) interface{} + + // Visit a parse tree produced by DorisParser#sampleByPercentile. + VisitSampleByPercentile(ctx *SampleByPercentileContext) interface{} + + // Visit a parse tree produced by DorisParser#sampleByRows. + VisitSampleByRows(ctx *SampleByRowsContext) interface{} + + // Visit a parse tree produced by DorisParser#tableSnapshot. + VisitTableSnapshot(ctx *TableSnapshotContext) interface{} + + // Visit a parse tree produced by DorisParser#errorCapturingIdentifier. + VisitErrorCapturingIdentifier(ctx *ErrorCapturingIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#errorIdent. + VisitErrorIdent(ctx *ErrorIdentContext) interface{} + + // Visit a parse tree produced by DorisParser#realIdent. + VisitRealIdent(ctx *RealIdentContext) interface{} + + // Visit a parse tree produced by DorisParser#identifier. + VisitIdentifier(ctx *IdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#unquotedIdentifier. + VisitUnquotedIdentifier(ctx *UnquotedIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#quotedIdentifierAlternative. + VisitQuotedIdentifierAlternative(ctx *QuotedIdentifierAlternativeContext) interface{} + + // Visit a parse tree produced by DorisParser#quotedIdentifier. + VisitQuotedIdentifier(ctx *QuotedIdentifierContext) interface{} + + // Visit a parse tree produced by DorisParser#integerLiteral. + VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#decimalLiteral. + VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{} + + // Visit a parse tree produced by DorisParser#nonReserved. + VisitNonReserved(ctx *NonReservedContext) interface{} +} diff --git a/doris/dorissql_base_listener.go b/doris/dorissql_base_listener.go deleted file mode 100644 index fcb66fd..0000000 --- a/doris/dorissql_base_listener.go +++ /dev/null @@ -1,4047 +0,0 @@ -// Code generated from DorisSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. - -package doris // DorisSQL -import "github.com/antlr4-go/antlr/v4" - -// BaseDorisSQLListener is a complete listener for a parse tree produced by DorisSQLParser. -type BaseDorisSQLListener struct{} - -var _ DorisSQLListener = &BaseDorisSQLListener{} - -// VisitTerminal is called when a terminal node is visited. -func (s *BaseDorisSQLListener) VisitTerminal(node antlr.TerminalNode) {} - -// VisitErrorNode is called when an error node is visited. -func (s *BaseDorisSQLListener) VisitErrorNode(node antlr.ErrorNode) {} - -// EnterEveryRule is called when any rule is entered. -func (s *BaseDorisSQLListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} - -// ExitEveryRule is called when any rule is exited. -func (s *BaseDorisSQLListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} - -// EnterSqlStatements is called when production sqlStatements is entered. -func (s *BaseDorisSQLListener) EnterSqlStatements(ctx *SqlStatementsContext) {} - -// ExitSqlStatements is called when production sqlStatements is exited. -func (s *BaseDorisSQLListener) ExitSqlStatements(ctx *SqlStatementsContext) {} - -// EnterSingleStatement is called when production singleStatement is entered. -func (s *BaseDorisSQLListener) EnterSingleStatement(ctx *SingleStatementContext) {} - -// ExitSingleStatement is called when production singleStatement is exited. -func (s *BaseDorisSQLListener) ExitSingleStatement(ctx *SingleStatementContext) {} - -// EnterStatement is called when production statement is entered. -func (s *BaseDorisSQLListener) EnterStatement(ctx *StatementContext) {} - -// ExitStatement is called when production statement is exited. -func (s *BaseDorisSQLListener) ExitStatement(ctx *StatementContext) {} - -// EnterUseDatabaseStatement is called when production useDatabaseStatement is entered. -func (s *BaseDorisSQLListener) EnterUseDatabaseStatement(ctx *UseDatabaseStatementContext) {} - -// ExitUseDatabaseStatement is called when production useDatabaseStatement is exited. -func (s *BaseDorisSQLListener) ExitUseDatabaseStatement(ctx *UseDatabaseStatementContext) {} - -// EnterUseCatalogStatement is called when production useCatalogStatement is entered. -func (s *BaseDorisSQLListener) EnterUseCatalogStatement(ctx *UseCatalogStatementContext) {} - -// ExitUseCatalogStatement is called when production useCatalogStatement is exited. -func (s *BaseDorisSQLListener) ExitUseCatalogStatement(ctx *UseCatalogStatementContext) {} - -// EnterSetCatalogStatement is called when production setCatalogStatement is entered. -func (s *BaseDorisSQLListener) EnterSetCatalogStatement(ctx *SetCatalogStatementContext) {} - -// ExitSetCatalogStatement is called when production setCatalogStatement is exited. -func (s *BaseDorisSQLListener) ExitSetCatalogStatement(ctx *SetCatalogStatementContext) {} - -// EnterShowDatabasesStatement is called when production showDatabasesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDatabasesStatement(ctx *ShowDatabasesStatementContext) {} - -// ExitShowDatabasesStatement is called when production showDatabasesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) {} - -// EnterAlterDbQuotaStatement is called when production alterDbQuotaStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) {} - -// ExitAlterDbQuotaStatement is called when production alterDbQuotaStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) {} - -// EnterCreateDbStatement is called when production createDbStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateDbStatement(ctx *CreateDbStatementContext) {} - -// ExitCreateDbStatement is called when production createDbStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateDbStatement(ctx *CreateDbStatementContext) {} - -// EnterDropDbStatement is called when production dropDbStatement is entered. -func (s *BaseDorisSQLListener) EnterDropDbStatement(ctx *DropDbStatementContext) {} - -// ExitDropDbStatement is called when production dropDbStatement is exited. -func (s *BaseDorisSQLListener) ExitDropDbStatement(ctx *DropDbStatementContext) {} - -// EnterShowCreateDbStatement is called when production showCreateDbStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateDbStatement(ctx *ShowCreateDbStatementContext) {} - -// ExitShowCreateDbStatement is called when production showCreateDbStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateDbStatement(ctx *ShowCreateDbStatementContext) {} - -// EnterAlterDatabaseRenameStatement is called when production alterDatabaseRenameStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) { -} - -// ExitAlterDatabaseRenameStatement is called when production alterDatabaseRenameStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) { -} - -// EnterRecoverDbStmt is called when production recoverDbStmt is entered. -func (s *BaseDorisSQLListener) EnterRecoverDbStmt(ctx *RecoverDbStmtContext) {} - -// ExitRecoverDbStmt is called when production recoverDbStmt is exited. -func (s *BaseDorisSQLListener) ExitRecoverDbStmt(ctx *RecoverDbStmtContext) {} - -// EnterShowDataStmt is called when production showDataStmt is entered. -func (s *BaseDorisSQLListener) EnterShowDataStmt(ctx *ShowDataStmtContext) {} - -// ExitShowDataStmt is called when production showDataStmt is exited. -func (s *BaseDorisSQLListener) ExitShowDataStmt(ctx *ShowDataStmtContext) {} - -// EnterShowDataDistributionStmt is called when production showDataDistributionStmt is entered. -func (s *BaseDorisSQLListener) EnterShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) {} - -// ExitShowDataDistributionStmt is called when production showDataDistributionStmt is exited. -func (s *BaseDorisSQLListener) ExitShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) {} - -// EnterCreateTableStatement is called when production createTableStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateTableStatement(ctx *CreateTableStatementContext) {} - -// ExitCreateTableStatement is called when production createTableStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateTableStatement(ctx *CreateTableStatementContext) {} - -// EnterColumnDesc is called when production columnDesc is entered. -func (s *BaseDorisSQLListener) EnterColumnDesc(ctx *ColumnDescContext) {} - -// ExitColumnDesc is called when production columnDesc is exited. -func (s *BaseDorisSQLListener) ExitColumnDesc(ctx *ColumnDescContext) {} - -// EnterCharsetName is called when production charsetName is entered. -func (s *BaseDorisSQLListener) EnterCharsetName(ctx *CharsetNameContext) {} - -// ExitCharsetName is called when production charsetName is exited. -func (s *BaseDorisSQLListener) ExitCharsetName(ctx *CharsetNameContext) {} - -// EnterDefaultDesc is called when production defaultDesc is entered. -func (s *BaseDorisSQLListener) EnterDefaultDesc(ctx *DefaultDescContext) {} - -// ExitDefaultDesc is called when production defaultDesc is exited. -func (s *BaseDorisSQLListener) ExitDefaultDesc(ctx *DefaultDescContext) {} - -// EnterGeneratedColumnDesc is called when production generatedColumnDesc is entered. -func (s *BaseDorisSQLListener) EnterGeneratedColumnDesc(ctx *GeneratedColumnDescContext) {} - -// ExitGeneratedColumnDesc is called when production generatedColumnDesc is exited. -func (s *BaseDorisSQLListener) ExitGeneratedColumnDesc(ctx *GeneratedColumnDescContext) {} - -// EnterIndexDesc is called when production indexDesc is entered. -func (s *BaseDorisSQLListener) EnterIndexDesc(ctx *IndexDescContext) {} - -// ExitIndexDesc is called when production indexDesc is exited. -func (s *BaseDorisSQLListener) ExitIndexDesc(ctx *IndexDescContext) {} - -// EnterEngineDesc is called when production engineDesc is entered. -func (s *BaseDorisSQLListener) EnterEngineDesc(ctx *EngineDescContext) {} - -// ExitEngineDesc is called when production engineDesc is exited. -func (s *BaseDorisSQLListener) ExitEngineDesc(ctx *EngineDescContext) {} - -// EnterCharsetDesc is called when production charsetDesc is entered. -func (s *BaseDorisSQLListener) EnterCharsetDesc(ctx *CharsetDescContext) {} - -// ExitCharsetDesc is called when production charsetDesc is exited. -func (s *BaseDorisSQLListener) ExitCharsetDesc(ctx *CharsetDescContext) {} - -// EnterCollateDesc is called when production collateDesc is entered. -func (s *BaseDorisSQLListener) EnterCollateDesc(ctx *CollateDescContext) {} - -// ExitCollateDesc is called when production collateDesc is exited. -func (s *BaseDorisSQLListener) ExitCollateDesc(ctx *CollateDescContext) {} - -// EnterKeyDesc is called when production keyDesc is entered. -func (s *BaseDorisSQLListener) EnterKeyDesc(ctx *KeyDescContext) {} - -// ExitKeyDesc is called when production keyDesc is exited. -func (s *BaseDorisSQLListener) ExitKeyDesc(ctx *KeyDescContext) {} - -// EnterOrderByDesc is called when production orderByDesc is entered. -func (s *BaseDorisSQLListener) EnterOrderByDesc(ctx *OrderByDescContext) {} - -// ExitOrderByDesc is called when production orderByDesc is exited. -func (s *BaseDorisSQLListener) ExitOrderByDesc(ctx *OrderByDescContext) {} - -// EnterColumnNullable is called when production columnNullable is entered. -func (s *BaseDorisSQLListener) EnterColumnNullable(ctx *ColumnNullableContext) {} - -// ExitColumnNullable is called when production columnNullable is exited. -func (s *BaseDorisSQLListener) ExitColumnNullable(ctx *ColumnNullableContext) {} - -// EnterTypeWithNullable is called when production typeWithNullable is entered. -func (s *BaseDorisSQLListener) EnterTypeWithNullable(ctx *TypeWithNullableContext) {} - -// ExitTypeWithNullable is called when production typeWithNullable is exited. -func (s *BaseDorisSQLListener) ExitTypeWithNullable(ctx *TypeWithNullableContext) {} - -// EnterAggStateDesc is called when production aggStateDesc is entered. -func (s *BaseDorisSQLListener) EnterAggStateDesc(ctx *AggStateDescContext) {} - -// ExitAggStateDesc is called when production aggStateDesc is exited. -func (s *BaseDorisSQLListener) ExitAggStateDesc(ctx *AggStateDescContext) {} - -// EnterAggDesc is called when production aggDesc is entered. -func (s *BaseDorisSQLListener) EnterAggDesc(ctx *AggDescContext) {} - -// ExitAggDesc is called when production aggDesc is exited. -func (s *BaseDorisSQLListener) ExitAggDesc(ctx *AggDescContext) {} - -// EnterRollupDesc is called when production rollupDesc is entered. -func (s *BaseDorisSQLListener) EnterRollupDesc(ctx *RollupDescContext) {} - -// ExitRollupDesc is called when production rollupDesc is exited. -func (s *BaseDorisSQLListener) ExitRollupDesc(ctx *RollupDescContext) {} - -// EnterRollupItem is called when production rollupItem is entered. -func (s *BaseDorisSQLListener) EnterRollupItem(ctx *RollupItemContext) {} - -// ExitRollupItem is called when production rollupItem is exited. -func (s *BaseDorisSQLListener) ExitRollupItem(ctx *RollupItemContext) {} - -// EnterDupKeys is called when production dupKeys is entered. -func (s *BaseDorisSQLListener) EnterDupKeys(ctx *DupKeysContext) {} - -// ExitDupKeys is called when production dupKeys is exited. -func (s *BaseDorisSQLListener) ExitDupKeys(ctx *DupKeysContext) {} - -// EnterFromRollup is called when production fromRollup is entered. -func (s *BaseDorisSQLListener) EnterFromRollup(ctx *FromRollupContext) {} - -// ExitFromRollup is called when production fromRollup is exited. -func (s *BaseDorisSQLListener) ExitFromRollup(ctx *FromRollupContext) {} - -// EnterOrReplace is called when production orReplace is entered. -func (s *BaseDorisSQLListener) EnterOrReplace(ctx *OrReplaceContext) {} - -// ExitOrReplace is called when production orReplace is exited. -func (s *BaseDorisSQLListener) ExitOrReplace(ctx *OrReplaceContext) {} - -// EnterIfNotExists is called when production ifNotExists is entered. -func (s *BaseDorisSQLListener) EnterIfNotExists(ctx *IfNotExistsContext) {} - -// ExitIfNotExists is called when production ifNotExists is exited. -func (s *BaseDorisSQLListener) ExitIfNotExists(ctx *IfNotExistsContext) {} - -// EnterCreateTableAsSelectStatement is called when production createTableAsSelectStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) { -} - -// ExitCreateTableAsSelectStatement is called when production createTableAsSelectStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) { -} - -// EnterDropTableStatement is called when production dropTableStatement is entered. -func (s *BaseDorisSQLListener) EnterDropTableStatement(ctx *DropTableStatementContext) {} - -// ExitDropTableStatement is called when production dropTableStatement is exited. -func (s *BaseDorisSQLListener) ExitDropTableStatement(ctx *DropTableStatementContext) {} - -// EnterCleanTemporaryTableStatement is called when production cleanTemporaryTableStatement is entered. -func (s *BaseDorisSQLListener) EnterCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) { -} - -// ExitCleanTemporaryTableStatement is called when production cleanTemporaryTableStatement is exited. -func (s *BaseDorisSQLListener) ExitCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) { -} - -// EnterAlterTableStatement is called when production alterTableStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterTableStatement(ctx *AlterTableStatementContext) {} - -// ExitAlterTableStatement is called when production alterTableStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterTableStatement(ctx *AlterTableStatementContext) {} - -// EnterCreateIndexStatement is called when production createIndexStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateIndexStatement(ctx *CreateIndexStatementContext) {} - -// ExitCreateIndexStatement is called when production createIndexStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateIndexStatement(ctx *CreateIndexStatementContext) {} - -// EnterDropIndexStatement is called when production dropIndexStatement is entered. -func (s *BaseDorisSQLListener) EnterDropIndexStatement(ctx *DropIndexStatementContext) {} - -// ExitDropIndexStatement is called when production dropIndexStatement is exited. -func (s *BaseDorisSQLListener) ExitDropIndexStatement(ctx *DropIndexStatementContext) {} - -// EnterIndexType is called when production indexType is entered. -func (s *BaseDorisSQLListener) EnterIndexType(ctx *IndexTypeContext) {} - -// ExitIndexType is called when production indexType is exited. -func (s *BaseDorisSQLListener) ExitIndexType(ctx *IndexTypeContext) {} - -// EnterShowTableStatement is called when production showTableStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTableStatement(ctx *ShowTableStatementContext) {} - -// ExitShowTableStatement is called when production showTableStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTableStatement(ctx *ShowTableStatementContext) {} - -// EnterShowTemporaryTablesStatement is called when production showTemporaryTablesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) { -} - -// ExitShowTemporaryTablesStatement is called when production showTemporaryTablesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) { -} - -// EnterShowCreateTableStatement is called when production showCreateTableStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateTableStatement(ctx *ShowCreateTableStatementContext) {} - -// ExitShowCreateTableStatement is called when production showCreateTableStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateTableStatement(ctx *ShowCreateTableStatementContext) {} - -// EnterShowColumnStatement is called when production showColumnStatement is entered. -func (s *BaseDorisSQLListener) EnterShowColumnStatement(ctx *ShowColumnStatementContext) {} - -// ExitShowColumnStatement is called when production showColumnStatement is exited. -func (s *BaseDorisSQLListener) ExitShowColumnStatement(ctx *ShowColumnStatementContext) {} - -// EnterShowTableStatusStatement is called when production showTableStatusStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTableStatusStatement(ctx *ShowTableStatusStatementContext) {} - -// ExitShowTableStatusStatement is called when production showTableStatusStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTableStatusStatement(ctx *ShowTableStatusStatementContext) {} - -// EnterRefreshTableStatement is called when production refreshTableStatement is entered. -func (s *BaseDorisSQLListener) EnterRefreshTableStatement(ctx *RefreshTableStatementContext) {} - -// ExitRefreshTableStatement is called when production refreshTableStatement is exited. -func (s *BaseDorisSQLListener) ExitRefreshTableStatement(ctx *RefreshTableStatementContext) {} - -// EnterShowAlterStatement is called when production showAlterStatement is entered. -func (s *BaseDorisSQLListener) EnterShowAlterStatement(ctx *ShowAlterStatementContext) {} - -// ExitShowAlterStatement is called when production showAlterStatement is exited. -func (s *BaseDorisSQLListener) ExitShowAlterStatement(ctx *ShowAlterStatementContext) {} - -// EnterDescTableStatement is called when production descTableStatement is entered. -func (s *BaseDorisSQLListener) EnterDescTableStatement(ctx *DescTableStatementContext) {} - -// ExitDescTableStatement is called when production descTableStatement is exited. -func (s *BaseDorisSQLListener) ExitDescTableStatement(ctx *DescTableStatementContext) {} - -// EnterCreateTableLikeStatement is called when production createTableLikeStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) {} - -// ExitCreateTableLikeStatement is called when production createTableLikeStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) {} - -// EnterShowIndexStatement is called when production showIndexStatement is entered. -func (s *BaseDorisSQLListener) EnterShowIndexStatement(ctx *ShowIndexStatementContext) {} - -// ExitShowIndexStatement is called when production showIndexStatement is exited. -func (s *BaseDorisSQLListener) ExitShowIndexStatement(ctx *ShowIndexStatementContext) {} - -// EnterRecoverTableStatement is called when production recoverTableStatement is entered. -func (s *BaseDorisSQLListener) EnterRecoverTableStatement(ctx *RecoverTableStatementContext) {} - -// ExitRecoverTableStatement is called when production recoverTableStatement is exited. -func (s *BaseDorisSQLListener) ExitRecoverTableStatement(ctx *RecoverTableStatementContext) {} - -// EnterTruncateTableStatement is called when production truncateTableStatement is entered. -func (s *BaseDorisSQLListener) EnterTruncateTableStatement(ctx *TruncateTableStatementContext) {} - -// ExitTruncateTableStatement is called when production truncateTableStatement is exited. -func (s *BaseDorisSQLListener) ExitTruncateTableStatement(ctx *TruncateTableStatementContext) {} - -// EnterCancelAlterTableStatement is called when production cancelAlterTableStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) { -} - -// ExitCancelAlterTableStatement is called when production cancelAlterTableStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) {} - -// EnterShowPartitionsStatement is called when production showPartitionsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPartitionsStatement(ctx *ShowPartitionsStatementContext) {} - -// ExitShowPartitionsStatement is called when production showPartitionsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPartitionsStatement(ctx *ShowPartitionsStatementContext) {} - -// EnterRecoverPartitionStatement is called when production recoverPartitionStatement is entered. -func (s *BaseDorisSQLListener) EnterRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) { -} - -// ExitRecoverPartitionStatement is called when production recoverPartitionStatement is exited. -func (s *BaseDorisSQLListener) ExitRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) {} - -// EnterCreateViewStatement is called when production createViewStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateViewStatement(ctx *CreateViewStatementContext) {} - -// ExitCreateViewStatement is called when production createViewStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateViewStatement(ctx *CreateViewStatementContext) {} - -// EnterAlterViewStatement is called when production alterViewStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterViewStatement(ctx *AlterViewStatementContext) {} - -// ExitAlterViewStatement is called when production alterViewStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterViewStatement(ctx *AlterViewStatementContext) {} - -// EnterDropViewStatement is called when production dropViewStatement is entered. -func (s *BaseDorisSQLListener) EnterDropViewStatement(ctx *DropViewStatementContext) {} - -// ExitDropViewStatement is called when production dropViewStatement is exited. -func (s *BaseDorisSQLListener) ExitDropViewStatement(ctx *DropViewStatementContext) {} - -// EnterColumnNameWithComment is called when production columnNameWithComment is entered. -func (s *BaseDorisSQLListener) EnterColumnNameWithComment(ctx *ColumnNameWithCommentContext) {} - -// ExitColumnNameWithComment is called when production columnNameWithComment is exited. -func (s *BaseDorisSQLListener) ExitColumnNameWithComment(ctx *ColumnNameWithCommentContext) {} - -// EnterSubmitTaskStatement is called when production submitTaskStatement is entered. -func (s *BaseDorisSQLListener) EnterSubmitTaskStatement(ctx *SubmitTaskStatementContext) {} - -// ExitSubmitTaskStatement is called when production submitTaskStatement is exited. -func (s *BaseDorisSQLListener) ExitSubmitTaskStatement(ctx *SubmitTaskStatementContext) {} - -// EnterTaskClause is called when production taskClause is entered. -func (s *BaseDorisSQLListener) EnterTaskClause(ctx *TaskClauseContext) {} - -// ExitTaskClause is called when production taskClause is exited. -func (s *BaseDorisSQLListener) ExitTaskClause(ctx *TaskClauseContext) {} - -// EnterDropTaskStatement is called when production dropTaskStatement is entered. -func (s *BaseDorisSQLListener) EnterDropTaskStatement(ctx *DropTaskStatementContext) {} - -// ExitDropTaskStatement is called when production dropTaskStatement is exited. -func (s *BaseDorisSQLListener) ExitDropTaskStatement(ctx *DropTaskStatementContext) {} - -// EnterTaskScheduleDesc is called when production taskScheduleDesc is entered. -func (s *BaseDorisSQLListener) EnterTaskScheduleDesc(ctx *TaskScheduleDescContext) {} - -// ExitTaskScheduleDesc is called when production taskScheduleDesc is exited. -func (s *BaseDorisSQLListener) ExitTaskScheduleDesc(ctx *TaskScheduleDescContext) {} - -// EnterCreateMaterializedViewStatement is called when production createMaterializedViewStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) { -} - -// ExitCreateMaterializedViewStatement is called when production createMaterializedViewStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) { -} - -// EnterMvPartitionExprs is called when production mvPartitionExprs is entered. -func (s *BaseDorisSQLListener) EnterMvPartitionExprs(ctx *MvPartitionExprsContext) {} - -// ExitMvPartitionExprs is called when production mvPartitionExprs is exited. -func (s *BaseDorisSQLListener) ExitMvPartitionExprs(ctx *MvPartitionExprsContext) {} - -// EnterMaterializedViewDesc is called when production materializedViewDesc is entered. -func (s *BaseDorisSQLListener) EnterMaterializedViewDesc(ctx *MaterializedViewDescContext) {} - -// ExitMaterializedViewDesc is called when production materializedViewDesc is exited. -func (s *BaseDorisSQLListener) ExitMaterializedViewDesc(ctx *MaterializedViewDescContext) {} - -// EnterShowMaterializedViewsStatement is called when production showMaterializedViewsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) { -} - -// ExitShowMaterializedViewsStatement is called when production showMaterializedViewsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) { -} - -// EnterDropMaterializedViewStatement is called when production dropMaterializedViewStatement is entered. -func (s *BaseDorisSQLListener) EnterDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) { -} - -// ExitDropMaterializedViewStatement is called when production dropMaterializedViewStatement is exited. -func (s *BaseDorisSQLListener) ExitDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) { -} - -// EnterAlterMaterializedViewStatement is called when production alterMaterializedViewStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) { -} - -// ExitAlterMaterializedViewStatement is called when production alterMaterializedViewStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) { -} - -// EnterRefreshMaterializedViewStatement is called when production refreshMaterializedViewStatement is entered. -func (s *BaseDorisSQLListener) EnterRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) { -} - -// ExitRefreshMaterializedViewStatement is called when production refreshMaterializedViewStatement is exited. -func (s *BaseDorisSQLListener) ExitRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) { -} - -// EnterCancelRefreshMaterializedViewStatement is called when production cancelRefreshMaterializedViewStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) { -} - -// ExitCancelRefreshMaterializedViewStatement is called when production cancelRefreshMaterializedViewStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) { -} - -// EnterAdminSetConfigStatement is called when production adminSetConfigStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) {} - -// ExitAdminSetConfigStatement is called when production adminSetConfigStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) {} - -// EnterAdminSetReplicaStatusStatement is called when production adminSetReplicaStatusStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) { -} - -// ExitAdminSetReplicaStatusStatement is called when production adminSetReplicaStatusStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) { -} - -// EnterAdminShowConfigStatement is called when production adminShowConfigStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) {} - -// ExitAdminShowConfigStatement is called when production adminShowConfigStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) {} - -// EnterAdminShowReplicaDistributionStatement is called when production adminShowReplicaDistributionStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) { -} - -// ExitAdminShowReplicaDistributionStatement is called when production adminShowReplicaDistributionStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) { -} - -// EnterAdminShowReplicaStatusStatement is called when production adminShowReplicaStatusStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) { -} - -// ExitAdminShowReplicaStatusStatement is called when production adminShowReplicaStatusStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) { -} - -// EnterAdminRepairTableStatement is called when production adminRepairTableStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) { -} - -// ExitAdminRepairTableStatement is called when production adminRepairTableStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) {} - -// EnterAdminCancelRepairTableStatement is called when production adminCancelRepairTableStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) { -} - -// ExitAdminCancelRepairTableStatement is called when production adminCancelRepairTableStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) { -} - -// EnterAdminCheckTabletsStatement is called when production adminCheckTabletsStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) { -} - -// ExitAdminCheckTabletsStatement is called when production adminCheckTabletsStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) { -} - -// EnterAdminSetPartitionVersion is called when production adminSetPartitionVersion is entered. -func (s *BaseDorisSQLListener) EnterAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) {} - -// ExitAdminSetPartitionVersion is called when production adminSetPartitionVersion is exited. -func (s *BaseDorisSQLListener) ExitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) {} - -// EnterKillStatement is called when production killStatement is entered. -func (s *BaseDorisSQLListener) EnterKillStatement(ctx *KillStatementContext) {} - -// ExitKillStatement is called when production killStatement is exited. -func (s *BaseDorisSQLListener) ExitKillStatement(ctx *KillStatementContext) {} - -// EnterSyncStatement is called when production syncStatement is entered. -func (s *BaseDorisSQLListener) EnterSyncStatement(ctx *SyncStatementContext) {} - -// ExitSyncStatement is called when production syncStatement is exited. -func (s *BaseDorisSQLListener) ExitSyncStatement(ctx *SyncStatementContext) {} - -// EnterAdminSetAutomatedSnapshotOnStatement is called when production adminSetAutomatedSnapshotOnStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) { -} - -// ExitAdminSetAutomatedSnapshotOnStatement is called when production adminSetAutomatedSnapshotOnStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) { -} - -// EnterAdminSetAutomatedSnapshotOffStatement is called when production adminSetAutomatedSnapshotOffStatement is entered. -func (s *BaseDorisSQLListener) EnterAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) { -} - -// ExitAdminSetAutomatedSnapshotOffStatement is called when production adminSetAutomatedSnapshotOffStatement is exited. -func (s *BaseDorisSQLListener) ExitAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) { -} - -// EnterAlterSystemStatement is called when production alterSystemStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterSystemStatement(ctx *AlterSystemStatementContext) {} - -// ExitAlterSystemStatement is called when production alterSystemStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterSystemStatement(ctx *AlterSystemStatementContext) {} - -// EnterCancelAlterSystemStatement is called when production cancelAlterSystemStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) { -} - -// ExitCancelAlterSystemStatement is called when production cancelAlterSystemStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) { -} - -// EnterShowComputeNodesStatement is called when production showComputeNodesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) { -} - -// ExitShowComputeNodesStatement is called when production showComputeNodesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) {} - -// EnterCreateExternalCatalogStatement is called when production createExternalCatalogStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) { -} - -// ExitCreateExternalCatalogStatement is called when production createExternalCatalogStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) { -} - -// EnterShowCreateExternalCatalogStatement is called when production showCreateExternalCatalogStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) { -} - -// ExitShowCreateExternalCatalogStatement is called when production showCreateExternalCatalogStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) { -} - -// EnterDropExternalCatalogStatement is called when production dropExternalCatalogStatement is entered. -func (s *BaseDorisSQLListener) EnterDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) { -} - -// ExitDropExternalCatalogStatement is called when production dropExternalCatalogStatement is exited. -func (s *BaseDorisSQLListener) ExitDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) { -} - -// EnterShowCatalogsStatement is called when production showCatalogsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCatalogsStatement(ctx *ShowCatalogsStatementContext) {} - -// ExitShowCatalogsStatement is called when production showCatalogsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCatalogsStatement(ctx *ShowCatalogsStatementContext) {} - -// EnterAlterCatalogStatement is called when production alterCatalogStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterCatalogStatement(ctx *AlterCatalogStatementContext) {} - -// ExitAlterCatalogStatement is called when production alterCatalogStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterCatalogStatement(ctx *AlterCatalogStatementContext) {} - -// EnterCreateStorageVolumeStatement is called when production createStorageVolumeStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) { -} - -// ExitCreateStorageVolumeStatement is called when production createStorageVolumeStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) { -} - -// EnterTypeDesc is called when production typeDesc is entered. -func (s *BaseDorisSQLListener) EnterTypeDesc(ctx *TypeDescContext) {} - -// ExitTypeDesc is called when production typeDesc is exited. -func (s *BaseDorisSQLListener) ExitTypeDesc(ctx *TypeDescContext) {} - -// EnterLocationsDesc is called when production locationsDesc is entered. -func (s *BaseDorisSQLListener) EnterLocationsDesc(ctx *LocationsDescContext) {} - -// ExitLocationsDesc is called when production locationsDesc is exited. -func (s *BaseDorisSQLListener) ExitLocationsDesc(ctx *LocationsDescContext) {} - -// EnterShowStorageVolumesStatement is called when production showStorageVolumesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) { -} - -// ExitShowStorageVolumesStatement is called when production showStorageVolumesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) { -} - -// EnterDropStorageVolumeStatement is called when production dropStorageVolumeStatement is entered. -func (s *BaseDorisSQLListener) EnterDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) { -} - -// ExitDropStorageVolumeStatement is called when production dropStorageVolumeStatement is exited. -func (s *BaseDorisSQLListener) ExitDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) { -} - -// EnterAlterStorageVolumeStatement is called when production alterStorageVolumeStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) { -} - -// ExitAlterStorageVolumeStatement is called when production alterStorageVolumeStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) { -} - -// EnterAlterStorageVolumeClause is called when production alterStorageVolumeClause is entered. -func (s *BaseDorisSQLListener) EnterAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) {} - -// ExitAlterStorageVolumeClause is called when production alterStorageVolumeClause is exited. -func (s *BaseDorisSQLListener) ExitAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) {} - -// EnterModifyStorageVolumePropertiesClause is called when production modifyStorageVolumePropertiesClause is entered. -func (s *BaseDorisSQLListener) EnterModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) { -} - -// ExitModifyStorageVolumePropertiesClause is called when production modifyStorageVolumePropertiesClause is exited. -func (s *BaseDorisSQLListener) ExitModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) { -} - -// EnterModifyStorageVolumeCommentClause is called when production modifyStorageVolumeCommentClause is entered. -func (s *BaseDorisSQLListener) EnterModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) { -} - -// ExitModifyStorageVolumeCommentClause is called when production modifyStorageVolumeCommentClause is exited. -func (s *BaseDorisSQLListener) ExitModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) { -} - -// EnterDescStorageVolumeStatement is called when production descStorageVolumeStatement is entered. -func (s *BaseDorisSQLListener) EnterDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) { -} - -// ExitDescStorageVolumeStatement is called when production descStorageVolumeStatement is exited. -func (s *BaseDorisSQLListener) ExitDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) { -} - -// EnterSetDefaultStorageVolumeStatement is called when production setDefaultStorageVolumeStatement is entered. -func (s *BaseDorisSQLListener) EnterSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) { -} - -// ExitSetDefaultStorageVolumeStatement is called when production setDefaultStorageVolumeStatement is exited. -func (s *BaseDorisSQLListener) ExitSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) { -} - -// EnterUpdateFailPointStatusStatement is called when production updateFailPointStatusStatement is entered. -func (s *BaseDorisSQLListener) EnterUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) { -} - -// ExitUpdateFailPointStatusStatement is called when production updateFailPointStatusStatement is exited. -func (s *BaseDorisSQLListener) ExitUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) { -} - -// EnterShowFailPointStatement is called when production showFailPointStatement is entered. -func (s *BaseDorisSQLListener) EnterShowFailPointStatement(ctx *ShowFailPointStatementContext) {} - -// ExitShowFailPointStatement is called when production showFailPointStatement is exited. -func (s *BaseDorisSQLListener) ExitShowFailPointStatement(ctx *ShowFailPointStatementContext) {} - -// EnterCreateDictionaryStatement is called when production createDictionaryStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) { -} - -// ExitCreateDictionaryStatement is called when production createDictionaryStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) {} - -// EnterDropDictionaryStatement is called when production dropDictionaryStatement is entered. -func (s *BaseDorisSQLListener) EnterDropDictionaryStatement(ctx *DropDictionaryStatementContext) {} - -// ExitDropDictionaryStatement is called when production dropDictionaryStatement is exited. -func (s *BaseDorisSQLListener) ExitDropDictionaryStatement(ctx *DropDictionaryStatementContext) {} - -// EnterRefreshDictionaryStatement is called when production refreshDictionaryStatement is entered. -func (s *BaseDorisSQLListener) EnterRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) { -} - -// ExitRefreshDictionaryStatement is called when production refreshDictionaryStatement is exited. -func (s *BaseDorisSQLListener) ExitRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) { -} - -// EnterShowDictionaryStatement is called when production showDictionaryStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDictionaryStatement(ctx *ShowDictionaryStatementContext) {} - -// ExitShowDictionaryStatement is called when production showDictionaryStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDictionaryStatement(ctx *ShowDictionaryStatementContext) {} - -// EnterCancelRefreshDictionaryStatement is called when production cancelRefreshDictionaryStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) { -} - -// ExitCancelRefreshDictionaryStatement is called when production cancelRefreshDictionaryStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) { -} - -// EnterDictionaryColumnDesc is called when production dictionaryColumnDesc is entered. -func (s *BaseDorisSQLListener) EnterDictionaryColumnDesc(ctx *DictionaryColumnDescContext) {} - -// ExitDictionaryColumnDesc is called when production dictionaryColumnDesc is exited. -func (s *BaseDorisSQLListener) ExitDictionaryColumnDesc(ctx *DictionaryColumnDescContext) {} - -// EnterDictionaryName is called when production dictionaryName is entered. -func (s *BaseDorisSQLListener) EnterDictionaryName(ctx *DictionaryNameContext) {} - -// ExitDictionaryName is called when production dictionaryName is exited. -func (s *BaseDorisSQLListener) ExitDictionaryName(ctx *DictionaryNameContext) {} - -// EnterAlterClause is called when production alterClause is entered. -func (s *BaseDorisSQLListener) EnterAlterClause(ctx *AlterClauseContext) {} - -// ExitAlterClause is called when production alterClause is exited. -func (s *BaseDorisSQLListener) ExitAlterClause(ctx *AlterClauseContext) {} - -// EnterAddFrontendClause is called when production addFrontendClause is entered. -func (s *BaseDorisSQLListener) EnterAddFrontendClause(ctx *AddFrontendClauseContext) {} - -// ExitAddFrontendClause is called when production addFrontendClause is exited. -func (s *BaseDorisSQLListener) ExitAddFrontendClause(ctx *AddFrontendClauseContext) {} - -// EnterDropFrontendClause is called when production dropFrontendClause is entered. -func (s *BaseDorisSQLListener) EnterDropFrontendClause(ctx *DropFrontendClauseContext) {} - -// ExitDropFrontendClause is called when production dropFrontendClause is exited. -func (s *BaseDorisSQLListener) ExitDropFrontendClause(ctx *DropFrontendClauseContext) {} - -// EnterModifyFrontendHostClause is called when production modifyFrontendHostClause is entered. -func (s *BaseDorisSQLListener) EnterModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) {} - -// ExitModifyFrontendHostClause is called when production modifyFrontendHostClause is exited. -func (s *BaseDorisSQLListener) ExitModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) {} - -// EnterAddBackendClause is called when production addBackendClause is entered. -func (s *BaseDorisSQLListener) EnterAddBackendClause(ctx *AddBackendClauseContext) {} - -// ExitAddBackendClause is called when production addBackendClause is exited. -func (s *BaseDorisSQLListener) ExitAddBackendClause(ctx *AddBackendClauseContext) {} - -// EnterDropBackendClause is called when production dropBackendClause is entered. -func (s *BaseDorisSQLListener) EnterDropBackendClause(ctx *DropBackendClauseContext) {} - -// ExitDropBackendClause is called when production dropBackendClause is exited. -func (s *BaseDorisSQLListener) ExitDropBackendClause(ctx *DropBackendClauseContext) {} - -// EnterDecommissionBackendClause is called when production decommissionBackendClause is entered. -func (s *BaseDorisSQLListener) EnterDecommissionBackendClause(ctx *DecommissionBackendClauseContext) { -} - -// ExitDecommissionBackendClause is called when production decommissionBackendClause is exited. -func (s *BaseDorisSQLListener) ExitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) {} - -// EnterModifyBackendClause is called when production modifyBackendClause is entered. -func (s *BaseDorisSQLListener) EnterModifyBackendClause(ctx *ModifyBackendClauseContext) {} - -// ExitModifyBackendClause is called when production modifyBackendClause is exited. -func (s *BaseDorisSQLListener) ExitModifyBackendClause(ctx *ModifyBackendClauseContext) {} - -// EnterAddComputeNodeClause is called when production addComputeNodeClause is entered. -func (s *BaseDorisSQLListener) EnterAddComputeNodeClause(ctx *AddComputeNodeClauseContext) {} - -// ExitAddComputeNodeClause is called when production addComputeNodeClause is exited. -func (s *BaseDorisSQLListener) ExitAddComputeNodeClause(ctx *AddComputeNodeClauseContext) {} - -// EnterDropComputeNodeClause is called when production dropComputeNodeClause is entered. -func (s *BaseDorisSQLListener) EnterDropComputeNodeClause(ctx *DropComputeNodeClauseContext) {} - -// ExitDropComputeNodeClause is called when production dropComputeNodeClause is exited. -func (s *BaseDorisSQLListener) ExitDropComputeNodeClause(ctx *DropComputeNodeClauseContext) {} - -// EnterModifyBrokerClause is called when production modifyBrokerClause is entered. -func (s *BaseDorisSQLListener) EnterModifyBrokerClause(ctx *ModifyBrokerClauseContext) {} - -// ExitModifyBrokerClause is called when production modifyBrokerClause is exited. -func (s *BaseDorisSQLListener) ExitModifyBrokerClause(ctx *ModifyBrokerClauseContext) {} - -// EnterAlterLoadErrorUrlClause is called when production alterLoadErrorUrlClause is entered. -func (s *BaseDorisSQLListener) EnterAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) {} - -// ExitAlterLoadErrorUrlClause is called when production alterLoadErrorUrlClause is exited. -func (s *BaseDorisSQLListener) ExitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) {} - -// EnterCreateImageClause is called when production createImageClause is entered. -func (s *BaseDorisSQLListener) EnterCreateImageClause(ctx *CreateImageClauseContext) {} - -// ExitCreateImageClause is called when production createImageClause is exited. -func (s *BaseDorisSQLListener) ExitCreateImageClause(ctx *CreateImageClauseContext) {} - -// EnterCleanTabletSchedQClause is called when production cleanTabletSchedQClause is entered. -func (s *BaseDorisSQLListener) EnterCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) {} - -// ExitCleanTabletSchedQClause is called when production cleanTabletSchedQClause is exited. -func (s *BaseDorisSQLListener) ExitCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) {} - -// EnterDecommissionDiskClause is called when production decommissionDiskClause is entered. -func (s *BaseDorisSQLListener) EnterDecommissionDiskClause(ctx *DecommissionDiskClauseContext) {} - -// ExitDecommissionDiskClause is called when production decommissionDiskClause is exited. -func (s *BaseDorisSQLListener) ExitDecommissionDiskClause(ctx *DecommissionDiskClauseContext) {} - -// EnterCancelDecommissionDiskClause is called when production cancelDecommissionDiskClause is entered. -func (s *BaseDorisSQLListener) EnterCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) { -} - -// ExitCancelDecommissionDiskClause is called when production cancelDecommissionDiskClause is exited. -func (s *BaseDorisSQLListener) ExitCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) { -} - -// EnterDisableDiskClause is called when production disableDiskClause is entered. -func (s *BaseDorisSQLListener) EnterDisableDiskClause(ctx *DisableDiskClauseContext) {} - -// ExitDisableDiskClause is called when production disableDiskClause is exited. -func (s *BaseDorisSQLListener) ExitDisableDiskClause(ctx *DisableDiskClauseContext) {} - -// EnterCancelDisableDiskClause is called when production cancelDisableDiskClause is entered. -func (s *BaseDorisSQLListener) EnterCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) {} - -// ExitCancelDisableDiskClause is called when production cancelDisableDiskClause is exited. -func (s *BaseDorisSQLListener) ExitCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) {} - -// EnterCreateIndexClause is called when production createIndexClause is entered. -func (s *BaseDorisSQLListener) EnterCreateIndexClause(ctx *CreateIndexClauseContext) {} - -// ExitCreateIndexClause is called when production createIndexClause is exited. -func (s *BaseDorisSQLListener) ExitCreateIndexClause(ctx *CreateIndexClauseContext) {} - -// EnterDropIndexClause is called when production dropIndexClause is entered. -func (s *BaseDorisSQLListener) EnterDropIndexClause(ctx *DropIndexClauseContext) {} - -// ExitDropIndexClause is called when production dropIndexClause is exited. -func (s *BaseDorisSQLListener) ExitDropIndexClause(ctx *DropIndexClauseContext) {} - -// EnterTableRenameClause is called when production tableRenameClause is entered. -func (s *BaseDorisSQLListener) EnterTableRenameClause(ctx *TableRenameClauseContext) {} - -// ExitTableRenameClause is called when production tableRenameClause is exited. -func (s *BaseDorisSQLListener) ExitTableRenameClause(ctx *TableRenameClauseContext) {} - -// EnterSwapTableClause is called when production swapTableClause is entered. -func (s *BaseDorisSQLListener) EnterSwapTableClause(ctx *SwapTableClauseContext) {} - -// ExitSwapTableClause is called when production swapTableClause is exited. -func (s *BaseDorisSQLListener) ExitSwapTableClause(ctx *SwapTableClauseContext) {} - -// EnterModifyPropertiesClause is called when production modifyPropertiesClause is entered. -func (s *BaseDorisSQLListener) EnterModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) {} - -// ExitModifyPropertiesClause is called when production modifyPropertiesClause is exited. -func (s *BaseDorisSQLListener) ExitModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) {} - -// EnterModifyCommentClause is called when production modifyCommentClause is entered. -func (s *BaseDorisSQLListener) EnterModifyCommentClause(ctx *ModifyCommentClauseContext) {} - -// ExitModifyCommentClause is called when production modifyCommentClause is exited. -func (s *BaseDorisSQLListener) ExitModifyCommentClause(ctx *ModifyCommentClauseContext) {} - -// EnterOptimizeRange is called when production optimizeRange is entered. -func (s *BaseDorisSQLListener) EnterOptimizeRange(ctx *OptimizeRangeContext) {} - -// ExitOptimizeRange is called when production optimizeRange is exited. -func (s *BaseDorisSQLListener) ExitOptimizeRange(ctx *OptimizeRangeContext) {} - -// EnterOptimizeClause is called when production optimizeClause is entered. -func (s *BaseDorisSQLListener) EnterOptimizeClause(ctx *OptimizeClauseContext) {} - -// ExitOptimizeClause is called when production optimizeClause is exited. -func (s *BaseDorisSQLListener) ExitOptimizeClause(ctx *OptimizeClauseContext) {} - -// EnterAddColumnClause is called when production addColumnClause is entered. -func (s *BaseDorisSQLListener) EnterAddColumnClause(ctx *AddColumnClauseContext) {} - -// ExitAddColumnClause is called when production addColumnClause is exited. -func (s *BaseDorisSQLListener) ExitAddColumnClause(ctx *AddColumnClauseContext) {} - -// EnterAddColumnsClause is called when production addColumnsClause is entered. -func (s *BaseDorisSQLListener) EnterAddColumnsClause(ctx *AddColumnsClauseContext) {} - -// ExitAddColumnsClause is called when production addColumnsClause is exited. -func (s *BaseDorisSQLListener) ExitAddColumnsClause(ctx *AddColumnsClauseContext) {} - -// EnterDropColumnClause is called when production dropColumnClause is entered. -func (s *BaseDorisSQLListener) EnterDropColumnClause(ctx *DropColumnClauseContext) {} - -// ExitDropColumnClause is called when production dropColumnClause is exited. -func (s *BaseDorisSQLListener) ExitDropColumnClause(ctx *DropColumnClauseContext) {} - -// EnterModifyColumnClause is called when production modifyColumnClause is entered. -func (s *BaseDorisSQLListener) EnterModifyColumnClause(ctx *ModifyColumnClauseContext) {} - -// ExitModifyColumnClause is called when production modifyColumnClause is exited. -func (s *BaseDorisSQLListener) ExitModifyColumnClause(ctx *ModifyColumnClauseContext) {} - -// EnterModifyColumnCommentClause is called when production modifyColumnCommentClause is entered. -func (s *BaseDorisSQLListener) EnterModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) { -} - -// ExitModifyColumnCommentClause is called when production modifyColumnCommentClause is exited. -func (s *BaseDorisSQLListener) ExitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) {} - -// EnterColumnRenameClause is called when production columnRenameClause is entered. -func (s *BaseDorisSQLListener) EnterColumnRenameClause(ctx *ColumnRenameClauseContext) {} - -// ExitColumnRenameClause is called when production columnRenameClause is exited. -func (s *BaseDorisSQLListener) ExitColumnRenameClause(ctx *ColumnRenameClauseContext) {} - -// EnterReorderColumnsClause is called when production reorderColumnsClause is entered. -func (s *BaseDorisSQLListener) EnterReorderColumnsClause(ctx *ReorderColumnsClauseContext) {} - -// ExitReorderColumnsClause is called when production reorderColumnsClause is exited. -func (s *BaseDorisSQLListener) ExitReorderColumnsClause(ctx *ReorderColumnsClauseContext) {} - -// EnterRollupRenameClause is called when production rollupRenameClause is entered. -func (s *BaseDorisSQLListener) EnterRollupRenameClause(ctx *RollupRenameClauseContext) {} - -// ExitRollupRenameClause is called when production rollupRenameClause is exited. -func (s *BaseDorisSQLListener) ExitRollupRenameClause(ctx *RollupRenameClauseContext) {} - -// EnterCompactionClause is called when production compactionClause is entered. -func (s *BaseDorisSQLListener) EnterCompactionClause(ctx *CompactionClauseContext) {} - -// ExitCompactionClause is called when production compactionClause is exited. -func (s *BaseDorisSQLListener) ExitCompactionClause(ctx *CompactionClauseContext) {} - -// EnterSubfieldName is called when production subfieldName is entered. -func (s *BaseDorisSQLListener) EnterSubfieldName(ctx *SubfieldNameContext) {} - -// ExitSubfieldName is called when production subfieldName is exited. -func (s *BaseDorisSQLListener) ExitSubfieldName(ctx *SubfieldNameContext) {} - -// EnterNestedFieldName is called when production nestedFieldName is entered. -func (s *BaseDorisSQLListener) EnterNestedFieldName(ctx *NestedFieldNameContext) {} - -// ExitNestedFieldName is called when production nestedFieldName is exited. -func (s *BaseDorisSQLListener) ExitNestedFieldName(ctx *NestedFieldNameContext) {} - -// EnterAddFieldClause is called when production addFieldClause is entered. -func (s *BaseDorisSQLListener) EnterAddFieldClause(ctx *AddFieldClauseContext) {} - -// ExitAddFieldClause is called when production addFieldClause is exited. -func (s *BaseDorisSQLListener) ExitAddFieldClause(ctx *AddFieldClauseContext) {} - -// EnterDropFieldClause is called when production dropFieldClause is entered. -func (s *BaseDorisSQLListener) EnterDropFieldClause(ctx *DropFieldClauseContext) {} - -// ExitDropFieldClause is called when production dropFieldClause is exited. -func (s *BaseDorisSQLListener) ExitDropFieldClause(ctx *DropFieldClauseContext) {} - -// EnterCreateOrReplaceTagClause is called when production createOrReplaceTagClause is entered. -func (s *BaseDorisSQLListener) EnterCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) {} - -// ExitCreateOrReplaceTagClause is called when production createOrReplaceTagClause is exited. -func (s *BaseDorisSQLListener) ExitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) {} - -// EnterCreateOrReplaceBranchClause is called when production createOrReplaceBranchClause is entered. -func (s *BaseDorisSQLListener) EnterCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) { -} - -// ExitCreateOrReplaceBranchClause is called when production createOrReplaceBranchClause is exited. -func (s *BaseDorisSQLListener) ExitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) { -} - -// EnterDropBranchClause is called when production dropBranchClause is entered. -func (s *BaseDorisSQLListener) EnterDropBranchClause(ctx *DropBranchClauseContext) {} - -// ExitDropBranchClause is called when production dropBranchClause is exited. -func (s *BaseDorisSQLListener) ExitDropBranchClause(ctx *DropBranchClauseContext) {} - -// EnterDropTagClause is called when production dropTagClause is entered. -func (s *BaseDorisSQLListener) EnterDropTagClause(ctx *DropTagClauseContext) {} - -// ExitDropTagClause is called when production dropTagClause is exited. -func (s *BaseDorisSQLListener) ExitDropTagClause(ctx *DropTagClauseContext) {} - -// EnterTableOperationClause is called when production tableOperationClause is entered. -func (s *BaseDorisSQLListener) EnterTableOperationClause(ctx *TableOperationClauseContext) {} - -// ExitTableOperationClause is called when production tableOperationClause is exited. -func (s *BaseDorisSQLListener) ExitTableOperationClause(ctx *TableOperationClauseContext) {} - -// EnterTagOptions is called when production tagOptions is entered. -func (s *BaseDorisSQLListener) EnterTagOptions(ctx *TagOptionsContext) {} - -// ExitTagOptions is called when production tagOptions is exited. -func (s *BaseDorisSQLListener) ExitTagOptions(ctx *TagOptionsContext) {} - -// EnterBranchOptions is called when production branchOptions is entered. -func (s *BaseDorisSQLListener) EnterBranchOptions(ctx *BranchOptionsContext) {} - -// ExitBranchOptions is called when production branchOptions is exited. -func (s *BaseDorisSQLListener) ExitBranchOptions(ctx *BranchOptionsContext) {} - -// EnterSnapshotRetention is called when production snapshotRetention is entered. -func (s *BaseDorisSQLListener) EnterSnapshotRetention(ctx *SnapshotRetentionContext) {} - -// ExitSnapshotRetention is called when production snapshotRetention is exited. -func (s *BaseDorisSQLListener) ExitSnapshotRetention(ctx *SnapshotRetentionContext) {} - -// EnterRefRetain is called when production refRetain is entered. -func (s *BaseDorisSQLListener) EnterRefRetain(ctx *RefRetainContext) {} - -// ExitRefRetain is called when production refRetain is exited. -func (s *BaseDorisSQLListener) ExitRefRetain(ctx *RefRetainContext) {} - -// EnterMaxSnapshotAge is called when production maxSnapshotAge is entered. -func (s *BaseDorisSQLListener) EnterMaxSnapshotAge(ctx *MaxSnapshotAgeContext) {} - -// ExitMaxSnapshotAge is called when production maxSnapshotAge is exited. -func (s *BaseDorisSQLListener) ExitMaxSnapshotAge(ctx *MaxSnapshotAgeContext) {} - -// EnterMinSnapshotsToKeep is called when production minSnapshotsToKeep is entered. -func (s *BaseDorisSQLListener) EnterMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) {} - -// ExitMinSnapshotsToKeep is called when production minSnapshotsToKeep is exited. -func (s *BaseDorisSQLListener) ExitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) {} - -// EnterSnapshotId is called when production snapshotId is entered. -func (s *BaseDorisSQLListener) EnterSnapshotId(ctx *SnapshotIdContext) {} - -// ExitSnapshotId is called when production snapshotId is exited. -func (s *BaseDorisSQLListener) ExitSnapshotId(ctx *SnapshotIdContext) {} - -// EnterTimeUnit is called when production timeUnit is entered. -func (s *BaseDorisSQLListener) EnterTimeUnit(ctx *TimeUnitContext) {} - -// ExitTimeUnit is called when production timeUnit is exited. -func (s *BaseDorisSQLListener) ExitTimeUnit(ctx *TimeUnitContext) {} - -// EnterInteger_list is called when production integer_list is entered. -func (s *BaseDorisSQLListener) EnterInteger_list(ctx *Integer_listContext) {} - -// ExitInteger_list is called when production integer_list is exited. -func (s *BaseDorisSQLListener) ExitInteger_list(ctx *Integer_listContext) {} - -// EnterDropPersistentIndexClause is called when production dropPersistentIndexClause is entered. -func (s *BaseDorisSQLListener) EnterDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) { -} - -// ExitDropPersistentIndexClause is called when production dropPersistentIndexClause is exited. -func (s *BaseDorisSQLListener) ExitDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) {} - -// EnterAddPartitionClause is called when production addPartitionClause is entered. -func (s *BaseDorisSQLListener) EnterAddPartitionClause(ctx *AddPartitionClauseContext) {} - -// ExitAddPartitionClause is called when production addPartitionClause is exited. -func (s *BaseDorisSQLListener) ExitAddPartitionClause(ctx *AddPartitionClauseContext) {} - -// EnterDropPartitionClause is called when production dropPartitionClause is entered. -func (s *BaseDorisSQLListener) EnterDropPartitionClause(ctx *DropPartitionClauseContext) {} - -// ExitDropPartitionClause is called when production dropPartitionClause is exited. -func (s *BaseDorisSQLListener) ExitDropPartitionClause(ctx *DropPartitionClauseContext) {} - -// EnterTruncatePartitionClause is called when production truncatePartitionClause is entered. -func (s *BaseDorisSQLListener) EnterTruncatePartitionClause(ctx *TruncatePartitionClauseContext) {} - -// ExitTruncatePartitionClause is called when production truncatePartitionClause is exited. -func (s *BaseDorisSQLListener) ExitTruncatePartitionClause(ctx *TruncatePartitionClauseContext) {} - -// EnterModifyPartitionClause is called when production modifyPartitionClause is entered. -func (s *BaseDorisSQLListener) EnterModifyPartitionClause(ctx *ModifyPartitionClauseContext) {} - -// ExitModifyPartitionClause is called when production modifyPartitionClause is exited. -func (s *BaseDorisSQLListener) ExitModifyPartitionClause(ctx *ModifyPartitionClauseContext) {} - -// EnterReplacePartitionClause is called when production replacePartitionClause is entered. -func (s *BaseDorisSQLListener) EnterReplacePartitionClause(ctx *ReplacePartitionClauseContext) {} - -// ExitReplacePartitionClause is called when production replacePartitionClause is exited. -func (s *BaseDorisSQLListener) ExitReplacePartitionClause(ctx *ReplacePartitionClauseContext) {} - -// EnterPartitionRenameClause is called when production partitionRenameClause is entered. -func (s *BaseDorisSQLListener) EnterPartitionRenameClause(ctx *PartitionRenameClauseContext) {} - -// ExitPartitionRenameClause is called when production partitionRenameClause is exited. -func (s *BaseDorisSQLListener) ExitPartitionRenameClause(ctx *PartitionRenameClauseContext) {} - -// EnterInsertStatement is called when production insertStatement is entered. -func (s *BaseDorisSQLListener) EnterInsertStatement(ctx *InsertStatementContext) {} - -// ExitInsertStatement is called when production insertStatement is exited. -func (s *BaseDorisSQLListener) ExitInsertStatement(ctx *InsertStatementContext) {} - -// EnterInsertLabelOrColumnAliases is called when production insertLabelOrColumnAliases is entered. -func (s *BaseDorisSQLListener) EnterInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) { -} - -// ExitInsertLabelOrColumnAliases is called when production insertLabelOrColumnAliases is exited. -func (s *BaseDorisSQLListener) ExitInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) { -} - -// EnterColumnAliasesOrByName is called when production columnAliasesOrByName is entered. -func (s *BaseDorisSQLListener) EnterColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) {} - -// ExitColumnAliasesOrByName is called when production columnAliasesOrByName is exited. -func (s *BaseDorisSQLListener) ExitColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) {} - -// EnterUpdateStatement is called when production updateStatement is entered. -func (s *BaseDorisSQLListener) EnterUpdateStatement(ctx *UpdateStatementContext) {} - -// ExitUpdateStatement is called when production updateStatement is exited. -func (s *BaseDorisSQLListener) ExitUpdateStatement(ctx *UpdateStatementContext) {} - -// EnterDeleteStatement is called when production deleteStatement is entered. -func (s *BaseDorisSQLListener) EnterDeleteStatement(ctx *DeleteStatementContext) {} - -// ExitDeleteStatement is called when production deleteStatement is exited. -func (s *BaseDorisSQLListener) ExitDeleteStatement(ctx *DeleteStatementContext) {} - -// EnterCreateRoutineLoadStatement is called when production createRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) { -} - -// ExitCreateRoutineLoadStatement is called when production createRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) { -} - -// EnterAlterRoutineLoadStatement is called when production alterRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) { -} - -// ExitAlterRoutineLoadStatement is called when production alterRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) {} - -// EnterDataSource is called when production dataSource is entered. -func (s *BaseDorisSQLListener) EnterDataSource(ctx *DataSourceContext) {} - -// ExitDataSource is called when production dataSource is exited. -func (s *BaseDorisSQLListener) ExitDataSource(ctx *DataSourceContext) {} - -// EnterLoadProperties is called when production loadProperties is entered. -func (s *BaseDorisSQLListener) EnterLoadProperties(ctx *LoadPropertiesContext) {} - -// ExitLoadProperties is called when production loadProperties is exited. -func (s *BaseDorisSQLListener) ExitLoadProperties(ctx *LoadPropertiesContext) {} - -// EnterColSeparatorProperty is called when production colSeparatorProperty is entered. -func (s *BaseDorisSQLListener) EnterColSeparatorProperty(ctx *ColSeparatorPropertyContext) {} - -// ExitColSeparatorProperty is called when production colSeparatorProperty is exited. -func (s *BaseDorisSQLListener) ExitColSeparatorProperty(ctx *ColSeparatorPropertyContext) {} - -// EnterRowDelimiterProperty is called when production rowDelimiterProperty is entered. -func (s *BaseDorisSQLListener) EnterRowDelimiterProperty(ctx *RowDelimiterPropertyContext) {} - -// ExitRowDelimiterProperty is called when production rowDelimiterProperty is exited. -func (s *BaseDorisSQLListener) ExitRowDelimiterProperty(ctx *RowDelimiterPropertyContext) {} - -// EnterImportColumns is called when production importColumns is entered. -func (s *BaseDorisSQLListener) EnterImportColumns(ctx *ImportColumnsContext) {} - -// ExitImportColumns is called when production importColumns is exited. -func (s *BaseDorisSQLListener) ExitImportColumns(ctx *ImportColumnsContext) {} - -// EnterColumnProperties is called when production columnProperties is entered. -func (s *BaseDorisSQLListener) EnterColumnProperties(ctx *ColumnPropertiesContext) {} - -// ExitColumnProperties is called when production columnProperties is exited. -func (s *BaseDorisSQLListener) ExitColumnProperties(ctx *ColumnPropertiesContext) {} - -// EnterJobProperties is called when production jobProperties is entered. -func (s *BaseDorisSQLListener) EnterJobProperties(ctx *JobPropertiesContext) {} - -// ExitJobProperties is called when production jobProperties is exited. -func (s *BaseDorisSQLListener) ExitJobProperties(ctx *JobPropertiesContext) {} - -// EnterDataSourceProperties is called when production dataSourceProperties is entered. -func (s *BaseDorisSQLListener) EnterDataSourceProperties(ctx *DataSourcePropertiesContext) {} - -// ExitDataSourceProperties is called when production dataSourceProperties is exited. -func (s *BaseDorisSQLListener) ExitDataSourceProperties(ctx *DataSourcePropertiesContext) {} - -// EnterStopRoutineLoadStatement is called when production stopRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) {} - -// ExitStopRoutineLoadStatement is called when production stopRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) {} - -// EnterResumeRoutineLoadStatement is called when production resumeRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) { -} - -// ExitResumeRoutineLoadStatement is called when production resumeRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) { -} - -// EnterPauseRoutineLoadStatement is called when production pauseRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) { -} - -// ExitPauseRoutineLoadStatement is called when production pauseRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) {} - -// EnterShowRoutineLoadStatement is called when production showRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) {} - -// ExitShowRoutineLoadStatement is called when production showRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) {} - -// EnterShowRoutineLoadTaskStatement is called when production showRoutineLoadTaskStatement is entered. -func (s *BaseDorisSQLListener) EnterShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) { -} - -// ExitShowRoutineLoadTaskStatement is called when production showRoutineLoadTaskStatement is exited. -func (s *BaseDorisSQLListener) ExitShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) { -} - -// EnterShowCreateRoutineLoadStatement is called when production showCreateRoutineLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) { -} - -// ExitShowCreateRoutineLoadStatement is called when production showCreateRoutineLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) { -} - -// EnterShowStreamLoadStatement is called when production showStreamLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) {} - -// ExitShowStreamLoadStatement is called when production showStreamLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) {} - -// EnterAnalyzeStatement is called when production analyzeStatement is entered. -func (s *BaseDorisSQLListener) EnterAnalyzeStatement(ctx *AnalyzeStatementContext) {} - -// ExitAnalyzeStatement is called when production analyzeStatement is exited. -func (s *BaseDorisSQLListener) ExitAnalyzeStatement(ctx *AnalyzeStatementContext) {} - -// EnterRegularColumns is called when production regularColumns is entered. -func (s *BaseDorisSQLListener) EnterRegularColumns(ctx *RegularColumnsContext) {} - -// ExitRegularColumns is called when production regularColumns is exited. -func (s *BaseDorisSQLListener) ExitRegularColumns(ctx *RegularColumnsContext) {} - -// EnterAllColumns is called when production allColumns is entered. -func (s *BaseDorisSQLListener) EnterAllColumns(ctx *AllColumnsContext) {} - -// ExitAllColumns is called when production allColumns is exited. -func (s *BaseDorisSQLListener) ExitAllColumns(ctx *AllColumnsContext) {} - -// EnterPredicateColumns is called when production predicateColumns is entered. -func (s *BaseDorisSQLListener) EnterPredicateColumns(ctx *PredicateColumnsContext) {} - -// ExitPredicateColumns is called when production predicateColumns is exited. -func (s *BaseDorisSQLListener) ExitPredicateColumns(ctx *PredicateColumnsContext) {} - -// EnterMultiColumnSet is called when production multiColumnSet is entered. -func (s *BaseDorisSQLListener) EnterMultiColumnSet(ctx *MultiColumnSetContext) {} - -// ExitMultiColumnSet is called when production multiColumnSet is exited. -func (s *BaseDorisSQLListener) ExitMultiColumnSet(ctx *MultiColumnSetContext) {} - -// EnterDropStatsStatement is called when production dropStatsStatement is entered. -func (s *BaseDorisSQLListener) EnterDropStatsStatement(ctx *DropStatsStatementContext) {} - -// ExitDropStatsStatement is called when production dropStatsStatement is exited. -func (s *BaseDorisSQLListener) ExitDropStatsStatement(ctx *DropStatsStatementContext) {} - -// EnterHistogramStatement is called when production histogramStatement is entered. -func (s *BaseDorisSQLListener) EnterHistogramStatement(ctx *HistogramStatementContext) {} - -// ExitHistogramStatement is called when production histogramStatement is exited. -func (s *BaseDorisSQLListener) ExitHistogramStatement(ctx *HistogramStatementContext) {} - -// EnterAnalyzeHistogramStatement is called when production analyzeHistogramStatement is entered. -func (s *BaseDorisSQLListener) EnterAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) { -} - -// ExitAnalyzeHistogramStatement is called when production analyzeHistogramStatement is exited. -func (s *BaseDorisSQLListener) ExitAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) {} - -// EnterDropHistogramStatement is called when production dropHistogramStatement is entered. -func (s *BaseDorisSQLListener) EnterDropHistogramStatement(ctx *DropHistogramStatementContext) {} - -// ExitDropHistogramStatement is called when production dropHistogramStatement is exited. -func (s *BaseDorisSQLListener) ExitDropHistogramStatement(ctx *DropHistogramStatementContext) {} - -// EnterCreateAnalyzeStatement is called when production createAnalyzeStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) {} - -// ExitCreateAnalyzeStatement is called when production createAnalyzeStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) {} - -// EnterDropAnalyzeJobStatement is called when production dropAnalyzeJobStatement is entered. -func (s *BaseDorisSQLListener) EnterDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) {} - -// ExitDropAnalyzeJobStatement is called when production dropAnalyzeJobStatement is exited. -func (s *BaseDorisSQLListener) ExitDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) {} - -// EnterShowAnalyzeStatement is called when production showAnalyzeStatement is entered. -func (s *BaseDorisSQLListener) EnterShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) {} - -// ExitShowAnalyzeStatement is called when production showAnalyzeStatement is exited. -func (s *BaseDorisSQLListener) ExitShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) {} - -// EnterShowStatsMetaStatement is called when production showStatsMetaStatement is entered. -func (s *BaseDorisSQLListener) EnterShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) {} - -// ExitShowStatsMetaStatement is called when production showStatsMetaStatement is exited. -func (s *BaseDorisSQLListener) ExitShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) {} - -// EnterShowHistogramMetaStatement is called when production showHistogramMetaStatement is entered. -func (s *BaseDorisSQLListener) EnterShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) { -} - -// ExitShowHistogramMetaStatement is called when production showHistogramMetaStatement is exited. -func (s *BaseDorisSQLListener) ExitShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) { -} - -// EnterKillAnalyzeStatement is called when production killAnalyzeStatement is entered. -func (s *BaseDorisSQLListener) EnterKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) {} - -// ExitKillAnalyzeStatement is called when production killAnalyzeStatement is exited. -func (s *BaseDorisSQLListener) ExitKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) {} - -// EnterAnalyzeProfileStatement is called when production analyzeProfileStatement is entered. -func (s *BaseDorisSQLListener) EnterAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) {} - -// ExitAnalyzeProfileStatement is called when production analyzeProfileStatement is exited. -func (s *BaseDorisSQLListener) ExitAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) {} - -// EnterCreateBaselinePlanStatement is called when production createBaselinePlanStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) { -} - -// ExitCreateBaselinePlanStatement is called when production createBaselinePlanStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) { -} - -// EnterDropBaselinePlanStatement is called when production dropBaselinePlanStatement is entered. -func (s *BaseDorisSQLListener) EnterDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) { -} - -// ExitDropBaselinePlanStatement is called when production dropBaselinePlanStatement is exited. -func (s *BaseDorisSQLListener) ExitDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) {} - -// EnterShowBaselinePlanStatement is called when production showBaselinePlanStatement is entered. -func (s *BaseDorisSQLListener) EnterShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) { -} - -// ExitShowBaselinePlanStatement is called when production showBaselinePlanStatement is exited. -func (s *BaseDorisSQLListener) ExitShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) {} - -// EnterCreateResourceGroupStatement is called when production createResourceGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) { -} - -// ExitCreateResourceGroupStatement is called when production createResourceGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) { -} - -// EnterDropResourceGroupStatement is called when production dropResourceGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) { -} - -// ExitDropResourceGroupStatement is called when production dropResourceGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) { -} - -// EnterAlterResourceGroupStatement is called when production alterResourceGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) { -} - -// ExitAlterResourceGroupStatement is called when production alterResourceGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) { -} - -// EnterShowResourceGroupStatement is called when production showResourceGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) { -} - -// ExitShowResourceGroupStatement is called when production showResourceGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) { -} - -// EnterShowResourceGroupUsageStatement is called when production showResourceGroupUsageStatement is entered. -func (s *BaseDorisSQLListener) EnterShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) { -} - -// ExitShowResourceGroupUsageStatement is called when production showResourceGroupUsageStatement is exited. -func (s *BaseDorisSQLListener) ExitShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) { -} - -// EnterCreateResourceStatement is called when production createResourceStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateResourceStatement(ctx *CreateResourceStatementContext) {} - -// ExitCreateResourceStatement is called when production createResourceStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateResourceStatement(ctx *CreateResourceStatementContext) {} - -// EnterAlterResourceStatement is called when production alterResourceStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterResourceStatement(ctx *AlterResourceStatementContext) {} - -// ExitAlterResourceStatement is called when production alterResourceStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterResourceStatement(ctx *AlterResourceStatementContext) {} - -// EnterDropResourceStatement is called when production dropResourceStatement is entered. -func (s *BaseDorisSQLListener) EnterDropResourceStatement(ctx *DropResourceStatementContext) {} - -// ExitDropResourceStatement is called when production dropResourceStatement is exited. -func (s *BaseDorisSQLListener) ExitDropResourceStatement(ctx *DropResourceStatementContext) {} - -// EnterShowResourceStatement is called when production showResourceStatement is entered. -func (s *BaseDorisSQLListener) EnterShowResourceStatement(ctx *ShowResourceStatementContext) {} - -// ExitShowResourceStatement is called when production showResourceStatement is exited. -func (s *BaseDorisSQLListener) ExitShowResourceStatement(ctx *ShowResourceStatementContext) {} - -// EnterClassifier is called when production classifier is entered. -func (s *BaseDorisSQLListener) EnterClassifier(ctx *ClassifierContext) {} - -// ExitClassifier is called when production classifier is exited. -func (s *BaseDorisSQLListener) ExitClassifier(ctx *ClassifierContext) {} - -// EnterShowFunctionsStatement is called when production showFunctionsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowFunctionsStatement(ctx *ShowFunctionsStatementContext) {} - -// ExitShowFunctionsStatement is called when production showFunctionsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowFunctionsStatement(ctx *ShowFunctionsStatementContext) {} - -// EnterDropFunctionStatement is called when production dropFunctionStatement is entered. -func (s *BaseDorisSQLListener) EnterDropFunctionStatement(ctx *DropFunctionStatementContext) {} - -// ExitDropFunctionStatement is called when production dropFunctionStatement is exited. -func (s *BaseDorisSQLListener) ExitDropFunctionStatement(ctx *DropFunctionStatementContext) {} - -// EnterCreateFunctionStatement is called when production createFunctionStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateFunctionStatement(ctx *CreateFunctionStatementContext) {} - -// ExitCreateFunctionStatement is called when production createFunctionStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateFunctionStatement(ctx *CreateFunctionStatementContext) {} - -// EnterInlineFunction is called when production inlineFunction is entered. -func (s *BaseDorisSQLListener) EnterInlineFunction(ctx *InlineFunctionContext) {} - -// ExitInlineFunction is called when production inlineFunction is exited. -func (s *BaseDorisSQLListener) ExitInlineFunction(ctx *InlineFunctionContext) {} - -// EnterTypeList is called when production typeList is entered. -func (s *BaseDorisSQLListener) EnterTypeList(ctx *TypeListContext) {} - -// ExitTypeList is called when production typeList is exited. -func (s *BaseDorisSQLListener) ExitTypeList(ctx *TypeListContext) {} - -// EnterLoadStatement is called when production loadStatement is entered. -func (s *BaseDorisSQLListener) EnterLoadStatement(ctx *LoadStatementContext) {} - -// ExitLoadStatement is called when production loadStatement is exited. -func (s *BaseDorisSQLListener) ExitLoadStatement(ctx *LoadStatementContext) {} - -// EnterLabelName is called when production labelName is entered. -func (s *BaseDorisSQLListener) EnterLabelName(ctx *LabelNameContext) {} - -// ExitLabelName is called when production labelName is exited. -func (s *BaseDorisSQLListener) ExitLabelName(ctx *LabelNameContext) {} - -// EnterDataDescList is called when production dataDescList is entered. -func (s *BaseDorisSQLListener) EnterDataDescList(ctx *DataDescListContext) {} - -// ExitDataDescList is called when production dataDescList is exited. -func (s *BaseDorisSQLListener) ExitDataDescList(ctx *DataDescListContext) {} - -// EnterDataDesc is called when production dataDesc is entered. -func (s *BaseDorisSQLListener) EnterDataDesc(ctx *DataDescContext) {} - -// ExitDataDesc is called when production dataDesc is exited. -func (s *BaseDorisSQLListener) ExitDataDesc(ctx *DataDescContext) {} - -// EnterFormatProps is called when production formatProps is entered. -func (s *BaseDorisSQLListener) EnterFormatProps(ctx *FormatPropsContext) {} - -// ExitFormatProps is called when production formatProps is exited. -func (s *BaseDorisSQLListener) ExitFormatProps(ctx *FormatPropsContext) {} - -// EnterBrokerDesc is called when production brokerDesc is entered. -func (s *BaseDorisSQLListener) EnterBrokerDesc(ctx *BrokerDescContext) {} - -// ExitBrokerDesc is called when production brokerDesc is exited. -func (s *BaseDorisSQLListener) ExitBrokerDesc(ctx *BrokerDescContext) {} - -// EnterResourceDesc is called when production resourceDesc is entered. -func (s *BaseDorisSQLListener) EnterResourceDesc(ctx *ResourceDescContext) {} - -// ExitResourceDesc is called when production resourceDesc is exited. -func (s *BaseDorisSQLListener) ExitResourceDesc(ctx *ResourceDescContext) {} - -// EnterShowLoadStatement is called when production showLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterShowLoadStatement(ctx *ShowLoadStatementContext) {} - -// ExitShowLoadStatement is called when production showLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitShowLoadStatement(ctx *ShowLoadStatementContext) {} - -// EnterShowLoadWarningsStatement is called when production showLoadWarningsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) { -} - -// ExitShowLoadWarningsStatement is called when production showLoadWarningsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) {} - -// EnterCancelLoadStatement is called when production cancelLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelLoadStatement(ctx *CancelLoadStatementContext) {} - -// ExitCancelLoadStatement is called when production cancelLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelLoadStatement(ctx *CancelLoadStatementContext) {} - -// EnterAlterLoadStatement is called when production alterLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterLoadStatement(ctx *AlterLoadStatementContext) {} - -// ExitAlterLoadStatement is called when production alterLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterLoadStatement(ctx *AlterLoadStatementContext) {} - -// EnterCancelCompactionStatement is called when production cancelCompactionStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelCompactionStatement(ctx *CancelCompactionStatementContext) { -} - -// ExitCancelCompactionStatement is called when production cancelCompactionStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelCompactionStatement(ctx *CancelCompactionStatementContext) {} - -// EnterShowAuthorStatement is called when production showAuthorStatement is entered. -func (s *BaseDorisSQLListener) EnterShowAuthorStatement(ctx *ShowAuthorStatementContext) {} - -// ExitShowAuthorStatement is called when production showAuthorStatement is exited. -func (s *BaseDorisSQLListener) ExitShowAuthorStatement(ctx *ShowAuthorStatementContext) {} - -// EnterShowBackendsStatement is called when production showBackendsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowBackendsStatement(ctx *ShowBackendsStatementContext) {} - -// ExitShowBackendsStatement is called when production showBackendsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowBackendsStatement(ctx *ShowBackendsStatementContext) {} - -// EnterShowBrokerStatement is called when production showBrokerStatement is entered. -func (s *BaseDorisSQLListener) EnterShowBrokerStatement(ctx *ShowBrokerStatementContext) {} - -// ExitShowBrokerStatement is called when production showBrokerStatement is exited. -func (s *BaseDorisSQLListener) ExitShowBrokerStatement(ctx *ShowBrokerStatementContext) {} - -// EnterShowCharsetStatement is called when production showCharsetStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCharsetStatement(ctx *ShowCharsetStatementContext) {} - -// ExitShowCharsetStatement is called when production showCharsetStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCharsetStatement(ctx *ShowCharsetStatementContext) {} - -// EnterShowCollationStatement is called when production showCollationStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCollationStatement(ctx *ShowCollationStatementContext) {} - -// ExitShowCollationStatement is called when production showCollationStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCollationStatement(ctx *ShowCollationStatementContext) {} - -// EnterShowDeleteStatement is called when production showDeleteStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDeleteStatement(ctx *ShowDeleteStatementContext) {} - -// ExitShowDeleteStatement is called when production showDeleteStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDeleteStatement(ctx *ShowDeleteStatementContext) {} - -// EnterShowDynamicPartitionStatement is called when production showDynamicPartitionStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) { -} - -// ExitShowDynamicPartitionStatement is called when production showDynamicPartitionStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) { -} - -// EnterShowEventsStatement is called when production showEventsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowEventsStatement(ctx *ShowEventsStatementContext) {} - -// ExitShowEventsStatement is called when production showEventsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowEventsStatement(ctx *ShowEventsStatementContext) {} - -// EnterShowEnginesStatement is called when production showEnginesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowEnginesStatement(ctx *ShowEnginesStatementContext) {} - -// ExitShowEnginesStatement is called when production showEnginesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowEnginesStatement(ctx *ShowEnginesStatementContext) {} - -// EnterShowFrontendsStatement is called when production showFrontendsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowFrontendsStatement(ctx *ShowFrontendsStatementContext) {} - -// ExitShowFrontendsStatement is called when production showFrontendsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowFrontendsStatement(ctx *ShowFrontendsStatementContext) {} - -// EnterShowFrontendsDisksStatement is called when production showFrontendsDisksStatement is entered. -func (s *BaseDorisSQLListener) EnterShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) { -} - -// ExitShowFrontendsDisksStatement is called when production showFrontendsDisksStatement is exited. -func (s *BaseDorisSQLListener) ExitShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) { -} - -// EnterShowPluginsStatement is called when production showPluginsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPluginsStatement(ctx *ShowPluginsStatementContext) {} - -// ExitShowPluginsStatement is called when production showPluginsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPluginsStatement(ctx *ShowPluginsStatementContext) {} - -// EnterShowRepositoriesStatement is called when production showRepositoriesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) { -} - -// ExitShowRepositoriesStatement is called when production showRepositoriesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) {} - -// EnterShowOpenTableStatement is called when production showOpenTableStatement is entered. -func (s *BaseDorisSQLListener) EnterShowOpenTableStatement(ctx *ShowOpenTableStatementContext) {} - -// ExitShowOpenTableStatement is called when production showOpenTableStatement is exited. -func (s *BaseDorisSQLListener) ExitShowOpenTableStatement(ctx *ShowOpenTableStatementContext) {} - -// EnterShowPrivilegesStatement is called when production showPrivilegesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) {} - -// ExitShowPrivilegesStatement is called when production showPrivilegesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) {} - -// EnterShowProcedureStatement is called when production showProcedureStatement is entered. -func (s *BaseDorisSQLListener) EnterShowProcedureStatement(ctx *ShowProcedureStatementContext) {} - -// ExitShowProcedureStatement is called when production showProcedureStatement is exited. -func (s *BaseDorisSQLListener) ExitShowProcedureStatement(ctx *ShowProcedureStatementContext) {} - -// EnterShowProcStatement is called when production showProcStatement is entered. -func (s *BaseDorisSQLListener) EnterShowProcStatement(ctx *ShowProcStatementContext) {} - -// ExitShowProcStatement is called when production showProcStatement is exited. -func (s *BaseDorisSQLListener) ExitShowProcStatement(ctx *ShowProcStatementContext) {} - -// EnterShowProcesslistStatement is called when production showProcesslistStatement is entered. -func (s *BaseDorisSQLListener) EnterShowProcesslistStatement(ctx *ShowProcesslistStatementContext) {} - -// ExitShowProcesslistStatement is called when production showProcesslistStatement is exited. -func (s *BaseDorisSQLListener) ExitShowProcesslistStatement(ctx *ShowProcesslistStatementContext) {} - -// EnterShowProfilelistStatement is called when production showProfilelistStatement is entered. -func (s *BaseDorisSQLListener) EnterShowProfilelistStatement(ctx *ShowProfilelistStatementContext) {} - -// ExitShowProfilelistStatement is called when production showProfilelistStatement is exited. -func (s *BaseDorisSQLListener) ExitShowProfilelistStatement(ctx *ShowProfilelistStatementContext) {} - -// EnterShowRunningQueriesStatement is called when production showRunningQueriesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) { -} - -// ExitShowRunningQueriesStatement is called when production showRunningQueriesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) { -} - -// EnterShowStatusStatement is called when production showStatusStatement is entered. -func (s *BaseDorisSQLListener) EnterShowStatusStatement(ctx *ShowStatusStatementContext) {} - -// ExitShowStatusStatement is called when production showStatusStatement is exited. -func (s *BaseDorisSQLListener) ExitShowStatusStatement(ctx *ShowStatusStatementContext) {} - -// EnterShowTabletStatement is called when production showTabletStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTabletStatement(ctx *ShowTabletStatementContext) {} - -// ExitShowTabletStatement is called when production showTabletStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTabletStatement(ctx *ShowTabletStatementContext) {} - -// EnterShowTransactionStatement is called when production showTransactionStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTransactionStatement(ctx *ShowTransactionStatementContext) {} - -// ExitShowTransactionStatement is called when production showTransactionStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTransactionStatement(ctx *ShowTransactionStatementContext) {} - -// EnterShowTriggersStatement is called when production showTriggersStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTriggersStatement(ctx *ShowTriggersStatementContext) {} - -// ExitShowTriggersStatement is called when production showTriggersStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTriggersStatement(ctx *ShowTriggersStatementContext) {} - -// EnterShowUserPropertyStatement is called when production showUserPropertyStatement is entered. -func (s *BaseDorisSQLListener) EnterShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) { -} - -// ExitShowUserPropertyStatement is called when production showUserPropertyStatement is exited. -func (s *BaseDorisSQLListener) ExitShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) {} - -// EnterShowVariablesStatement is called when production showVariablesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowVariablesStatement(ctx *ShowVariablesStatementContext) {} - -// ExitShowVariablesStatement is called when production showVariablesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowVariablesStatement(ctx *ShowVariablesStatementContext) {} - -// EnterShowWarningStatement is called when production showWarningStatement is entered. -func (s *BaseDorisSQLListener) EnterShowWarningStatement(ctx *ShowWarningStatementContext) {} - -// ExitShowWarningStatement is called when production showWarningStatement is exited. -func (s *BaseDorisSQLListener) ExitShowWarningStatement(ctx *ShowWarningStatementContext) {} - -// EnterHelpStatement is called when production helpStatement is entered. -func (s *BaseDorisSQLListener) EnterHelpStatement(ctx *HelpStatementContext) {} - -// ExitHelpStatement is called when production helpStatement is exited. -func (s *BaseDorisSQLListener) ExitHelpStatement(ctx *HelpStatementContext) {} - -// EnterShowQueryProfileStatement is called when production showQueryProfileStatement is entered. -func (s *BaseDorisSQLListener) EnterShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) { -} - -// ExitShowQueryProfileStatement is called when production showQueryProfileStatement is exited. -func (s *BaseDorisSQLListener) ExitShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) {} - -// EnterShowQueryStatsStatement is called when production showQueryStatsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) {} - -// ExitShowQueryStatsStatement is called when production showQueryStatsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) {} - -// EnterShowLoadProfileStatement is called when production showLoadProfileStatement is entered. -func (s *BaseDorisSQLListener) EnterShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) {} - -// ExitShowLoadProfileStatement is called when production showLoadProfileStatement is exited. -func (s *BaseDorisSQLListener) ExitShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) {} - -// EnterShowDataSkewStatement is called when production showDataSkewStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDataSkewStatement(ctx *ShowDataSkewStatementContext) {} - -// ExitShowDataSkewStatement is called when production showDataSkewStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDataSkewStatement(ctx *ShowDataSkewStatementContext) {} - -// EnterShowDataTypesStatement is called when production showDataTypesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDataTypesStatement(ctx *ShowDataTypesStatementContext) {} - -// ExitShowDataTypesStatement is called when production showDataTypesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDataTypesStatement(ctx *ShowDataTypesStatementContext) {} - -// EnterShowSyncJobStatement is called when production showSyncJobStatement is entered. -func (s *BaseDorisSQLListener) EnterShowSyncJobStatement(ctx *ShowSyncJobStatementContext) {} - -// ExitShowSyncJobStatement is called when production showSyncJobStatement is exited. -func (s *BaseDorisSQLListener) ExitShowSyncJobStatement(ctx *ShowSyncJobStatementContext) {} - -// EnterShowPolicyStatement is called when production showPolicyStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPolicyStatement(ctx *ShowPolicyStatementContext) {} - -// ExitShowPolicyStatement is called when production showPolicyStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPolicyStatement(ctx *ShowPolicyStatementContext) {} - -// EnterShowSqlBlockRuleStatement is called when production showSqlBlockRuleStatement is entered. -func (s *BaseDorisSQLListener) EnterShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) { -} - -// ExitShowSqlBlockRuleStatement is called when production showSqlBlockRuleStatement is exited. -func (s *BaseDorisSQLListener) ExitShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) {} - -// EnterShowEncryptKeysStatement is called when production showEncryptKeysStatement is entered. -func (s *BaseDorisSQLListener) EnterShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) {} - -// ExitShowEncryptKeysStatement is called when production showEncryptKeysStatement is exited. -func (s *BaseDorisSQLListener) ExitShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) {} - -// EnterShowCreateLoadStatement is called when production showCreateLoadStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) {} - -// ExitShowCreateLoadStatement is called when production showCreateLoadStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) {} - -// EnterShowCreateRepositoryStatement is called when production showCreateRepositoryStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) { -} - -// ExitShowCreateRepositoryStatement is called when production showCreateRepositoryStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) { -} - -// EnterShowLastInsertStatement is called when production showLastInsertStatement is entered. -func (s *BaseDorisSQLListener) EnterShowLastInsertStatement(ctx *ShowLastInsertStatementContext) {} - -// ExitShowLastInsertStatement is called when production showLastInsertStatement is exited. -func (s *BaseDorisSQLListener) ExitShowLastInsertStatement(ctx *ShowLastInsertStatementContext) {} - -// EnterShowTableIdStatement is called when production showTableIdStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTableIdStatement(ctx *ShowTableIdStatementContext) {} - -// ExitShowTableIdStatement is called when production showTableIdStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTableIdStatement(ctx *ShowTableIdStatementContext) {} - -// EnterShowDatabaseIdStatement is called when production showDatabaseIdStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) {} - -// ExitShowDatabaseIdStatement is called when production showDatabaseIdStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) {} - -// EnterShowPartitionIdStatement is called when production showPartitionIdStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) {} - -// ExitShowPartitionIdStatement is called when production showPartitionIdStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) {} - -// EnterShowTableStatsStatement is called when production showTableStatsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTableStatsStatement(ctx *ShowTableStatsStatementContext) {} - -// ExitShowTableStatsStatement is called when production showTableStatsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTableStatsStatement(ctx *ShowTableStatsStatementContext) {} - -// EnterShowColumnStatsStatement is called when production showColumnStatsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) {} - -// ExitShowColumnStatsStatement is called when production showColumnStatsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) {} - -// EnterShowConvertLightSchemaChangeStatement is called when production showConvertLightSchemaChangeStatement is entered. -func (s *BaseDorisSQLListener) EnterShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) { -} - -// ExitShowConvertLightSchemaChangeStatement is called when production showConvertLightSchemaChangeStatement is exited. -func (s *BaseDorisSQLListener) ExitShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) { -} - -// EnterShowCatalogRecycleBinStatement is called when production showCatalogRecycleBinStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) { -} - -// ExitShowCatalogRecycleBinStatement is called when production showCatalogRecycleBinStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) { -} - -// EnterShowTrashStatement is called when production showTrashStatement is entered. -func (s *BaseDorisSQLListener) EnterShowTrashStatement(ctx *ShowTrashStatementContext) {} - -// ExitShowTrashStatement is called when production showTrashStatement is exited. -func (s *BaseDorisSQLListener) ExitShowTrashStatement(ctx *ShowTrashStatementContext) {} - -// EnterShowMigrationsStatement is called when production showMigrationsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowMigrationsStatement(ctx *ShowMigrationsStatementContext) {} - -// ExitShowMigrationsStatement is called when production showMigrationsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowMigrationsStatement(ctx *ShowMigrationsStatementContext) {} - -// EnterShowWorkloadGroupsStatement is called when production showWorkloadGroupsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) { -} - -// ExitShowWorkloadGroupsStatement is called when production showWorkloadGroupsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) { -} - -// EnterShowJobTaskStatement is called when production showJobTaskStatement is entered. -func (s *BaseDorisSQLListener) EnterShowJobTaskStatement(ctx *ShowJobTaskStatementContext) {} - -// ExitShowJobTaskStatement is called when production showJobTaskStatement is exited. -func (s *BaseDorisSQLListener) ExitShowJobTaskStatement(ctx *ShowJobTaskStatementContext) {} - -// EnterCreateUserStatement is called when production createUserStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateUserStatement(ctx *CreateUserStatementContext) {} - -// ExitCreateUserStatement is called when production createUserStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateUserStatement(ctx *CreateUserStatementContext) {} - -// EnterDropUserStatement is called when production dropUserStatement is entered. -func (s *BaseDorisSQLListener) EnterDropUserStatement(ctx *DropUserStatementContext) {} - -// ExitDropUserStatement is called when production dropUserStatement is exited. -func (s *BaseDorisSQLListener) ExitDropUserStatement(ctx *DropUserStatementContext) {} - -// EnterAlterUserStatement is called when production alterUserStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterUserStatement(ctx *AlterUserStatementContext) {} - -// ExitAlterUserStatement is called when production alterUserStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterUserStatement(ctx *AlterUserStatementContext) {} - -// EnterShowUserStatement is called when production showUserStatement is entered. -func (s *BaseDorisSQLListener) EnterShowUserStatement(ctx *ShowUserStatementContext) {} - -// ExitShowUserStatement is called when production showUserStatement is exited. -func (s *BaseDorisSQLListener) ExitShowUserStatement(ctx *ShowUserStatementContext) {} - -// EnterShowAllAuthentication is called when production showAllAuthentication is entered. -func (s *BaseDorisSQLListener) EnterShowAllAuthentication(ctx *ShowAllAuthenticationContext) {} - -// ExitShowAllAuthentication is called when production showAllAuthentication is exited. -func (s *BaseDorisSQLListener) ExitShowAllAuthentication(ctx *ShowAllAuthenticationContext) {} - -// EnterShowAuthenticationForUser is called when production showAuthenticationForUser is entered. -func (s *BaseDorisSQLListener) EnterShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) { -} - -// ExitShowAuthenticationForUser is called when production showAuthenticationForUser is exited. -func (s *BaseDorisSQLListener) ExitShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) {} - -// EnterExecuteAsStatement is called when production executeAsStatement is entered. -func (s *BaseDorisSQLListener) EnterExecuteAsStatement(ctx *ExecuteAsStatementContext) {} - -// ExitExecuteAsStatement is called when production executeAsStatement is exited. -func (s *BaseDorisSQLListener) ExitExecuteAsStatement(ctx *ExecuteAsStatementContext) {} - -// EnterCreateRoleStatement is called when production createRoleStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateRoleStatement(ctx *CreateRoleStatementContext) {} - -// ExitCreateRoleStatement is called when production createRoleStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateRoleStatement(ctx *CreateRoleStatementContext) {} - -// EnterAlterRoleStatement is called when production alterRoleStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterRoleStatement(ctx *AlterRoleStatementContext) {} - -// ExitAlterRoleStatement is called when production alterRoleStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterRoleStatement(ctx *AlterRoleStatementContext) {} - -// EnterDropRoleStatement is called when production dropRoleStatement is entered. -func (s *BaseDorisSQLListener) EnterDropRoleStatement(ctx *DropRoleStatementContext) {} - -// ExitDropRoleStatement is called when production dropRoleStatement is exited. -func (s *BaseDorisSQLListener) ExitDropRoleStatement(ctx *DropRoleStatementContext) {} - -// EnterShowRolesStatement is called when production showRolesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowRolesStatement(ctx *ShowRolesStatementContext) {} - -// ExitShowRolesStatement is called when production showRolesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowRolesStatement(ctx *ShowRolesStatementContext) {} - -// EnterGrantRoleToUser is called when production grantRoleToUser is entered. -func (s *BaseDorisSQLListener) EnterGrantRoleToUser(ctx *GrantRoleToUserContext) {} - -// ExitGrantRoleToUser is called when production grantRoleToUser is exited. -func (s *BaseDorisSQLListener) ExitGrantRoleToUser(ctx *GrantRoleToUserContext) {} - -// EnterGrantRoleToRole is called when production grantRoleToRole is entered. -func (s *BaseDorisSQLListener) EnterGrantRoleToRole(ctx *GrantRoleToRoleContext) {} - -// ExitGrantRoleToRole is called when production grantRoleToRole is exited. -func (s *BaseDorisSQLListener) ExitGrantRoleToRole(ctx *GrantRoleToRoleContext) {} - -// EnterRevokeRoleFromUser is called when production revokeRoleFromUser is entered. -func (s *BaseDorisSQLListener) EnterRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) {} - -// ExitRevokeRoleFromUser is called when production revokeRoleFromUser is exited. -func (s *BaseDorisSQLListener) ExitRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) {} - -// EnterRevokeRoleFromRole is called when production revokeRoleFromRole is entered. -func (s *BaseDorisSQLListener) EnterRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) {} - -// ExitRevokeRoleFromRole is called when production revokeRoleFromRole is exited. -func (s *BaseDorisSQLListener) ExitRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) {} - -// EnterSetRoleStatement is called when production setRoleStatement is entered. -func (s *BaseDorisSQLListener) EnterSetRoleStatement(ctx *SetRoleStatementContext) {} - -// ExitSetRoleStatement is called when production setRoleStatement is exited. -func (s *BaseDorisSQLListener) ExitSetRoleStatement(ctx *SetRoleStatementContext) {} - -// EnterSetDefaultRoleStatement is called when production setDefaultRoleStatement is entered. -func (s *BaseDorisSQLListener) EnterSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) {} - -// ExitSetDefaultRoleStatement is called when production setDefaultRoleStatement is exited. -func (s *BaseDorisSQLListener) ExitSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) {} - -// EnterGrantRevokeClause is called when production grantRevokeClause is entered. -func (s *BaseDorisSQLListener) EnterGrantRevokeClause(ctx *GrantRevokeClauseContext) {} - -// ExitGrantRevokeClause is called when production grantRevokeClause is exited. -func (s *BaseDorisSQLListener) ExitGrantRevokeClause(ctx *GrantRevokeClauseContext) {} - -// EnterGrantOnUser is called when production grantOnUser is entered. -func (s *BaseDorisSQLListener) EnterGrantOnUser(ctx *GrantOnUserContext) {} - -// ExitGrantOnUser is called when production grantOnUser is exited. -func (s *BaseDorisSQLListener) ExitGrantOnUser(ctx *GrantOnUserContext) {} - -// EnterGrantOnTableBrief is called when production grantOnTableBrief is entered. -func (s *BaseDorisSQLListener) EnterGrantOnTableBrief(ctx *GrantOnTableBriefContext) {} - -// ExitGrantOnTableBrief is called when production grantOnTableBrief is exited. -func (s *BaseDorisSQLListener) ExitGrantOnTableBrief(ctx *GrantOnTableBriefContext) {} - -// EnterGrantOnFunc is called when production grantOnFunc is entered. -func (s *BaseDorisSQLListener) EnterGrantOnFunc(ctx *GrantOnFuncContext) {} - -// ExitGrantOnFunc is called when production grantOnFunc is exited. -func (s *BaseDorisSQLListener) ExitGrantOnFunc(ctx *GrantOnFuncContext) {} - -// EnterGrantOnSystem is called when production grantOnSystem is entered. -func (s *BaseDorisSQLListener) EnterGrantOnSystem(ctx *GrantOnSystemContext) {} - -// ExitGrantOnSystem is called when production grantOnSystem is exited. -func (s *BaseDorisSQLListener) ExitGrantOnSystem(ctx *GrantOnSystemContext) {} - -// EnterGrantOnPrimaryObj is called when production grantOnPrimaryObj is entered. -func (s *BaseDorisSQLListener) EnterGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) {} - -// ExitGrantOnPrimaryObj is called when production grantOnPrimaryObj is exited. -func (s *BaseDorisSQLListener) ExitGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) {} - -// EnterGrantOnAll is called when production grantOnAll is entered. -func (s *BaseDorisSQLListener) EnterGrantOnAll(ctx *GrantOnAllContext) {} - -// ExitGrantOnAll is called when production grantOnAll is exited. -func (s *BaseDorisSQLListener) ExitGrantOnAll(ctx *GrantOnAllContext) {} - -// EnterRevokeOnUser is called when production revokeOnUser is entered. -func (s *BaseDorisSQLListener) EnterRevokeOnUser(ctx *RevokeOnUserContext) {} - -// ExitRevokeOnUser is called when production revokeOnUser is exited. -func (s *BaseDorisSQLListener) ExitRevokeOnUser(ctx *RevokeOnUserContext) {} - -// EnterRevokeOnTableBrief is called when production revokeOnTableBrief is entered. -func (s *BaseDorisSQLListener) EnterRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) {} - -// ExitRevokeOnTableBrief is called when production revokeOnTableBrief is exited. -func (s *BaseDorisSQLListener) ExitRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) {} - -// EnterRevokeOnFunc is called when production revokeOnFunc is entered. -func (s *BaseDorisSQLListener) EnterRevokeOnFunc(ctx *RevokeOnFuncContext) {} - -// ExitRevokeOnFunc is called when production revokeOnFunc is exited. -func (s *BaseDorisSQLListener) ExitRevokeOnFunc(ctx *RevokeOnFuncContext) {} - -// EnterRevokeOnSystem is called when production revokeOnSystem is entered. -func (s *BaseDorisSQLListener) EnterRevokeOnSystem(ctx *RevokeOnSystemContext) {} - -// ExitRevokeOnSystem is called when production revokeOnSystem is exited. -func (s *BaseDorisSQLListener) ExitRevokeOnSystem(ctx *RevokeOnSystemContext) {} - -// EnterRevokeOnPrimaryObj is called when production revokeOnPrimaryObj is entered. -func (s *BaseDorisSQLListener) EnterRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) {} - -// ExitRevokeOnPrimaryObj is called when production revokeOnPrimaryObj is exited. -func (s *BaseDorisSQLListener) ExitRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) {} - -// EnterRevokeOnAll is called when production revokeOnAll is entered. -func (s *BaseDorisSQLListener) EnterRevokeOnAll(ctx *RevokeOnAllContext) {} - -// ExitRevokeOnAll is called when production revokeOnAll is exited. -func (s *BaseDorisSQLListener) ExitRevokeOnAll(ctx *RevokeOnAllContext) {} - -// EnterShowGrantsStatement is called when production showGrantsStatement is entered. -func (s *BaseDorisSQLListener) EnterShowGrantsStatement(ctx *ShowGrantsStatementContext) {} - -// ExitShowGrantsStatement is called when production showGrantsStatement is exited. -func (s *BaseDorisSQLListener) ExitShowGrantsStatement(ctx *ShowGrantsStatementContext) {} - -// EnterAuthWithoutPlugin is called when production authWithoutPlugin is entered. -func (s *BaseDorisSQLListener) EnterAuthWithoutPlugin(ctx *AuthWithoutPluginContext) {} - -// ExitAuthWithoutPlugin is called when production authWithoutPlugin is exited. -func (s *BaseDorisSQLListener) ExitAuthWithoutPlugin(ctx *AuthWithoutPluginContext) {} - -// EnterAuthWithPlugin is called when production authWithPlugin is entered. -func (s *BaseDorisSQLListener) EnterAuthWithPlugin(ctx *AuthWithPluginContext) {} - -// ExitAuthWithPlugin is called when production authWithPlugin is exited. -func (s *BaseDorisSQLListener) ExitAuthWithPlugin(ctx *AuthWithPluginContext) {} - -// EnterPrivObjectName is called when production privObjectName is entered. -func (s *BaseDorisSQLListener) EnterPrivObjectName(ctx *PrivObjectNameContext) {} - -// ExitPrivObjectName is called when production privObjectName is exited. -func (s *BaseDorisSQLListener) ExitPrivObjectName(ctx *PrivObjectNameContext) {} - -// EnterPrivObjectNameList is called when production privObjectNameList is entered. -func (s *BaseDorisSQLListener) EnterPrivObjectNameList(ctx *PrivObjectNameListContext) {} - -// ExitPrivObjectNameList is called when production privObjectNameList is exited. -func (s *BaseDorisSQLListener) ExitPrivObjectNameList(ctx *PrivObjectNameListContext) {} - -// EnterPrivFunctionObjectNameList is called when production privFunctionObjectNameList is entered. -func (s *BaseDorisSQLListener) EnterPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) { -} - -// ExitPrivFunctionObjectNameList is called when production privFunctionObjectNameList is exited. -func (s *BaseDorisSQLListener) ExitPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) { -} - -// EnterPrivilegeTypeList is called when production privilegeTypeList is entered. -func (s *BaseDorisSQLListener) EnterPrivilegeTypeList(ctx *PrivilegeTypeListContext) {} - -// ExitPrivilegeTypeList is called when production privilegeTypeList is exited. -func (s *BaseDorisSQLListener) ExitPrivilegeTypeList(ctx *PrivilegeTypeListContext) {} - -// EnterPrivilegeType is called when production privilegeType is entered. -func (s *BaseDorisSQLListener) EnterPrivilegeType(ctx *PrivilegeTypeContext) {} - -// ExitPrivilegeType is called when production privilegeType is exited. -func (s *BaseDorisSQLListener) ExitPrivilegeType(ctx *PrivilegeTypeContext) {} - -// EnterPrivObjectType is called when production privObjectType is entered. -func (s *BaseDorisSQLListener) EnterPrivObjectType(ctx *PrivObjectTypeContext) {} - -// ExitPrivObjectType is called when production privObjectType is exited. -func (s *BaseDorisSQLListener) ExitPrivObjectType(ctx *PrivObjectTypeContext) {} - -// EnterPrivObjectTypePlural is called when production privObjectTypePlural is entered. -func (s *BaseDorisSQLListener) EnterPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) {} - -// ExitPrivObjectTypePlural is called when production privObjectTypePlural is exited. -func (s *BaseDorisSQLListener) ExitPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) {} - -// EnterCreateSecurityIntegrationStatement is called when production createSecurityIntegrationStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) { -} - -// ExitCreateSecurityIntegrationStatement is called when production createSecurityIntegrationStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) { -} - -// EnterAlterSecurityIntegrationStatement is called when production alterSecurityIntegrationStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) { -} - -// ExitAlterSecurityIntegrationStatement is called when production alterSecurityIntegrationStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) { -} - -// EnterDropSecurityIntegrationStatement is called when production dropSecurityIntegrationStatement is entered. -func (s *BaseDorisSQLListener) EnterDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) { -} - -// ExitDropSecurityIntegrationStatement is called when production dropSecurityIntegrationStatement is exited. -func (s *BaseDorisSQLListener) ExitDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) { -} - -// EnterShowSecurityIntegrationStatement is called when production showSecurityIntegrationStatement is entered. -func (s *BaseDorisSQLListener) EnterShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) { -} - -// ExitShowSecurityIntegrationStatement is called when production showSecurityIntegrationStatement is exited. -func (s *BaseDorisSQLListener) ExitShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) { -} - -// EnterShowCreateSecurityIntegrationStatement is called when production showCreateSecurityIntegrationStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) { -} - -// ExitShowCreateSecurityIntegrationStatement is called when production showCreateSecurityIntegrationStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) { -} - -// EnterCreateGroupProviderStatement is called when production createGroupProviderStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) { -} - -// ExitCreateGroupProviderStatement is called when production createGroupProviderStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) { -} - -// EnterDropGroupProviderStatement is called when production dropGroupProviderStatement is entered. -func (s *BaseDorisSQLListener) EnterDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) { -} - -// ExitDropGroupProviderStatement is called when production dropGroupProviderStatement is exited. -func (s *BaseDorisSQLListener) ExitDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) { -} - -// EnterShowGroupProvidersStatement is called when production showGroupProvidersStatement is entered. -func (s *BaseDorisSQLListener) EnterShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) { -} - -// ExitShowGroupProvidersStatement is called when production showGroupProvidersStatement is exited. -func (s *BaseDorisSQLListener) ExitShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) { -} - -// EnterShowCreateGroupProviderStatement is called when production showCreateGroupProviderStatement is entered. -func (s *BaseDorisSQLListener) EnterShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) { -} - -// ExitShowCreateGroupProviderStatement is called when production showCreateGroupProviderStatement is exited. -func (s *BaseDorisSQLListener) ExitShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) { -} - -// EnterBackupStatement is called when production backupStatement is entered. -func (s *BaseDorisSQLListener) EnterBackupStatement(ctx *BackupStatementContext) {} - -// ExitBackupStatement is called when production backupStatement is exited. -func (s *BaseDorisSQLListener) ExitBackupStatement(ctx *BackupStatementContext) {} - -// EnterCancelBackupStatement is called when production cancelBackupStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelBackupStatement(ctx *CancelBackupStatementContext) {} - -// ExitCancelBackupStatement is called when production cancelBackupStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelBackupStatement(ctx *CancelBackupStatementContext) {} - -// EnterShowBackupStatement is called when production showBackupStatement is entered. -func (s *BaseDorisSQLListener) EnterShowBackupStatement(ctx *ShowBackupStatementContext) {} - -// ExitShowBackupStatement is called when production showBackupStatement is exited. -func (s *BaseDorisSQLListener) ExitShowBackupStatement(ctx *ShowBackupStatementContext) {} - -// EnterRestoreStatement is called when production restoreStatement is entered. -func (s *BaseDorisSQLListener) EnterRestoreStatement(ctx *RestoreStatementContext) {} - -// ExitRestoreStatement is called when production restoreStatement is exited. -func (s *BaseDorisSQLListener) ExitRestoreStatement(ctx *RestoreStatementContext) {} - -// EnterCancelRestoreStatement is called when production cancelRestoreStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelRestoreStatement(ctx *CancelRestoreStatementContext) {} - -// ExitCancelRestoreStatement is called when production cancelRestoreStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelRestoreStatement(ctx *CancelRestoreStatementContext) {} - -// EnterShowRestoreStatement is called when production showRestoreStatement is entered. -func (s *BaseDorisSQLListener) EnterShowRestoreStatement(ctx *ShowRestoreStatementContext) {} - -// ExitShowRestoreStatement is called when production showRestoreStatement is exited. -func (s *BaseDorisSQLListener) ExitShowRestoreStatement(ctx *ShowRestoreStatementContext) {} - -// EnterShowSnapshotStatement is called when production showSnapshotStatement is entered. -func (s *BaseDorisSQLListener) EnterShowSnapshotStatement(ctx *ShowSnapshotStatementContext) {} - -// ExitShowSnapshotStatement is called when production showSnapshotStatement is exited. -func (s *BaseDorisSQLListener) ExitShowSnapshotStatement(ctx *ShowSnapshotStatementContext) {} - -// EnterCreateRepositoryStatement is called when production createRepositoryStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) { -} - -// ExitCreateRepositoryStatement is called when production createRepositoryStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) {} - -// EnterDropRepositoryStatement is called when production dropRepositoryStatement is entered. -func (s *BaseDorisSQLListener) EnterDropRepositoryStatement(ctx *DropRepositoryStatementContext) {} - -// ExitDropRepositoryStatement is called when production dropRepositoryStatement is exited. -func (s *BaseDorisSQLListener) ExitDropRepositoryStatement(ctx *DropRepositoryStatementContext) {} - -// EnterAddSqlBlackListStatement is called when production addSqlBlackListStatement is entered. -func (s *BaseDorisSQLListener) EnterAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) {} - -// ExitAddSqlBlackListStatement is called when production addSqlBlackListStatement is exited. -func (s *BaseDorisSQLListener) ExitAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) {} - -// EnterDelSqlBlackListStatement is called when production delSqlBlackListStatement is entered. -func (s *BaseDorisSQLListener) EnterDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) {} - -// ExitDelSqlBlackListStatement is called when production delSqlBlackListStatement is exited. -func (s *BaseDorisSQLListener) ExitDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) {} - -// EnterShowSqlBlackListStatement is called when production showSqlBlackListStatement is entered. -func (s *BaseDorisSQLListener) EnterShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) { -} - -// ExitShowSqlBlackListStatement is called when production showSqlBlackListStatement is exited. -func (s *BaseDorisSQLListener) ExitShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) {} - -// EnterShowWhiteListStatement is called when production showWhiteListStatement is entered. -func (s *BaseDorisSQLListener) EnterShowWhiteListStatement(ctx *ShowWhiteListStatementContext) {} - -// ExitShowWhiteListStatement is called when production showWhiteListStatement is exited. -func (s *BaseDorisSQLListener) ExitShowWhiteListStatement(ctx *ShowWhiteListStatementContext) {} - -// EnterAddBackendBlackListStatement is called when production addBackendBlackListStatement is entered. -func (s *BaseDorisSQLListener) EnterAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) { -} - -// ExitAddBackendBlackListStatement is called when production addBackendBlackListStatement is exited. -func (s *BaseDorisSQLListener) ExitAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) { -} - -// EnterDelBackendBlackListStatement is called when production delBackendBlackListStatement is entered. -func (s *BaseDorisSQLListener) EnterDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) { -} - -// ExitDelBackendBlackListStatement is called when production delBackendBlackListStatement is exited. -func (s *BaseDorisSQLListener) ExitDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) { -} - -// EnterShowBackendBlackListStatement is called when production showBackendBlackListStatement is entered. -func (s *BaseDorisSQLListener) EnterShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) { -} - -// ExitShowBackendBlackListStatement is called when production showBackendBlackListStatement is exited. -func (s *BaseDorisSQLListener) ExitShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) { -} - -// EnterDataCacheTarget is called when production dataCacheTarget is entered. -func (s *BaseDorisSQLListener) EnterDataCacheTarget(ctx *DataCacheTargetContext) {} - -// ExitDataCacheTarget is called when production dataCacheTarget is exited. -func (s *BaseDorisSQLListener) ExitDataCacheTarget(ctx *DataCacheTargetContext) {} - -// EnterCreateDataCacheRuleStatement is called when production createDataCacheRuleStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) { -} - -// ExitCreateDataCacheRuleStatement is called when production createDataCacheRuleStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) { -} - -// EnterShowDataCacheRulesStatement is called when production showDataCacheRulesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) { -} - -// ExitShowDataCacheRulesStatement is called when production showDataCacheRulesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) { -} - -// EnterDropDataCacheRuleStatement is called when production dropDataCacheRuleStatement is entered. -func (s *BaseDorisSQLListener) EnterDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) { -} - -// ExitDropDataCacheRuleStatement is called when production dropDataCacheRuleStatement is exited. -func (s *BaseDorisSQLListener) ExitDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) { -} - -// EnterClearDataCacheRulesStatement is called when production clearDataCacheRulesStatement is entered. -func (s *BaseDorisSQLListener) EnterClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) { -} - -// ExitClearDataCacheRulesStatement is called when production clearDataCacheRulesStatement is exited. -func (s *BaseDorisSQLListener) ExitClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) { -} - -// EnterDataCacheSelectStatement is called when production dataCacheSelectStatement is entered. -func (s *BaseDorisSQLListener) EnterDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) {} - -// ExitDataCacheSelectStatement is called when production dataCacheSelectStatement is exited. -func (s *BaseDorisSQLListener) ExitDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) {} - -// EnterExportStatement is called when production exportStatement is entered. -func (s *BaseDorisSQLListener) EnterExportStatement(ctx *ExportStatementContext) {} - -// ExitExportStatement is called when production exportStatement is exited. -func (s *BaseDorisSQLListener) ExitExportStatement(ctx *ExportStatementContext) {} - -// EnterCancelExportStatement is called when production cancelExportStatement is entered. -func (s *BaseDorisSQLListener) EnterCancelExportStatement(ctx *CancelExportStatementContext) {} - -// ExitCancelExportStatement is called when production cancelExportStatement is exited. -func (s *BaseDorisSQLListener) ExitCancelExportStatement(ctx *CancelExportStatementContext) {} - -// EnterShowExportStatement is called when production showExportStatement is entered. -func (s *BaseDorisSQLListener) EnterShowExportStatement(ctx *ShowExportStatementContext) {} - -// ExitShowExportStatement is called when production showExportStatement is exited. -func (s *BaseDorisSQLListener) ExitShowExportStatement(ctx *ShowExportStatementContext) {} - -// EnterInstallPluginStatement is called when production installPluginStatement is entered. -func (s *BaseDorisSQLListener) EnterInstallPluginStatement(ctx *InstallPluginStatementContext) {} - -// ExitInstallPluginStatement is called when production installPluginStatement is exited. -func (s *BaseDorisSQLListener) ExitInstallPluginStatement(ctx *InstallPluginStatementContext) {} - -// EnterUninstallPluginStatement is called when production uninstallPluginStatement is entered. -func (s *BaseDorisSQLListener) EnterUninstallPluginStatement(ctx *UninstallPluginStatementContext) {} - -// ExitUninstallPluginStatement is called when production uninstallPluginStatement is exited. -func (s *BaseDorisSQLListener) ExitUninstallPluginStatement(ctx *UninstallPluginStatementContext) {} - -// EnterCreateFileStatement is called when production createFileStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateFileStatement(ctx *CreateFileStatementContext) {} - -// ExitCreateFileStatement is called when production createFileStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateFileStatement(ctx *CreateFileStatementContext) {} - -// EnterDropFileStatement is called when production dropFileStatement is entered. -func (s *BaseDorisSQLListener) EnterDropFileStatement(ctx *DropFileStatementContext) {} - -// ExitDropFileStatement is called when production dropFileStatement is exited. -func (s *BaseDorisSQLListener) ExitDropFileStatement(ctx *DropFileStatementContext) {} - -// EnterShowSmallFilesStatement is called when production showSmallFilesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) {} - -// ExitShowSmallFilesStatement is called when production showSmallFilesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) {} - -// EnterCreatePipeStatement is called when production createPipeStatement is entered. -func (s *BaseDorisSQLListener) EnterCreatePipeStatement(ctx *CreatePipeStatementContext) {} - -// ExitCreatePipeStatement is called when production createPipeStatement is exited. -func (s *BaseDorisSQLListener) ExitCreatePipeStatement(ctx *CreatePipeStatementContext) {} - -// EnterDropPipeStatement is called when production dropPipeStatement is entered. -func (s *BaseDorisSQLListener) EnterDropPipeStatement(ctx *DropPipeStatementContext) {} - -// ExitDropPipeStatement is called when production dropPipeStatement is exited. -func (s *BaseDorisSQLListener) ExitDropPipeStatement(ctx *DropPipeStatementContext) {} - -// EnterAlterPipeClause is called when production alterPipeClause is entered. -func (s *BaseDorisSQLListener) EnterAlterPipeClause(ctx *AlterPipeClauseContext) {} - -// ExitAlterPipeClause is called when production alterPipeClause is exited. -func (s *BaseDorisSQLListener) ExitAlterPipeClause(ctx *AlterPipeClauseContext) {} - -// EnterAlterPipeStatement is called when production alterPipeStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterPipeStatement(ctx *AlterPipeStatementContext) {} - -// ExitAlterPipeStatement is called when production alterPipeStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterPipeStatement(ctx *AlterPipeStatementContext) {} - -// EnterDescPipeStatement is called when production descPipeStatement is entered. -func (s *BaseDorisSQLListener) EnterDescPipeStatement(ctx *DescPipeStatementContext) {} - -// ExitDescPipeStatement is called when production descPipeStatement is exited. -func (s *BaseDorisSQLListener) ExitDescPipeStatement(ctx *DescPipeStatementContext) {} - -// EnterShowPipeStatement is called when production showPipeStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPipeStatement(ctx *ShowPipeStatementContext) {} - -// ExitShowPipeStatement is called when production showPipeStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPipeStatement(ctx *ShowPipeStatementContext) {} - -// EnterSetStatement is called when production setStatement is entered. -func (s *BaseDorisSQLListener) EnterSetStatement(ctx *SetStatementContext) {} - -// ExitSetStatement is called when production setStatement is exited. -func (s *BaseDorisSQLListener) ExitSetStatement(ctx *SetStatementContext) {} - -// EnterSetNames is called when production setNames is entered. -func (s *BaseDorisSQLListener) EnterSetNames(ctx *SetNamesContext) {} - -// ExitSetNames is called when production setNames is exited. -func (s *BaseDorisSQLListener) ExitSetNames(ctx *SetNamesContext) {} - -// EnterSetPassword is called when production setPassword is entered. -func (s *BaseDorisSQLListener) EnterSetPassword(ctx *SetPasswordContext) {} - -// ExitSetPassword is called when production setPassword is exited. -func (s *BaseDorisSQLListener) ExitSetPassword(ctx *SetPasswordContext) {} - -// EnterSetUserVar is called when production setUserVar is entered. -func (s *BaseDorisSQLListener) EnterSetUserVar(ctx *SetUserVarContext) {} - -// ExitSetUserVar is called when production setUserVar is exited. -func (s *BaseDorisSQLListener) ExitSetUserVar(ctx *SetUserVarContext) {} - -// EnterSetSystemVar is called when production setSystemVar is entered. -func (s *BaseDorisSQLListener) EnterSetSystemVar(ctx *SetSystemVarContext) {} - -// ExitSetSystemVar is called when production setSystemVar is exited. -func (s *BaseDorisSQLListener) ExitSetSystemVar(ctx *SetSystemVarContext) {} - -// EnterSetTransaction is called when production setTransaction is entered. -func (s *BaseDorisSQLListener) EnterSetTransaction(ctx *SetTransactionContext) {} - -// ExitSetTransaction is called when production setTransaction is exited. -func (s *BaseDorisSQLListener) ExitSetTransaction(ctx *SetTransactionContext) {} - -// EnterTransaction_characteristics is called when production transaction_characteristics is entered. -func (s *BaseDorisSQLListener) EnterTransaction_characteristics(ctx *Transaction_characteristicsContext) { -} - -// ExitTransaction_characteristics is called when production transaction_characteristics is exited. -func (s *BaseDorisSQLListener) ExitTransaction_characteristics(ctx *Transaction_characteristicsContext) { -} - -// EnterTransaction_access_mode is called when production transaction_access_mode is entered. -func (s *BaseDorisSQLListener) EnterTransaction_access_mode(ctx *Transaction_access_modeContext) {} - -// ExitTransaction_access_mode is called when production transaction_access_mode is exited. -func (s *BaseDorisSQLListener) ExitTransaction_access_mode(ctx *Transaction_access_modeContext) {} - -// EnterIsolation_level is called when production isolation_level is entered. -func (s *BaseDorisSQLListener) EnterIsolation_level(ctx *Isolation_levelContext) {} - -// ExitIsolation_level is called when production isolation_level is exited. -func (s *BaseDorisSQLListener) ExitIsolation_level(ctx *Isolation_levelContext) {} - -// EnterIsolation_types is called when production isolation_types is entered. -func (s *BaseDorisSQLListener) EnterIsolation_types(ctx *Isolation_typesContext) {} - -// ExitIsolation_types is called when production isolation_types is exited. -func (s *BaseDorisSQLListener) ExitIsolation_types(ctx *Isolation_typesContext) {} - -// EnterSetExprOrDefault is called when production setExprOrDefault is entered. -func (s *BaseDorisSQLListener) EnterSetExprOrDefault(ctx *SetExprOrDefaultContext) {} - -// ExitSetExprOrDefault is called when production setExprOrDefault is exited. -func (s *BaseDorisSQLListener) ExitSetExprOrDefault(ctx *SetExprOrDefaultContext) {} - -// EnterSetUserPropertyStatement is called when production setUserPropertyStatement is entered. -func (s *BaseDorisSQLListener) EnterSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) {} - -// ExitSetUserPropertyStatement is called when production setUserPropertyStatement is exited. -func (s *BaseDorisSQLListener) ExitSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) {} - -// EnterRoleList is called when production roleList is entered. -func (s *BaseDorisSQLListener) EnterRoleList(ctx *RoleListContext) {} - -// ExitRoleList is called when production roleList is exited. -func (s *BaseDorisSQLListener) ExitRoleList(ctx *RoleListContext) {} - -// EnterExecuteScriptStatement is called when production executeScriptStatement is entered. -func (s *BaseDorisSQLListener) EnterExecuteScriptStatement(ctx *ExecuteScriptStatementContext) {} - -// ExitExecuteScriptStatement is called when production executeScriptStatement is exited. -func (s *BaseDorisSQLListener) ExitExecuteScriptStatement(ctx *ExecuteScriptStatementContext) {} - -// EnterUnsupportedStatement is called when production unsupportedStatement is entered. -func (s *BaseDorisSQLListener) EnterUnsupportedStatement(ctx *UnsupportedStatementContext) {} - -// ExitUnsupportedStatement is called when production unsupportedStatement is exited. -func (s *BaseDorisSQLListener) ExitUnsupportedStatement(ctx *UnsupportedStatementContext) {} - -// EnterLock_item is called when production lock_item is entered. -func (s *BaseDorisSQLListener) EnterLock_item(ctx *Lock_itemContext) {} - -// ExitLock_item is called when production lock_item is exited. -func (s *BaseDorisSQLListener) ExitLock_item(ctx *Lock_itemContext) {} - -// EnterLock_type is called when production lock_type is entered. -func (s *BaseDorisSQLListener) EnterLock_type(ctx *Lock_typeContext) {} - -// ExitLock_type is called when production lock_type is exited. -func (s *BaseDorisSQLListener) ExitLock_type(ctx *Lock_typeContext) {} - -// EnterAlterPlanAdvisorAddStatement is called when production alterPlanAdvisorAddStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) { -} - -// ExitAlterPlanAdvisorAddStatement is called when production alterPlanAdvisorAddStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) { -} - -// EnterTruncatePlanAdvisorStatement is called when production truncatePlanAdvisorStatement is entered. -func (s *BaseDorisSQLListener) EnterTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) { -} - -// ExitTruncatePlanAdvisorStatement is called when production truncatePlanAdvisorStatement is exited. -func (s *BaseDorisSQLListener) ExitTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) { -} - -// EnterAlterPlanAdvisorDropStatement is called when production alterPlanAdvisorDropStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) { -} - -// ExitAlterPlanAdvisorDropStatement is called when production alterPlanAdvisorDropStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) { -} - -// EnterShowPlanAdvisorStatement is called when production showPlanAdvisorStatement is entered. -func (s *BaseDorisSQLListener) EnterShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) {} - -// ExitShowPlanAdvisorStatement is called when production showPlanAdvisorStatement is exited. -func (s *BaseDorisSQLListener) ExitShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) {} - -// EnterCreateWarehouseStatement is called when production createWarehouseStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) {} - -// ExitCreateWarehouseStatement is called when production createWarehouseStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) {} - -// EnterDropWarehouseStatement is called when production dropWarehouseStatement is entered. -func (s *BaseDorisSQLListener) EnterDropWarehouseStatement(ctx *DropWarehouseStatementContext) {} - -// ExitDropWarehouseStatement is called when production dropWarehouseStatement is exited. -func (s *BaseDorisSQLListener) ExitDropWarehouseStatement(ctx *DropWarehouseStatementContext) {} - -// EnterSuspendWarehouseStatement is called when production suspendWarehouseStatement is entered. -func (s *BaseDorisSQLListener) EnterSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) { -} - -// ExitSuspendWarehouseStatement is called when production suspendWarehouseStatement is exited. -func (s *BaseDorisSQLListener) ExitSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) {} - -// EnterResumeWarehouseStatement is called when production resumeWarehouseStatement is entered. -func (s *BaseDorisSQLListener) EnterResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) {} - -// ExitResumeWarehouseStatement is called when production resumeWarehouseStatement is exited. -func (s *BaseDorisSQLListener) ExitResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) {} - -// EnterSetWarehouseStatement is called when production setWarehouseStatement is entered. -func (s *BaseDorisSQLListener) EnterSetWarehouseStatement(ctx *SetWarehouseStatementContext) {} - -// ExitSetWarehouseStatement is called when production setWarehouseStatement is exited. -func (s *BaseDorisSQLListener) ExitSetWarehouseStatement(ctx *SetWarehouseStatementContext) {} - -// EnterShowWarehousesStatement is called when production showWarehousesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowWarehousesStatement(ctx *ShowWarehousesStatementContext) {} - -// ExitShowWarehousesStatement is called when production showWarehousesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowWarehousesStatement(ctx *ShowWarehousesStatementContext) {} - -// EnterShowClustersStatement is called when production showClustersStatement is entered. -func (s *BaseDorisSQLListener) EnterShowClustersStatement(ctx *ShowClustersStatementContext) {} - -// ExitShowClustersStatement is called when production showClustersStatement is exited. -func (s *BaseDorisSQLListener) ExitShowClustersStatement(ctx *ShowClustersStatementContext) {} - -// EnterShowNodesStatement is called when production showNodesStatement is entered. -func (s *BaseDorisSQLListener) EnterShowNodesStatement(ctx *ShowNodesStatementContext) {} - -// ExitShowNodesStatement is called when production showNodesStatement is exited. -func (s *BaseDorisSQLListener) ExitShowNodesStatement(ctx *ShowNodesStatementContext) {} - -// EnterAlterWarehouseStatement is called when production alterWarehouseStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) {} - -// ExitAlterWarehouseStatement is called when production alterWarehouseStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) {} - -// EnterCreateCNGroupStatement is called when production createCNGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) {} - -// ExitCreateCNGroupStatement is called when production createCNGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) {} - -// EnterDropCNGroupStatement is called when production dropCNGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterDropCNGroupStatement(ctx *DropCNGroupStatementContext) {} - -// ExitDropCNGroupStatement is called when production dropCNGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitDropCNGroupStatement(ctx *DropCNGroupStatementContext) {} - -// EnterEnableCNGroupStatement is called when production enableCNGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) {} - -// ExitEnableCNGroupStatement is called when production enableCNGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) {} - -// EnterDisableCNGroupStatement is called when production disableCNGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) {} - -// ExitDisableCNGroupStatement is called when production disableCNGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) {} - -// EnterAlterCNGroupStatement is called when production alterCNGroupStatement is entered. -func (s *BaseDorisSQLListener) EnterAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) {} - -// ExitAlterCNGroupStatement is called when production alterCNGroupStatement is exited. -func (s *BaseDorisSQLListener) ExitAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) {} - -// EnterBeginStatement is called when production beginStatement is entered. -func (s *BaseDorisSQLListener) EnterBeginStatement(ctx *BeginStatementContext) {} - -// ExitBeginStatement is called when production beginStatement is exited. -func (s *BaseDorisSQLListener) ExitBeginStatement(ctx *BeginStatementContext) {} - -// EnterCommitStatement is called when production commitStatement is entered. -func (s *BaseDorisSQLListener) EnterCommitStatement(ctx *CommitStatementContext) {} - -// ExitCommitStatement is called when production commitStatement is exited. -func (s *BaseDorisSQLListener) ExitCommitStatement(ctx *CommitStatementContext) {} - -// EnterRollbackStatement is called when production rollbackStatement is entered. -func (s *BaseDorisSQLListener) EnterRollbackStatement(ctx *RollbackStatementContext) {} - -// ExitRollbackStatement is called when production rollbackStatement is exited. -func (s *BaseDorisSQLListener) ExitRollbackStatement(ctx *RollbackStatementContext) {} - -// EnterTranslateStatement is called when production translateStatement is entered. -func (s *BaseDorisSQLListener) EnterTranslateStatement(ctx *TranslateStatementContext) {} - -// ExitTranslateStatement is called when production translateStatement is exited. -func (s *BaseDorisSQLListener) ExitTranslateStatement(ctx *TranslateStatementContext) {} - -// EnterDialect is called when production dialect is entered. -func (s *BaseDorisSQLListener) EnterDialect(ctx *DialectContext) {} - -// ExitDialect is called when production dialect is exited. -func (s *BaseDorisSQLListener) ExitDialect(ctx *DialectContext) {} - -// EnterTranslateSQL is called when production translateSQL is entered. -func (s *BaseDorisSQLListener) EnterTranslateSQL(ctx *TranslateSQLContext) {} - -// ExitTranslateSQL is called when production translateSQL is exited. -func (s *BaseDorisSQLListener) ExitTranslateSQL(ctx *TranslateSQLContext) {} - -// EnterQueryStatement is called when production queryStatement is entered. -func (s *BaseDorisSQLListener) EnterQueryStatement(ctx *QueryStatementContext) {} - -// ExitQueryStatement is called when production queryStatement is exited. -func (s *BaseDorisSQLListener) ExitQueryStatement(ctx *QueryStatementContext) {} - -// EnterQueryRelation is called when production queryRelation is entered. -func (s *BaseDorisSQLListener) EnterQueryRelation(ctx *QueryRelationContext) {} - -// ExitQueryRelation is called when production queryRelation is exited. -func (s *BaseDorisSQLListener) ExitQueryRelation(ctx *QueryRelationContext) {} - -// EnterWithClause is called when production withClause is entered. -func (s *BaseDorisSQLListener) EnterWithClause(ctx *WithClauseContext) {} - -// ExitWithClause is called when production withClause is exited. -func (s *BaseDorisSQLListener) ExitWithClause(ctx *WithClauseContext) {} - -// EnterQueryNoWith is called when production queryNoWith is entered. -func (s *BaseDorisSQLListener) EnterQueryNoWith(ctx *QueryNoWithContext) {} - -// ExitQueryNoWith is called when production queryNoWith is exited. -func (s *BaseDorisSQLListener) ExitQueryNoWith(ctx *QueryNoWithContext) {} - -// EnterQueryPeriod is called when production queryPeriod is entered. -func (s *BaseDorisSQLListener) EnterQueryPeriod(ctx *QueryPeriodContext) {} - -// ExitQueryPeriod is called when production queryPeriod is exited. -func (s *BaseDorisSQLListener) ExitQueryPeriod(ctx *QueryPeriodContext) {} - -// EnterPeriodType is called when production periodType is entered. -func (s *BaseDorisSQLListener) EnterPeriodType(ctx *PeriodTypeContext) {} - -// ExitPeriodType is called when production periodType is exited. -func (s *BaseDorisSQLListener) ExitPeriodType(ctx *PeriodTypeContext) {} - -// EnterQueryWithParentheses is called when production queryWithParentheses is entered. -func (s *BaseDorisSQLListener) EnterQueryWithParentheses(ctx *QueryWithParenthesesContext) {} - -// ExitQueryWithParentheses is called when production queryWithParentheses is exited. -func (s *BaseDorisSQLListener) ExitQueryWithParentheses(ctx *QueryWithParenthesesContext) {} - -// EnterSetOperation is called when production setOperation is entered. -func (s *BaseDorisSQLListener) EnterSetOperation(ctx *SetOperationContext) {} - -// ExitSetOperation is called when production setOperation is exited. -func (s *BaseDorisSQLListener) ExitSetOperation(ctx *SetOperationContext) {} - -// EnterQueryPrimaryDefault is called when production queryPrimaryDefault is entered. -func (s *BaseDorisSQLListener) EnterQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) {} - -// ExitQueryPrimaryDefault is called when production queryPrimaryDefault is exited. -func (s *BaseDorisSQLListener) ExitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) {} - -// EnterSubquery is called when production subquery is entered. -func (s *BaseDorisSQLListener) EnterSubquery(ctx *SubqueryContext) {} - -// ExitSubquery is called when production subquery is exited. -func (s *BaseDorisSQLListener) ExitSubquery(ctx *SubqueryContext) {} - -// EnterRowConstructor is called when production rowConstructor is entered. -func (s *BaseDorisSQLListener) EnterRowConstructor(ctx *RowConstructorContext) {} - -// ExitRowConstructor is called when production rowConstructor is exited. -func (s *BaseDorisSQLListener) ExitRowConstructor(ctx *RowConstructorContext) {} - -// EnterSortItem is called when production sortItem is entered. -func (s *BaseDorisSQLListener) EnterSortItem(ctx *SortItemContext) {} - -// ExitSortItem is called when production sortItem is exited. -func (s *BaseDorisSQLListener) ExitSortItem(ctx *SortItemContext) {} - -// EnterLimitConstExpr is called when production limitConstExpr is entered. -func (s *BaseDorisSQLListener) EnterLimitConstExpr(ctx *LimitConstExprContext) {} - -// ExitLimitConstExpr is called when production limitConstExpr is exited. -func (s *BaseDorisSQLListener) ExitLimitConstExpr(ctx *LimitConstExprContext) {} - -// EnterLimitElement is called when production limitElement is entered. -func (s *BaseDorisSQLListener) EnterLimitElement(ctx *LimitElementContext) {} - -// ExitLimitElement is called when production limitElement is exited. -func (s *BaseDorisSQLListener) ExitLimitElement(ctx *LimitElementContext) {} - -// EnterQuerySpecification is called when production querySpecification is entered. -func (s *BaseDorisSQLListener) EnterQuerySpecification(ctx *QuerySpecificationContext) {} - -// ExitQuerySpecification is called when production querySpecification is exited. -func (s *BaseDorisSQLListener) ExitQuerySpecification(ctx *QuerySpecificationContext) {} - -// EnterFrom is called when production from is entered. -func (s *BaseDorisSQLListener) EnterFrom(ctx *FromContext) {} - -// ExitFrom is called when production from is exited. -func (s *BaseDorisSQLListener) ExitFrom(ctx *FromContext) {} - -// EnterDual is called when production dual is entered. -func (s *BaseDorisSQLListener) EnterDual(ctx *DualContext) {} - -// ExitDual is called when production dual is exited. -func (s *BaseDorisSQLListener) ExitDual(ctx *DualContext) {} - -// EnterRollup is called when production rollup is entered. -func (s *BaseDorisSQLListener) EnterRollup(ctx *RollupContext) {} - -// ExitRollup is called when production rollup is exited. -func (s *BaseDorisSQLListener) ExitRollup(ctx *RollupContext) {} - -// EnterCube is called when production cube is entered. -func (s *BaseDorisSQLListener) EnterCube(ctx *CubeContext) {} - -// ExitCube is called when production cube is exited. -func (s *BaseDorisSQLListener) ExitCube(ctx *CubeContext) {} - -// EnterMultipleGroupingSets is called when production multipleGroupingSets is entered. -func (s *BaseDorisSQLListener) EnterMultipleGroupingSets(ctx *MultipleGroupingSetsContext) {} - -// ExitMultipleGroupingSets is called when production multipleGroupingSets is exited. -func (s *BaseDorisSQLListener) ExitMultipleGroupingSets(ctx *MultipleGroupingSetsContext) {} - -// EnterSingleGroupingSet is called when production singleGroupingSet is entered. -func (s *BaseDorisSQLListener) EnterSingleGroupingSet(ctx *SingleGroupingSetContext) {} - -// ExitSingleGroupingSet is called when production singleGroupingSet is exited. -func (s *BaseDorisSQLListener) ExitSingleGroupingSet(ctx *SingleGroupingSetContext) {} - -// EnterGroupingSet is called when production groupingSet is entered. -func (s *BaseDorisSQLListener) EnterGroupingSet(ctx *GroupingSetContext) {} - -// ExitGroupingSet is called when production groupingSet is exited. -func (s *BaseDorisSQLListener) ExitGroupingSet(ctx *GroupingSetContext) {} - -// EnterCommonTableExpression is called when production commonTableExpression is entered. -func (s *BaseDorisSQLListener) EnterCommonTableExpression(ctx *CommonTableExpressionContext) {} - -// ExitCommonTableExpression is called when production commonTableExpression is exited. -func (s *BaseDorisSQLListener) ExitCommonTableExpression(ctx *CommonTableExpressionContext) {} - -// EnterSetQuantifier is called when production setQuantifier is entered. -func (s *BaseDorisSQLListener) EnterSetQuantifier(ctx *SetQuantifierContext) {} - -// ExitSetQuantifier is called when production setQuantifier is exited. -func (s *BaseDorisSQLListener) ExitSetQuantifier(ctx *SetQuantifierContext) {} - -// EnterSelectSingle is called when production selectSingle is entered. -func (s *BaseDorisSQLListener) EnterSelectSingle(ctx *SelectSingleContext) {} - -// ExitSelectSingle is called when production selectSingle is exited. -func (s *BaseDorisSQLListener) ExitSelectSingle(ctx *SelectSingleContext) {} - -// EnterSelectAll is called when production selectAll is entered. -func (s *BaseDorisSQLListener) EnterSelectAll(ctx *SelectAllContext) {} - -// ExitSelectAll is called when production selectAll is exited. -func (s *BaseDorisSQLListener) ExitSelectAll(ctx *SelectAllContext) {} - -// EnterExcludeClause is called when production excludeClause is entered. -func (s *BaseDorisSQLListener) EnterExcludeClause(ctx *ExcludeClauseContext) {} - -// ExitExcludeClause is called when production excludeClause is exited. -func (s *BaseDorisSQLListener) ExitExcludeClause(ctx *ExcludeClauseContext) {} - -// EnterRelations is called when production relations is entered. -func (s *BaseDorisSQLListener) EnterRelations(ctx *RelationsContext) {} - -// ExitRelations is called when production relations is exited. -func (s *BaseDorisSQLListener) ExitRelations(ctx *RelationsContext) {} - -// EnterRelationLateralView is called when production relationLateralView is entered. -func (s *BaseDorisSQLListener) EnterRelationLateralView(ctx *RelationLateralViewContext) {} - -// ExitRelationLateralView is called when production relationLateralView is exited. -func (s *BaseDorisSQLListener) ExitRelationLateralView(ctx *RelationLateralViewContext) {} - -// EnterLateralView is called when production lateralView is entered. -func (s *BaseDorisSQLListener) EnterLateralView(ctx *LateralViewContext) {} - -// ExitLateralView is called when production lateralView is exited. -func (s *BaseDorisSQLListener) ExitLateralView(ctx *LateralViewContext) {} - -// EnterGeneratorFunction is called when production generatorFunction is entered. -func (s *BaseDorisSQLListener) EnterGeneratorFunction(ctx *GeneratorFunctionContext) {} - -// ExitGeneratorFunction is called when production generatorFunction is exited. -func (s *BaseDorisSQLListener) ExitGeneratorFunction(ctx *GeneratorFunctionContext) {} - -// EnterRelation is called when production relation is entered. -func (s *BaseDorisSQLListener) EnterRelation(ctx *RelationContext) {} - -// ExitRelation is called when production relation is exited. -func (s *BaseDorisSQLListener) ExitRelation(ctx *RelationContext) {} - -// EnterTableAtom is called when production tableAtom is entered. -func (s *BaseDorisSQLListener) EnterTableAtom(ctx *TableAtomContext) {} - -// ExitTableAtom is called when production tableAtom is exited. -func (s *BaseDorisSQLListener) ExitTableAtom(ctx *TableAtomContext) {} - -// EnterInlineTable is called when production inlineTable is entered. -func (s *BaseDorisSQLListener) EnterInlineTable(ctx *InlineTableContext) {} - -// ExitInlineTable is called when production inlineTable is exited. -func (s *BaseDorisSQLListener) ExitInlineTable(ctx *InlineTableContext) {} - -// EnterSubqueryWithAlias is called when production subqueryWithAlias is entered. -func (s *BaseDorisSQLListener) EnterSubqueryWithAlias(ctx *SubqueryWithAliasContext) {} - -// ExitSubqueryWithAlias is called when production subqueryWithAlias is exited. -func (s *BaseDorisSQLListener) ExitSubqueryWithAlias(ctx *SubqueryWithAliasContext) {} - -// EnterTableFunction is called when production tableFunction is entered. -func (s *BaseDorisSQLListener) EnterTableFunction(ctx *TableFunctionContext) {} - -// ExitTableFunction is called when production tableFunction is exited. -func (s *BaseDorisSQLListener) ExitTableFunction(ctx *TableFunctionContext) {} - -// EnterNormalizedTableFunction is called when production normalizedTableFunction is entered. -func (s *BaseDorisSQLListener) EnterNormalizedTableFunction(ctx *NormalizedTableFunctionContext) {} - -// ExitNormalizedTableFunction is called when production normalizedTableFunction is exited. -func (s *BaseDorisSQLListener) ExitNormalizedTableFunction(ctx *NormalizedTableFunctionContext) {} - -// EnterFileTableFunction is called when production fileTableFunction is entered. -func (s *BaseDorisSQLListener) EnterFileTableFunction(ctx *FileTableFunctionContext) {} - -// ExitFileTableFunction is called when production fileTableFunction is exited. -func (s *BaseDorisSQLListener) ExitFileTableFunction(ctx *FileTableFunctionContext) {} - -// EnterParenthesizedRelation is called when production parenthesizedRelation is entered. -func (s *BaseDorisSQLListener) EnterParenthesizedRelation(ctx *ParenthesizedRelationContext) {} - -// ExitParenthesizedRelation is called when production parenthesizedRelation is exited. -func (s *BaseDorisSQLListener) ExitParenthesizedRelation(ctx *ParenthesizedRelationContext) {} - -// EnterPivotClause is called when production pivotClause is entered. -func (s *BaseDorisSQLListener) EnterPivotClause(ctx *PivotClauseContext) {} - -// ExitPivotClause is called when production pivotClause is exited. -func (s *BaseDorisSQLListener) ExitPivotClause(ctx *PivotClauseContext) {} - -// EnterPivotAggregationExpression is called when production pivotAggregationExpression is entered. -func (s *BaseDorisSQLListener) EnterPivotAggregationExpression(ctx *PivotAggregationExpressionContext) { -} - -// ExitPivotAggregationExpression is called when production pivotAggregationExpression is exited. -func (s *BaseDorisSQLListener) ExitPivotAggregationExpression(ctx *PivotAggregationExpressionContext) { -} - -// EnterPivotValue is called when production pivotValue is entered. -func (s *BaseDorisSQLListener) EnterPivotValue(ctx *PivotValueContext) {} - -// ExitPivotValue is called when production pivotValue is exited. -func (s *BaseDorisSQLListener) ExitPivotValue(ctx *PivotValueContext) {} - -// EnterSampleClause is called when production sampleClause is entered. -func (s *BaseDorisSQLListener) EnterSampleClause(ctx *SampleClauseContext) {} - -// ExitSampleClause is called when production sampleClause is exited. -func (s *BaseDorisSQLListener) ExitSampleClause(ctx *SampleClauseContext) {} - -// EnterArgumentList is called when production argumentList is entered. -func (s *BaseDorisSQLListener) EnterArgumentList(ctx *ArgumentListContext) {} - -// ExitArgumentList is called when production argumentList is exited. -func (s *BaseDorisSQLListener) ExitArgumentList(ctx *ArgumentListContext) {} - -// EnterNamedArgumentList is called when production namedArgumentList is entered. -func (s *BaseDorisSQLListener) EnterNamedArgumentList(ctx *NamedArgumentListContext) {} - -// ExitNamedArgumentList is called when production namedArgumentList is exited. -func (s *BaseDorisSQLListener) ExitNamedArgumentList(ctx *NamedArgumentListContext) {} - -// EnterNamedArguments is called when production namedArguments is entered. -func (s *BaseDorisSQLListener) EnterNamedArguments(ctx *NamedArgumentsContext) {} - -// ExitNamedArguments is called when production namedArguments is exited. -func (s *BaseDorisSQLListener) ExitNamedArguments(ctx *NamedArgumentsContext) {} - -// EnterJoinRelation is called when production joinRelation is entered. -func (s *BaseDorisSQLListener) EnterJoinRelation(ctx *JoinRelationContext) {} - -// ExitJoinRelation is called when production joinRelation is exited. -func (s *BaseDorisSQLListener) ExitJoinRelation(ctx *JoinRelationContext) {} - -// EnterCrossOrInnerJoinType is called when production crossOrInnerJoinType is entered. -func (s *BaseDorisSQLListener) EnterCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) {} - -// ExitCrossOrInnerJoinType is called when production crossOrInnerJoinType is exited. -func (s *BaseDorisSQLListener) ExitCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) {} - -// EnterOuterAndSemiJoinType is called when production outerAndSemiJoinType is entered. -func (s *BaseDorisSQLListener) EnterOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) {} - -// ExitOuterAndSemiJoinType is called when production outerAndSemiJoinType is exited. -func (s *BaseDorisSQLListener) ExitOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) {} - -// EnterBracketHint is called when production bracketHint is entered. -func (s *BaseDorisSQLListener) EnterBracketHint(ctx *BracketHintContext) {} - -// ExitBracketHint is called when production bracketHint is exited. -func (s *BaseDorisSQLListener) ExitBracketHint(ctx *BracketHintContext) {} - -// EnterHintMap is called when production hintMap is entered. -func (s *BaseDorisSQLListener) EnterHintMap(ctx *HintMapContext) {} - -// ExitHintMap is called when production hintMap is exited. -func (s *BaseDorisSQLListener) ExitHintMap(ctx *HintMapContext) {} - -// EnterJoinCriteria is called when production joinCriteria is entered. -func (s *BaseDorisSQLListener) EnterJoinCriteria(ctx *JoinCriteriaContext) {} - -// ExitJoinCriteria is called when production joinCriteria is exited. -func (s *BaseDorisSQLListener) ExitJoinCriteria(ctx *JoinCriteriaContext) {} - -// EnterColumnAliases is called when production columnAliases is entered. -func (s *BaseDorisSQLListener) EnterColumnAliases(ctx *ColumnAliasesContext) {} - -// ExitColumnAliases is called when production columnAliases is exited. -func (s *BaseDorisSQLListener) ExitColumnAliases(ctx *ColumnAliasesContext) {} - -// EnterColumnAliasesWithoutParentheses is called when production columnAliasesWithoutParentheses is entered. -func (s *BaseDorisSQLListener) EnterColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) { -} - -// ExitColumnAliasesWithoutParentheses is called when production columnAliasesWithoutParentheses is exited. -func (s *BaseDorisSQLListener) ExitColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) { -} - -// EnterPartitionNames is called when production partitionNames is entered. -func (s *BaseDorisSQLListener) EnterPartitionNames(ctx *PartitionNamesContext) {} - -// ExitPartitionNames is called when production partitionNames is exited. -func (s *BaseDorisSQLListener) ExitPartitionNames(ctx *PartitionNamesContext) {} - -// EnterKeyPartitionList is called when production keyPartitionList is entered. -func (s *BaseDorisSQLListener) EnterKeyPartitionList(ctx *KeyPartitionListContext) {} - -// ExitKeyPartitionList is called when production keyPartitionList is exited. -func (s *BaseDorisSQLListener) ExitKeyPartitionList(ctx *KeyPartitionListContext) {} - -// EnterTabletList is called when production tabletList is entered. -func (s *BaseDorisSQLListener) EnterTabletList(ctx *TabletListContext) {} - -// ExitTabletList is called when production tabletList is exited. -func (s *BaseDorisSQLListener) ExitTabletList(ctx *TabletListContext) {} - -// EnterPrepareStatement is called when production prepareStatement is entered. -func (s *BaseDorisSQLListener) EnterPrepareStatement(ctx *PrepareStatementContext) {} - -// ExitPrepareStatement is called when production prepareStatement is exited. -func (s *BaseDorisSQLListener) ExitPrepareStatement(ctx *PrepareStatementContext) {} - -// EnterPrepareSql is called when production prepareSql is entered. -func (s *BaseDorisSQLListener) EnterPrepareSql(ctx *PrepareSqlContext) {} - -// ExitPrepareSql is called when production prepareSql is exited. -func (s *BaseDorisSQLListener) ExitPrepareSql(ctx *PrepareSqlContext) {} - -// EnterExecuteStatement is called when production executeStatement is entered. -func (s *BaseDorisSQLListener) EnterExecuteStatement(ctx *ExecuteStatementContext) {} - -// ExitExecuteStatement is called when production executeStatement is exited. -func (s *BaseDorisSQLListener) ExitExecuteStatement(ctx *ExecuteStatementContext) {} - -// EnterDeallocateStatement is called when production deallocateStatement is entered. -func (s *BaseDorisSQLListener) EnterDeallocateStatement(ctx *DeallocateStatementContext) {} - -// ExitDeallocateStatement is called when production deallocateStatement is exited. -func (s *BaseDorisSQLListener) ExitDeallocateStatement(ctx *DeallocateStatementContext) {} - -// EnterReplicaList is called when production replicaList is entered. -func (s *BaseDorisSQLListener) EnterReplicaList(ctx *ReplicaListContext) {} - -// ExitReplicaList is called when production replicaList is exited. -func (s *BaseDorisSQLListener) ExitReplicaList(ctx *ReplicaListContext) {} - -// EnterExpressionsWithDefault is called when production expressionsWithDefault is entered. -func (s *BaseDorisSQLListener) EnterExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) {} - -// ExitExpressionsWithDefault is called when production expressionsWithDefault is exited. -func (s *BaseDorisSQLListener) ExitExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) {} - -// EnterExpressionOrDefault is called when production expressionOrDefault is entered. -func (s *BaseDorisSQLListener) EnterExpressionOrDefault(ctx *ExpressionOrDefaultContext) {} - -// ExitExpressionOrDefault is called when production expressionOrDefault is exited. -func (s *BaseDorisSQLListener) ExitExpressionOrDefault(ctx *ExpressionOrDefaultContext) {} - -// EnterMapExpressionList is called when production mapExpressionList is entered. -func (s *BaseDorisSQLListener) EnterMapExpressionList(ctx *MapExpressionListContext) {} - -// ExitMapExpressionList is called when production mapExpressionList is exited. -func (s *BaseDorisSQLListener) ExitMapExpressionList(ctx *MapExpressionListContext) {} - -// EnterMapExpression is called when production mapExpression is entered. -func (s *BaseDorisSQLListener) EnterMapExpression(ctx *MapExpressionContext) {} - -// ExitMapExpression is called when production mapExpression is exited. -func (s *BaseDorisSQLListener) ExitMapExpression(ctx *MapExpressionContext) {} - -// EnterExpressionSingleton is called when production expressionSingleton is entered. -func (s *BaseDorisSQLListener) EnterExpressionSingleton(ctx *ExpressionSingletonContext) {} - -// ExitExpressionSingleton is called when production expressionSingleton is exited. -func (s *BaseDorisSQLListener) ExitExpressionSingleton(ctx *ExpressionSingletonContext) {} - -// EnterExpressionDefault is called when production expressionDefault is entered. -func (s *BaseDorisSQLListener) EnterExpressionDefault(ctx *ExpressionDefaultContext) {} - -// ExitExpressionDefault is called when production expressionDefault is exited. -func (s *BaseDorisSQLListener) ExitExpressionDefault(ctx *ExpressionDefaultContext) {} - -// EnterLogicalNot is called when production logicalNot is entered. -func (s *BaseDorisSQLListener) EnterLogicalNot(ctx *LogicalNotContext) {} - -// ExitLogicalNot is called when production logicalNot is exited. -func (s *BaseDorisSQLListener) ExitLogicalNot(ctx *LogicalNotContext) {} - -// EnterLogicalBinary is called when production logicalBinary is entered. -func (s *BaseDorisSQLListener) EnterLogicalBinary(ctx *LogicalBinaryContext) {} - -// ExitLogicalBinary is called when production logicalBinary is exited. -func (s *BaseDorisSQLListener) ExitLogicalBinary(ctx *LogicalBinaryContext) {} - -// EnterExpressionList is called when production expressionList is entered. -func (s *BaseDorisSQLListener) EnterExpressionList(ctx *ExpressionListContext) {} - -// ExitExpressionList is called when production expressionList is exited. -func (s *BaseDorisSQLListener) ExitExpressionList(ctx *ExpressionListContext) {} - -// EnterComparison is called when production comparison is entered. -func (s *BaseDorisSQLListener) EnterComparison(ctx *ComparisonContext) {} - -// ExitComparison is called when production comparison is exited. -func (s *BaseDorisSQLListener) ExitComparison(ctx *ComparisonContext) {} - -// EnterBooleanExpressionDefault is called when production booleanExpressionDefault is entered. -func (s *BaseDorisSQLListener) EnterBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) {} - -// ExitBooleanExpressionDefault is called when production booleanExpressionDefault is exited. -func (s *BaseDorisSQLListener) ExitBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) {} - -// EnterIsNull is called when production isNull is entered. -func (s *BaseDorisSQLListener) EnterIsNull(ctx *IsNullContext) {} - -// ExitIsNull is called when production isNull is exited. -func (s *BaseDorisSQLListener) ExitIsNull(ctx *IsNullContext) {} - -// EnterScalarSubquery is called when production scalarSubquery is entered. -func (s *BaseDorisSQLListener) EnterScalarSubquery(ctx *ScalarSubqueryContext) {} - -// ExitScalarSubquery is called when production scalarSubquery is exited. -func (s *BaseDorisSQLListener) ExitScalarSubquery(ctx *ScalarSubqueryContext) {} - -// EnterPredicate is called when production predicate is entered. -func (s *BaseDorisSQLListener) EnterPredicate(ctx *PredicateContext) {} - -// ExitPredicate is called when production predicate is exited. -func (s *BaseDorisSQLListener) ExitPredicate(ctx *PredicateContext) {} - -// EnterTupleInSubquery is called when production tupleInSubquery is entered. -func (s *BaseDorisSQLListener) EnterTupleInSubquery(ctx *TupleInSubqueryContext) {} - -// ExitTupleInSubquery is called when production tupleInSubquery is exited. -func (s *BaseDorisSQLListener) ExitTupleInSubquery(ctx *TupleInSubqueryContext) {} - -// EnterInSubquery is called when production inSubquery is entered. -func (s *BaseDorisSQLListener) EnterInSubquery(ctx *InSubqueryContext) {} - -// ExitInSubquery is called when production inSubquery is exited. -func (s *BaseDorisSQLListener) ExitInSubquery(ctx *InSubqueryContext) {} - -// EnterInList is called when production inList is entered. -func (s *BaseDorisSQLListener) EnterInList(ctx *InListContext) {} - -// ExitInList is called when production inList is exited. -func (s *BaseDorisSQLListener) ExitInList(ctx *InListContext) {} - -// EnterBetween is called when production between is entered. -func (s *BaseDorisSQLListener) EnterBetween(ctx *BetweenContext) {} - -// ExitBetween is called when production between is exited. -func (s *BaseDorisSQLListener) ExitBetween(ctx *BetweenContext) {} - -// EnterLike is called when production like is entered. -func (s *BaseDorisSQLListener) EnterLike(ctx *LikeContext) {} - -// ExitLike is called when production like is exited. -func (s *BaseDorisSQLListener) ExitLike(ctx *LikeContext) {} - -// EnterValueExpressionDefault is called when production valueExpressionDefault is entered. -func (s *BaseDorisSQLListener) EnterValueExpressionDefault(ctx *ValueExpressionDefaultContext) {} - -// ExitValueExpressionDefault is called when production valueExpressionDefault is exited. -func (s *BaseDorisSQLListener) ExitValueExpressionDefault(ctx *ValueExpressionDefaultContext) {} - -// EnterArithmeticBinary is called when production arithmeticBinary is entered. -func (s *BaseDorisSQLListener) EnterArithmeticBinary(ctx *ArithmeticBinaryContext) {} - -// ExitArithmeticBinary is called when production arithmeticBinary is exited. -func (s *BaseDorisSQLListener) ExitArithmeticBinary(ctx *ArithmeticBinaryContext) {} - -// EnterDereference is called when production dereference is entered. -func (s *BaseDorisSQLListener) EnterDereference(ctx *DereferenceContext) {} - -// ExitDereference is called when production dereference is exited. -func (s *BaseDorisSQLListener) ExitDereference(ctx *DereferenceContext) {} - -// EnterOdbcFunctionCallExpression is called when production odbcFunctionCallExpression is entered. -func (s *BaseDorisSQLListener) EnterOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) { -} - -// ExitOdbcFunctionCallExpression is called when production odbcFunctionCallExpression is exited. -func (s *BaseDorisSQLListener) ExitOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) { -} - -// EnterMatchExpr is called when production matchExpr is entered. -func (s *BaseDorisSQLListener) EnterMatchExpr(ctx *MatchExprContext) {} - -// ExitMatchExpr is called when production matchExpr is exited. -func (s *BaseDorisSQLListener) ExitMatchExpr(ctx *MatchExprContext) {} - -// EnterColumnRef is called when production columnRef is entered. -func (s *BaseDorisSQLListener) EnterColumnRef(ctx *ColumnRefContext) {} - -// ExitColumnRef is called when production columnRef is exited. -func (s *BaseDorisSQLListener) ExitColumnRef(ctx *ColumnRefContext) {} - -// EnterConvert is called when production convert is entered. -func (s *BaseDorisSQLListener) EnterConvert(ctx *ConvertContext) {} - -// ExitConvert is called when production convert is exited. -func (s *BaseDorisSQLListener) ExitConvert(ctx *ConvertContext) {} - -// EnterCollectionSubscript is called when production collectionSubscript is entered. -func (s *BaseDorisSQLListener) EnterCollectionSubscript(ctx *CollectionSubscriptContext) {} - -// ExitCollectionSubscript is called when production collectionSubscript is exited. -func (s *BaseDorisSQLListener) ExitCollectionSubscript(ctx *CollectionSubscriptContext) {} - -// EnterLiteral is called when production literal is entered. -func (s *BaseDorisSQLListener) EnterLiteral(ctx *LiteralContext) {} - -// ExitLiteral is called when production literal is exited. -func (s *BaseDorisSQLListener) ExitLiteral(ctx *LiteralContext) {} - -// EnterCast is called when production cast is entered. -func (s *BaseDorisSQLListener) EnterCast(ctx *CastContext) {} - -// ExitCast is called when production cast is exited. -func (s *BaseDorisSQLListener) ExitCast(ctx *CastContext) {} - -// EnterParenthesizedExpression is called when production parenthesizedExpression is entered. -func (s *BaseDorisSQLListener) EnterParenthesizedExpression(ctx *ParenthesizedExpressionContext) {} - -// ExitParenthesizedExpression is called when production parenthesizedExpression is exited. -func (s *BaseDorisSQLListener) ExitParenthesizedExpression(ctx *ParenthesizedExpressionContext) {} - -// EnterUserVariableExpression is called when production userVariableExpression is entered. -func (s *BaseDorisSQLListener) EnterUserVariableExpression(ctx *UserVariableExpressionContext) {} - -// ExitUserVariableExpression is called when production userVariableExpression is exited. -func (s *BaseDorisSQLListener) ExitUserVariableExpression(ctx *UserVariableExpressionContext) {} - -// EnterFunctionCallExpression is called when production functionCallExpression is entered. -func (s *BaseDorisSQLListener) EnterFunctionCallExpression(ctx *FunctionCallExpressionContext) {} - -// ExitFunctionCallExpression is called when production functionCallExpression is exited. -func (s *BaseDorisSQLListener) ExitFunctionCallExpression(ctx *FunctionCallExpressionContext) {} - -// EnterSimpleCase is called when production simpleCase is entered. -func (s *BaseDorisSQLListener) EnterSimpleCase(ctx *SimpleCaseContext) {} - -// ExitSimpleCase is called when production simpleCase is exited. -func (s *BaseDorisSQLListener) ExitSimpleCase(ctx *SimpleCaseContext) {} - -// EnterArrowExpression is called when production arrowExpression is entered. -func (s *BaseDorisSQLListener) EnterArrowExpression(ctx *ArrowExpressionContext) {} - -// ExitArrowExpression is called when production arrowExpression is exited. -func (s *BaseDorisSQLListener) ExitArrowExpression(ctx *ArrowExpressionContext) {} - -// EnterArrayExpr is called when production arrayExpr is entered. -func (s *BaseDorisSQLListener) EnterArrayExpr(ctx *ArrayExprContext) {} - -// ExitArrayExpr is called when production arrayExpr is exited. -func (s *BaseDorisSQLListener) ExitArrayExpr(ctx *ArrayExprContext) {} - -// EnterSystemVariableExpression is called when production systemVariableExpression is entered. -func (s *BaseDorisSQLListener) EnterSystemVariableExpression(ctx *SystemVariableExpressionContext) {} - -// ExitSystemVariableExpression is called when production systemVariableExpression is exited. -func (s *BaseDorisSQLListener) ExitSystemVariableExpression(ctx *SystemVariableExpressionContext) {} - -// EnterConcat is called when production concat is entered. -func (s *BaseDorisSQLListener) EnterConcat(ctx *ConcatContext) {} - -// ExitConcat is called when production concat is exited. -func (s *BaseDorisSQLListener) ExitConcat(ctx *ConcatContext) {} - -// EnterSubqueryExpression is called when production subqueryExpression is entered. -func (s *BaseDorisSQLListener) EnterSubqueryExpression(ctx *SubqueryExpressionContext) {} - -// ExitSubqueryExpression is called when production subqueryExpression is exited. -func (s *BaseDorisSQLListener) ExitSubqueryExpression(ctx *SubqueryExpressionContext) {} - -// EnterLambdaFunctionExpr is called when production lambdaFunctionExpr is entered. -func (s *BaseDorisSQLListener) EnterLambdaFunctionExpr(ctx *LambdaFunctionExprContext) {} - -// ExitLambdaFunctionExpr is called when production lambdaFunctionExpr is exited. -func (s *BaseDorisSQLListener) ExitLambdaFunctionExpr(ctx *LambdaFunctionExprContext) {} - -// EnterDictionaryGetExpr is called when production dictionaryGetExpr is entered. -func (s *BaseDorisSQLListener) EnterDictionaryGetExpr(ctx *DictionaryGetExprContext) {} - -// ExitDictionaryGetExpr is called when production dictionaryGetExpr is exited. -func (s *BaseDorisSQLListener) ExitDictionaryGetExpr(ctx *DictionaryGetExprContext) {} - -// EnterCollate is called when production collate is entered. -func (s *BaseDorisSQLListener) EnterCollate(ctx *CollateContext) {} - -// ExitCollate is called when production collate is exited. -func (s *BaseDorisSQLListener) ExitCollate(ctx *CollateContext) {} - -// EnterArrayConstructor is called when production arrayConstructor is entered. -func (s *BaseDorisSQLListener) EnterArrayConstructor(ctx *ArrayConstructorContext) {} - -// ExitArrayConstructor is called when production arrayConstructor is exited. -func (s *BaseDorisSQLListener) ExitArrayConstructor(ctx *ArrayConstructorContext) {} - -// EnterMapConstructor is called when production mapConstructor is entered. -func (s *BaseDorisSQLListener) EnterMapConstructor(ctx *MapConstructorContext) {} - -// ExitMapConstructor is called when production mapConstructor is exited. -func (s *BaseDorisSQLListener) ExitMapConstructor(ctx *MapConstructorContext) {} - -// EnterArraySlice is called when production arraySlice is entered. -func (s *BaseDorisSQLListener) EnterArraySlice(ctx *ArraySliceContext) {} - -// ExitArraySlice is called when production arraySlice is exited. -func (s *BaseDorisSQLListener) ExitArraySlice(ctx *ArraySliceContext) {} - -// EnterExists is called when production exists is entered. -func (s *BaseDorisSQLListener) EnterExists(ctx *ExistsContext) {} - -// ExitExists is called when production exists is exited. -func (s *BaseDorisSQLListener) ExitExists(ctx *ExistsContext) {} - -// EnterSearchedCase is called when production searchedCase is entered. -func (s *BaseDorisSQLListener) EnterSearchedCase(ctx *SearchedCaseContext) {} - -// ExitSearchedCase is called when production searchedCase is exited. -func (s *BaseDorisSQLListener) ExitSearchedCase(ctx *SearchedCaseContext) {} - -// EnterArithmeticUnary is called when production arithmeticUnary is entered. -func (s *BaseDorisSQLListener) EnterArithmeticUnary(ctx *ArithmeticUnaryContext) {} - -// ExitArithmeticUnary is called when production arithmeticUnary is exited. -func (s *BaseDorisSQLListener) ExitArithmeticUnary(ctx *ArithmeticUnaryContext) {} - -// EnterNullLiteral is called when production nullLiteral is entered. -func (s *BaseDorisSQLListener) EnterNullLiteral(ctx *NullLiteralContext) {} - -// ExitNullLiteral is called when production nullLiteral is exited. -func (s *BaseDorisSQLListener) ExitNullLiteral(ctx *NullLiteralContext) {} - -// EnterBooleanLiteral is called when production booleanLiteral is entered. -func (s *BaseDorisSQLListener) EnterBooleanLiteral(ctx *BooleanLiteralContext) {} - -// ExitBooleanLiteral is called when production booleanLiteral is exited. -func (s *BaseDorisSQLListener) ExitBooleanLiteral(ctx *BooleanLiteralContext) {} - -// EnterNumericLiteral is called when production numericLiteral is entered. -func (s *BaseDorisSQLListener) EnterNumericLiteral(ctx *NumericLiteralContext) {} - -// ExitNumericLiteral is called when production numericLiteral is exited. -func (s *BaseDorisSQLListener) ExitNumericLiteral(ctx *NumericLiteralContext) {} - -// EnterDateLiteral is called when production dateLiteral is entered. -func (s *BaseDorisSQLListener) EnterDateLiteral(ctx *DateLiteralContext) {} - -// ExitDateLiteral is called when production dateLiteral is exited. -func (s *BaseDorisSQLListener) ExitDateLiteral(ctx *DateLiteralContext) {} - -// EnterStringLiteral is called when production stringLiteral is entered. -func (s *BaseDorisSQLListener) EnterStringLiteral(ctx *StringLiteralContext) {} - -// ExitStringLiteral is called when production stringLiteral is exited. -func (s *BaseDorisSQLListener) ExitStringLiteral(ctx *StringLiteralContext) {} - -// EnterIntervalLiteral is called when production intervalLiteral is entered. -func (s *BaseDorisSQLListener) EnterIntervalLiteral(ctx *IntervalLiteralContext) {} - -// ExitIntervalLiteral is called when production intervalLiteral is exited. -func (s *BaseDorisSQLListener) ExitIntervalLiteral(ctx *IntervalLiteralContext) {} - -// EnterUnitBoundaryLiteral is called when production unitBoundaryLiteral is entered. -func (s *BaseDorisSQLListener) EnterUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) {} - -// ExitUnitBoundaryLiteral is called when production unitBoundaryLiteral is exited. -func (s *BaseDorisSQLListener) ExitUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) {} - -// EnterBinaryLiteral is called when production binaryLiteral is entered. -func (s *BaseDorisSQLListener) EnterBinaryLiteral(ctx *BinaryLiteralContext) {} - -// ExitBinaryLiteral is called when production binaryLiteral is exited. -func (s *BaseDorisSQLListener) ExitBinaryLiteral(ctx *BinaryLiteralContext) {} - -// EnterParameter is called when production Parameter is entered. -func (s *BaseDorisSQLListener) EnterParameter(ctx *ParameterContext) {} - -// ExitParameter is called when production Parameter is exited. -func (s *BaseDorisSQLListener) ExitParameter(ctx *ParameterContext) {} - -// EnterExtract is called when production extract is entered. -func (s *BaseDorisSQLListener) EnterExtract(ctx *ExtractContext) {} - -// ExitExtract is called when production extract is exited. -func (s *BaseDorisSQLListener) ExitExtract(ctx *ExtractContext) {} - -// EnterGroupingOperation is called when production groupingOperation is entered. -func (s *BaseDorisSQLListener) EnterGroupingOperation(ctx *GroupingOperationContext) {} - -// ExitGroupingOperation is called when production groupingOperation is exited. -func (s *BaseDorisSQLListener) ExitGroupingOperation(ctx *GroupingOperationContext) {} - -// EnterInformationFunction is called when production informationFunction is entered. -func (s *BaseDorisSQLListener) EnterInformationFunction(ctx *InformationFunctionContext) {} - -// ExitInformationFunction is called when production informationFunction is exited. -func (s *BaseDorisSQLListener) ExitInformationFunction(ctx *InformationFunctionContext) {} - -// EnterSpecialDateTime is called when production specialDateTime is entered. -func (s *BaseDorisSQLListener) EnterSpecialDateTime(ctx *SpecialDateTimeContext) {} - -// ExitSpecialDateTime is called when production specialDateTime is exited. -func (s *BaseDorisSQLListener) ExitSpecialDateTime(ctx *SpecialDateTimeContext) {} - -// EnterSpecialFunction is called when production specialFunction is entered. -func (s *BaseDorisSQLListener) EnterSpecialFunction(ctx *SpecialFunctionContext) {} - -// ExitSpecialFunction is called when production specialFunction is exited. -func (s *BaseDorisSQLListener) ExitSpecialFunction(ctx *SpecialFunctionContext) {} - -// EnterAggregationFunctionCall is called when production aggregationFunctionCall is entered. -func (s *BaseDorisSQLListener) EnterAggregationFunctionCall(ctx *AggregationFunctionCallContext) {} - -// ExitAggregationFunctionCall is called when production aggregationFunctionCall is exited. -func (s *BaseDorisSQLListener) ExitAggregationFunctionCall(ctx *AggregationFunctionCallContext) {} - -// EnterWindowFunctionCall is called when production windowFunctionCall is entered. -func (s *BaseDorisSQLListener) EnterWindowFunctionCall(ctx *WindowFunctionCallContext) {} - -// ExitWindowFunctionCall is called when production windowFunctionCall is exited. -func (s *BaseDorisSQLListener) ExitWindowFunctionCall(ctx *WindowFunctionCallContext) {} - -// EnterTranslateFunctionCall is called when production translateFunctionCall is entered. -func (s *BaseDorisSQLListener) EnterTranslateFunctionCall(ctx *TranslateFunctionCallContext) {} - -// ExitTranslateFunctionCall is called when production translateFunctionCall is exited. -func (s *BaseDorisSQLListener) ExitTranslateFunctionCall(ctx *TranslateFunctionCallContext) {} - -// EnterSimpleFunctionCall is called when production simpleFunctionCall is entered. -func (s *BaseDorisSQLListener) EnterSimpleFunctionCall(ctx *SimpleFunctionCallContext) {} - -// ExitSimpleFunctionCall is called when production simpleFunctionCall is exited. -func (s *BaseDorisSQLListener) ExitSimpleFunctionCall(ctx *SimpleFunctionCallContext) {} - -// EnterAggregationFunction is called when production aggregationFunction is entered. -func (s *BaseDorisSQLListener) EnterAggregationFunction(ctx *AggregationFunctionContext) {} - -// ExitAggregationFunction is called when production aggregationFunction is exited. -func (s *BaseDorisSQLListener) ExitAggregationFunction(ctx *AggregationFunctionContext) {} - -// EnterUserVariable is called when production userVariable is entered. -func (s *BaseDorisSQLListener) EnterUserVariable(ctx *UserVariableContext) {} - -// ExitUserVariable is called when production userVariable is exited. -func (s *BaseDorisSQLListener) ExitUserVariable(ctx *UserVariableContext) {} - -// EnterSystemVariable is called when production systemVariable is entered. -func (s *BaseDorisSQLListener) EnterSystemVariable(ctx *SystemVariableContext) {} - -// ExitSystemVariable is called when production systemVariable is exited. -func (s *BaseDorisSQLListener) ExitSystemVariable(ctx *SystemVariableContext) {} - -// EnterColumnReference is called when production columnReference is entered. -func (s *BaseDorisSQLListener) EnterColumnReference(ctx *ColumnReferenceContext) {} - -// ExitColumnReference is called when production columnReference is exited. -func (s *BaseDorisSQLListener) ExitColumnReference(ctx *ColumnReferenceContext) {} - -// EnterInformationFunctionExpression is called when production informationFunctionExpression is entered. -func (s *BaseDorisSQLListener) EnterInformationFunctionExpression(ctx *InformationFunctionExpressionContext) { -} - -// ExitInformationFunctionExpression is called when production informationFunctionExpression is exited. -func (s *BaseDorisSQLListener) ExitInformationFunctionExpression(ctx *InformationFunctionExpressionContext) { -} - -// EnterSpecialDateTimeExpression is called when production specialDateTimeExpression is entered. -func (s *BaseDorisSQLListener) EnterSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) { -} - -// ExitSpecialDateTimeExpression is called when production specialDateTimeExpression is exited. -func (s *BaseDorisSQLListener) ExitSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) {} - -// EnterSpecialFunctionExpression is called when production specialFunctionExpression is entered. -func (s *BaseDorisSQLListener) EnterSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) { -} - -// ExitSpecialFunctionExpression is called when production specialFunctionExpression is exited. -func (s *BaseDorisSQLListener) ExitSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) {} - -// EnterWindowFunction is called when production windowFunction is entered. -func (s *BaseDorisSQLListener) EnterWindowFunction(ctx *WindowFunctionContext) {} - -// ExitWindowFunction is called when production windowFunction is exited. -func (s *BaseDorisSQLListener) ExitWindowFunction(ctx *WindowFunctionContext) {} - -// EnterWhenClause is called when production whenClause is entered. -func (s *BaseDorisSQLListener) EnterWhenClause(ctx *WhenClauseContext) {} - -// ExitWhenClause is called when production whenClause is exited. -func (s *BaseDorisSQLListener) ExitWhenClause(ctx *WhenClauseContext) {} - -// EnterOver is called when production over is entered. -func (s *BaseDorisSQLListener) EnterOver(ctx *OverContext) {} - -// ExitOver is called when production over is exited. -func (s *BaseDorisSQLListener) ExitOver(ctx *OverContext) {} - -// EnterIgnoreNulls is called when production ignoreNulls is entered. -func (s *BaseDorisSQLListener) EnterIgnoreNulls(ctx *IgnoreNullsContext) {} - -// ExitIgnoreNulls is called when production ignoreNulls is exited. -func (s *BaseDorisSQLListener) ExitIgnoreNulls(ctx *IgnoreNullsContext) {} - -// EnterWindowFrame is called when production windowFrame is entered. -func (s *BaseDorisSQLListener) EnterWindowFrame(ctx *WindowFrameContext) {} - -// ExitWindowFrame is called when production windowFrame is exited. -func (s *BaseDorisSQLListener) ExitWindowFrame(ctx *WindowFrameContext) {} - -// EnterUnboundedFrame is called when production unboundedFrame is entered. -func (s *BaseDorisSQLListener) EnterUnboundedFrame(ctx *UnboundedFrameContext) {} - -// ExitUnboundedFrame is called when production unboundedFrame is exited. -func (s *BaseDorisSQLListener) ExitUnboundedFrame(ctx *UnboundedFrameContext) {} - -// EnterCurrentRowBound is called when production currentRowBound is entered. -func (s *BaseDorisSQLListener) EnterCurrentRowBound(ctx *CurrentRowBoundContext) {} - -// ExitCurrentRowBound is called when production currentRowBound is exited. -func (s *BaseDorisSQLListener) ExitCurrentRowBound(ctx *CurrentRowBoundContext) {} - -// EnterBoundedFrame is called when production boundedFrame is entered. -func (s *BaseDorisSQLListener) EnterBoundedFrame(ctx *BoundedFrameContext) {} - -// ExitBoundedFrame is called when production boundedFrame is exited. -func (s *BaseDorisSQLListener) ExitBoundedFrame(ctx *BoundedFrameContext) {} - -// EnterBackupRestoreObjectDesc is called when production backupRestoreObjectDesc is entered. -func (s *BaseDorisSQLListener) EnterBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) {} - -// ExitBackupRestoreObjectDesc is called when production backupRestoreObjectDesc is exited. -func (s *BaseDorisSQLListener) ExitBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) {} - -// EnterTableDesc is called when production tableDesc is entered. -func (s *BaseDorisSQLListener) EnterTableDesc(ctx *TableDescContext) {} - -// ExitTableDesc is called when production tableDesc is exited. -func (s *BaseDorisSQLListener) ExitTableDesc(ctx *TableDescContext) {} - -// EnterBackupRestoreTableDesc is called when production backupRestoreTableDesc is entered. -func (s *BaseDorisSQLListener) EnterBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) {} - -// ExitBackupRestoreTableDesc is called when production backupRestoreTableDesc is exited. -func (s *BaseDorisSQLListener) ExitBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) {} - -// EnterExplainDesc is called when production explainDesc is entered. -func (s *BaseDorisSQLListener) EnterExplainDesc(ctx *ExplainDescContext) {} - -// ExitExplainDesc is called when production explainDesc is exited. -func (s *BaseDorisSQLListener) ExitExplainDesc(ctx *ExplainDescContext) {} - -// EnterOptimizerTrace is called when production optimizerTrace is entered. -func (s *BaseDorisSQLListener) EnterOptimizerTrace(ctx *OptimizerTraceContext) {} - -// ExitOptimizerTrace is called when production optimizerTrace is exited. -func (s *BaseDorisSQLListener) ExitOptimizerTrace(ctx *OptimizerTraceContext) {} - -// EnterPartitionExpr is called when production partitionExpr is entered. -func (s *BaseDorisSQLListener) EnterPartitionExpr(ctx *PartitionExprContext) {} - -// ExitPartitionExpr is called when production partitionExpr is exited. -func (s *BaseDorisSQLListener) ExitPartitionExpr(ctx *PartitionExprContext) {} - -// EnterPartitionDesc is called when production partitionDesc is entered. -func (s *BaseDorisSQLListener) EnterPartitionDesc(ctx *PartitionDescContext) {} - -// ExitPartitionDesc is called when production partitionDesc is exited. -func (s *BaseDorisSQLListener) ExitPartitionDesc(ctx *PartitionDescContext) {} - -// EnterListPartitionDesc is called when production listPartitionDesc is entered. -func (s *BaseDorisSQLListener) EnterListPartitionDesc(ctx *ListPartitionDescContext) {} - -// ExitListPartitionDesc is called when production listPartitionDesc is exited. -func (s *BaseDorisSQLListener) ExitListPartitionDesc(ctx *ListPartitionDescContext) {} - -// EnterSingleItemListPartitionDesc is called when production singleItemListPartitionDesc is entered. -func (s *BaseDorisSQLListener) EnterSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) { -} - -// ExitSingleItemListPartitionDesc is called when production singleItemListPartitionDesc is exited. -func (s *BaseDorisSQLListener) ExitSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) { -} - -// EnterMultiItemListPartitionDesc is called when production multiItemListPartitionDesc is entered. -func (s *BaseDorisSQLListener) EnterMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) { -} - -// ExitMultiItemListPartitionDesc is called when production multiItemListPartitionDesc is exited. -func (s *BaseDorisSQLListener) ExitMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) { -} - -// EnterMultiListPartitionValues is called when production multiListPartitionValues is entered. -func (s *BaseDorisSQLListener) EnterMultiListPartitionValues(ctx *MultiListPartitionValuesContext) {} - -// ExitMultiListPartitionValues is called when production multiListPartitionValues is exited. -func (s *BaseDorisSQLListener) ExitMultiListPartitionValues(ctx *MultiListPartitionValuesContext) {} - -// EnterSingleListPartitionValues is called when production singleListPartitionValues is entered. -func (s *BaseDorisSQLListener) EnterSingleListPartitionValues(ctx *SingleListPartitionValuesContext) { -} - -// ExitSingleListPartitionValues is called when production singleListPartitionValues is exited. -func (s *BaseDorisSQLListener) ExitSingleListPartitionValues(ctx *SingleListPartitionValuesContext) {} - -// EnterListPartitionValues is called when production listPartitionValues is entered. -func (s *BaseDorisSQLListener) EnterListPartitionValues(ctx *ListPartitionValuesContext) {} - -// ExitListPartitionValues is called when production listPartitionValues is exited. -func (s *BaseDorisSQLListener) ExitListPartitionValues(ctx *ListPartitionValuesContext) {} - -// EnterListPartitionValue is called when production listPartitionValue is entered. -func (s *BaseDorisSQLListener) EnterListPartitionValue(ctx *ListPartitionValueContext) {} - -// ExitListPartitionValue is called when production listPartitionValue is exited. -func (s *BaseDorisSQLListener) ExitListPartitionValue(ctx *ListPartitionValueContext) {} - -// EnterStringList is called when production stringList is entered. -func (s *BaseDorisSQLListener) EnterStringList(ctx *StringListContext) {} - -// ExitStringList is called when production stringList is exited. -func (s *BaseDorisSQLListener) ExitStringList(ctx *StringListContext) {} - -// EnterLiteralExpressionList is called when production literalExpressionList is entered. -func (s *BaseDorisSQLListener) EnterLiteralExpressionList(ctx *LiteralExpressionListContext) {} - -// ExitLiteralExpressionList is called when production literalExpressionList is exited. -func (s *BaseDorisSQLListener) ExitLiteralExpressionList(ctx *LiteralExpressionListContext) {} - -// EnterRangePartitionDesc is called when production rangePartitionDesc is entered. -func (s *BaseDorisSQLListener) EnterRangePartitionDesc(ctx *RangePartitionDescContext) {} - -// ExitRangePartitionDesc is called when production rangePartitionDesc is exited. -func (s *BaseDorisSQLListener) ExitRangePartitionDesc(ctx *RangePartitionDescContext) {} - -// EnterSingleRangePartition is called when production singleRangePartition is entered. -func (s *BaseDorisSQLListener) EnterSingleRangePartition(ctx *SingleRangePartitionContext) {} - -// ExitSingleRangePartition is called when production singleRangePartition is exited. -func (s *BaseDorisSQLListener) ExitSingleRangePartition(ctx *SingleRangePartitionContext) {} - -// EnterMultiRangePartition is called when production multiRangePartition is entered. -func (s *BaseDorisSQLListener) EnterMultiRangePartition(ctx *MultiRangePartitionContext) {} - -// ExitMultiRangePartition is called when production multiRangePartition is exited. -func (s *BaseDorisSQLListener) ExitMultiRangePartition(ctx *MultiRangePartitionContext) {} - -// EnterPartitionRangeDesc is called when production partitionRangeDesc is entered. -func (s *BaseDorisSQLListener) EnterPartitionRangeDesc(ctx *PartitionRangeDescContext) {} - -// ExitPartitionRangeDesc is called when production partitionRangeDesc is exited. -func (s *BaseDorisSQLListener) ExitPartitionRangeDesc(ctx *PartitionRangeDescContext) {} - -// EnterPartitionKeyDesc is called when production partitionKeyDesc is entered. -func (s *BaseDorisSQLListener) EnterPartitionKeyDesc(ctx *PartitionKeyDescContext) {} - -// ExitPartitionKeyDesc is called when production partitionKeyDesc is exited. -func (s *BaseDorisSQLListener) ExitPartitionKeyDesc(ctx *PartitionKeyDescContext) {} - -// EnterPartitionValueList is called when production partitionValueList is entered. -func (s *BaseDorisSQLListener) EnterPartitionValueList(ctx *PartitionValueListContext) {} - -// ExitPartitionValueList is called when production partitionValueList is exited. -func (s *BaseDorisSQLListener) ExitPartitionValueList(ctx *PartitionValueListContext) {} - -// EnterKeyPartition is called when production keyPartition is entered. -func (s *BaseDorisSQLListener) EnterKeyPartition(ctx *KeyPartitionContext) {} - -// ExitKeyPartition is called when production keyPartition is exited. -func (s *BaseDorisSQLListener) ExitKeyPartition(ctx *KeyPartitionContext) {} - -// EnterPartitionValue is called when production partitionValue is entered. -func (s *BaseDorisSQLListener) EnterPartitionValue(ctx *PartitionValueContext) {} - -// ExitPartitionValue is called when production partitionValue is exited. -func (s *BaseDorisSQLListener) ExitPartitionValue(ctx *PartitionValueContext) {} - -// EnterDistributionClause is called when production distributionClause is entered. -func (s *BaseDorisSQLListener) EnterDistributionClause(ctx *DistributionClauseContext) {} - -// ExitDistributionClause is called when production distributionClause is exited. -func (s *BaseDorisSQLListener) ExitDistributionClause(ctx *DistributionClauseContext) {} - -// EnterDistributionDesc is called when production distributionDesc is entered. -func (s *BaseDorisSQLListener) EnterDistributionDesc(ctx *DistributionDescContext) {} - -// ExitDistributionDesc is called when production distributionDesc is exited. -func (s *BaseDorisSQLListener) ExitDistributionDesc(ctx *DistributionDescContext) {} - -// EnterRefreshSchemeDesc is called when production refreshSchemeDesc is entered. -func (s *BaseDorisSQLListener) EnterRefreshSchemeDesc(ctx *RefreshSchemeDescContext) {} - -// ExitRefreshSchemeDesc is called when production refreshSchemeDesc is exited. -func (s *BaseDorisSQLListener) ExitRefreshSchemeDesc(ctx *RefreshSchemeDescContext) {} - -// EnterStatusDesc is called when production statusDesc is entered. -func (s *BaseDorisSQLListener) EnterStatusDesc(ctx *StatusDescContext) {} - -// ExitStatusDesc is called when production statusDesc is exited. -func (s *BaseDorisSQLListener) ExitStatusDesc(ctx *StatusDescContext) {} - -// EnterProperties is called when production properties is entered. -func (s *BaseDorisSQLListener) EnterProperties(ctx *PropertiesContext) {} - -// ExitProperties is called when production properties is exited. -func (s *BaseDorisSQLListener) ExitProperties(ctx *PropertiesContext) {} - -// EnterExtProperties is called when production extProperties is entered. -func (s *BaseDorisSQLListener) EnterExtProperties(ctx *ExtPropertiesContext) {} - -// ExitExtProperties is called when production extProperties is exited. -func (s *BaseDorisSQLListener) ExitExtProperties(ctx *ExtPropertiesContext) {} - -// EnterPropertyList is called when production propertyList is entered. -func (s *BaseDorisSQLListener) EnterPropertyList(ctx *PropertyListContext) {} - -// ExitPropertyList is called when production propertyList is exited. -func (s *BaseDorisSQLListener) ExitPropertyList(ctx *PropertyListContext) {} - -// EnterUserPropertyList is called when production userPropertyList is entered. -func (s *BaseDorisSQLListener) EnterUserPropertyList(ctx *UserPropertyListContext) {} - -// ExitUserPropertyList is called when production userPropertyList is exited. -func (s *BaseDorisSQLListener) ExitUserPropertyList(ctx *UserPropertyListContext) {} - -// EnterProperty is called when production property is entered. -func (s *BaseDorisSQLListener) EnterProperty(ctx *PropertyContext) {} - -// ExitProperty is called when production property is exited. -func (s *BaseDorisSQLListener) ExitProperty(ctx *PropertyContext) {} - -// EnterInlineProperties is called when production inlineProperties is entered. -func (s *BaseDorisSQLListener) EnterInlineProperties(ctx *InlinePropertiesContext) {} - -// ExitInlineProperties is called when production inlineProperties is exited. -func (s *BaseDorisSQLListener) ExitInlineProperties(ctx *InlinePropertiesContext) {} - -// EnterInlineProperty is called when production inlineProperty is entered. -func (s *BaseDorisSQLListener) EnterInlineProperty(ctx *InlinePropertyContext) {} - -// ExitInlineProperty is called when production inlineProperty is exited. -func (s *BaseDorisSQLListener) ExitInlineProperty(ctx *InlinePropertyContext) {} - -// EnterVarType is called when production varType is entered. -func (s *BaseDorisSQLListener) EnterVarType(ctx *VarTypeContext) {} - -// ExitVarType is called when production varType is exited. -func (s *BaseDorisSQLListener) ExitVarType(ctx *VarTypeContext) {} - -// EnterComment is called when production comment is entered. -func (s *BaseDorisSQLListener) EnterComment(ctx *CommentContext) {} - -// ExitComment is called when production comment is exited. -func (s *BaseDorisSQLListener) ExitComment(ctx *CommentContext) {} - -// EnterOutfile is called when production outfile is entered. -func (s *BaseDorisSQLListener) EnterOutfile(ctx *OutfileContext) {} - -// ExitOutfile is called when production outfile is exited. -func (s *BaseDorisSQLListener) ExitOutfile(ctx *OutfileContext) {} - -// EnterFileFormat is called when production fileFormat is entered. -func (s *BaseDorisSQLListener) EnterFileFormat(ctx *FileFormatContext) {} - -// ExitFileFormat is called when production fileFormat is exited. -func (s *BaseDorisSQLListener) ExitFileFormat(ctx *FileFormatContext) {} - -// EnterString is called when production string is entered. -func (s *BaseDorisSQLListener) EnterString(ctx *StringContext) {} - -// ExitString is called when production string is exited. -func (s *BaseDorisSQLListener) ExitString(ctx *StringContext) {} - -// EnterBinary is called when production binary is entered. -func (s *BaseDorisSQLListener) EnterBinary(ctx *BinaryContext) {} - -// ExitBinary is called when production binary is exited. -func (s *BaseDorisSQLListener) ExitBinary(ctx *BinaryContext) {} - -// EnterComparisonOperator is called when production comparisonOperator is entered. -func (s *BaseDorisSQLListener) EnterComparisonOperator(ctx *ComparisonOperatorContext) {} - -// ExitComparisonOperator is called when production comparisonOperator is exited. -func (s *BaseDorisSQLListener) ExitComparisonOperator(ctx *ComparisonOperatorContext) {} - -// EnterBooleanValue is called when production booleanValue is entered. -func (s *BaseDorisSQLListener) EnterBooleanValue(ctx *BooleanValueContext) {} - -// ExitBooleanValue is called when production booleanValue is exited. -func (s *BaseDorisSQLListener) ExitBooleanValue(ctx *BooleanValueContext) {} - -// EnterInterval is called when production interval is entered. -func (s *BaseDorisSQLListener) EnterInterval(ctx *IntervalContext) {} - -// ExitInterval is called when production interval is exited. -func (s *BaseDorisSQLListener) ExitInterval(ctx *IntervalContext) {} - -// EnterTaskInterval is called when production taskInterval is entered. -func (s *BaseDorisSQLListener) EnterTaskInterval(ctx *TaskIntervalContext) {} - -// ExitTaskInterval is called when production taskInterval is exited. -func (s *BaseDorisSQLListener) ExitTaskInterval(ctx *TaskIntervalContext) {} - -// EnterTaskUnitIdentifier is called when production taskUnitIdentifier is entered. -func (s *BaseDorisSQLListener) EnterTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) {} - -// ExitTaskUnitIdentifier is called when production taskUnitIdentifier is exited. -func (s *BaseDorisSQLListener) ExitTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) {} - -// EnterUnitIdentifier is called when production unitIdentifier is entered. -func (s *BaseDorisSQLListener) EnterUnitIdentifier(ctx *UnitIdentifierContext) {} - -// ExitUnitIdentifier is called when production unitIdentifier is exited. -func (s *BaseDorisSQLListener) ExitUnitIdentifier(ctx *UnitIdentifierContext) {} - -// EnterUnitBoundary is called when production unitBoundary is entered. -func (s *BaseDorisSQLListener) EnterUnitBoundary(ctx *UnitBoundaryContext) {} - -// ExitUnitBoundary is called when production unitBoundary is exited. -func (s *BaseDorisSQLListener) ExitUnitBoundary(ctx *UnitBoundaryContext) {} - -// EnterType is called when production type is entered. -func (s *BaseDorisSQLListener) EnterType(ctx *TypeContext) {} - -// ExitType is called when production type is exited. -func (s *BaseDorisSQLListener) ExitType(ctx *TypeContext) {} - -// EnterArrayType is called when production arrayType is entered. -func (s *BaseDorisSQLListener) EnterArrayType(ctx *ArrayTypeContext) {} - -// ExitArrayType is called when production arrayType is exited. -func (s *BaseDorisSQLListener) ExitArrayType(ctx *ArrayTypeContext) {} - -// EnterMapType is called when production mapType is entered. -func (s *BaseDorisSQLListener) EnterMapType(ctx *MapTypeContext) {} - -// ExitMapType is called when production mapType is exited. -func (s *BaseDorisSQLListener) ExitMapType(ctx *MapTypeContext) {} - -// EnterSubfieldDesc is called when production subfieldDesc is entered. -func (s *BaseDorisSQLListener) EnterSubfieldDesc(ctx *SubfieldDescContext) {} - -// ExitSubfieldDesc is called when production subfieldDesc is exited. -func (s *BaseDorisSQLListener) ExitSubfieldDesc(ctx *SubfieldDescContext) {} - -// EnterSubfieldDescs is called when production subfieldDescs is entered. -func (s *BaseDorisSQLListener) EnterSubfieldDescs(ctx *SubfieldDescsContext) {} - -// ExitSubfieldDescs is called when production subfieldDescs is exited. -func (s *BaseDorisSQLListener) ExitSubfieldDescs(ctx *SubfieldDescsContext) {} - -// EnterStructType is called when production structType is entered. -func (s *BaseDorisSQLListener) EnterStructType(ctx *StructTypeContext) {} - -// ExitStructType is called when production structType is exited. -func (s *BaseDorisSQLListener) ExitStructType(ctx *StructTypeContext) {} - -// EnterTypeParameter is called when production typeParameter is entered. -func (s *BaseDorisSQLListener) EnterTypeParameter(ctx *TypeParameterContext) {} - -// ExitTypeParameter is called when production typeParameter is exited. -func (s *BaseDorisSQLListener) ExitTypeParameter(ctx *TypeParameterContext) {} - -// EnterBaseType is called when production baseType is entered. -func (s *BaseDorisSQLListener) EnterBaseType(ctx *BaseTypeContext) {} - -// ExitBaseType is called when production baseType is exited. -func (s *BaseDorisSQLListener) ExitBaseType(ctx *BaseTypeContext) {} - -// EnterDecimalType is called when production decimalType is entered. -func (s *BaseDorisSQLListener) EnterDecimalType(ctx *DecimalTypeContext) {} - -// ExitDecimalType is called when production decimalType is exited. -func (s *BaseDorisSQLListener) ExitDecimalType(ctx *DecimalTypeContext) {} - -// EnterQualifiedName is called when production qualifiedName is entered. -func (s *BaseDorisSQLListener) EnterQualifiedName(ctx *QualifiedNameContext) {} - -// ExitQualifiedName is called when production qualifiedName is exited. -func (s *BaseDorisSQLListener) ExitQualifiedName(ctx *QualifiedNameContext) {} - -// EnterTableName is called when production tableName is entered. -func (s *BaseDorisSQLListener) EnterTableName(ctx *TableNameContext) {} - -// ExitTableName is called when production tableName is exited. -func (s *BaseDorisSQLListener) ExitTableName(ctx *TableNameContext) {} - -// EnterWriteBranch is called when production writeBranch is entered. -func (s *BaseDorisSQLListener) EnterWriteBranch(ctx *WriteBranchContext) {} - -// ExitWriteBranch is called when production writeBranch is exited. -func (s *BaseDorisSQLListener) ExitWriteBranch(ctx *WriteBranchContext) {} - -// EnterUnquotedIdentifier is called when production unquotedIdentifier is entered. -func (s *BaseDorisSQLListener) EnterUnquotedIdentifier(ctx *UnquotedIdentifierContext) {} - -// ExitUnquotedIdentifier is called when production unquotedIdentifier is exited. -func (s *BaseDorisSQLListener) ExitUnquotedIdentifier(ctx *UnquotedIdentifierContext) {} - -// EnterDigitIdentifier is called when production digitIdentifier is entered. -func (s *BaseDorisSQLListener) EnterDigitIdentifier(ctx *DigitIdentifierContext) {} - -// ExitDigitIdentifier is called when production digitIdentifier is exited. -func (s *BaseDorisSQLListener) ExitDigitIdentifier(ctx *DigitIdentifierContext) {} - -// EnterBackQuotedIdentifier is called when production backQuotedIdentifier is entered. -func (s *BaseDorisSQLListener) EnterBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) {} - -// ExitBackQuotedIdentifier is called when production backQuotedIdentifier is exited. -func (s *BaseDorisSQLListener) ExitBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) {} - -// EnterIdentifierWithAlias is called when production identifierWithAlias is entered. -func (s *BaseDorisSQLListener) EnterIdentifierWithAlias(ctx *IdentifierWithAliasContext) {} - -// ExitIdentifierWithAlias is called when production identifierWithAlias is exited. -func (s *BaseDorisSQLListener) ExitIdentifierWithAlias(ctx *IdentifierWithAliasContext) {} - -// EnterIdentifierWithAliasList is called when production identifierWithAliasList is entered. -func (s *BaseDorisSQLListener) EnterIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) {} - -// ExitIdentifierWithAliasList is called when production identifierWithAliasList is exited. -func (s *BaseDorisSQLListener) ExitIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) {} - -// EnterIdentifierList is called when production identifierList is entered. -func (s *BaseDorisSQLListener) EnterIdentifierList(ctx *IdentifierListContext) {} - -// ExitIdentifierList is called when production identifierList is exited. -func (s *BaseDorisSQLListener) ExitIdentifierList(ctx *IdentifierListContext) {} - -// EnterIdentifierOrString is called when production identifierOrString is entered. -func (s *BaseDorisSQLListener) EnterIdentifierOrString(ctx *IdentifierOrStringContext) {} - -// ExitIdentifierOrString is called when production identifierOrString is exited. -func (s *BaseDorisSQLListener) ExitIdentifierOrString(ctx *IdentifierOrStringContext) {} - -// EnterIdentifierOrStringList is called when production identifierOrStringList is entered. -func (s *BaseDorisSQLListener) EnterIdentifierOrStringList(ctx *IdentifierOrStringListContext) {} - -// ExitIdentifierOrStringList is called when production identifierOrStringList is exited. -func (s *BaseDorisSQLListener) ExitIdentifierOrStringList(ctx *IdentifierOrStringListContext) {} - -// EnterIdentifierOrStringOrStar is called when production identifierOrStringOrStar is entered. -func (s *BaseDorisSQLListener) EnterIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) {} - -// ExitIdentifierOrStringOrStar is called when production identifierOrStringOrStar is exited. -func (s *BaseDorisSQLListener) ExitIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) {} - -// EnterUserWithoutHost is called when production userWithoutHost is entered. -func (s *BaseDorisSQLListener) EnterUserWithoutHost(ctx *UserWithoutHostContext) {} - -// ExitUserWithoutHost is called when production userWithoutHost is exited. -func (s *BaseDorisSQLListener) ExitUserWithoutHost(ctx *UserWithoutHostContext) {} - -// EnterUserWithHost is called when production userWithHost is entered. -func (s *BaseDorisSQLListener) EnterUserWithHost(ctx *UserWithHostContext) {} - -// ExitUserWithHost is called when production userWithHost is exited. -func (s *BaseDorisSQLListener) ExitUserWithHost(ctx *UserWithHostContext) {} - -// EnterUserWithHostAndBlanket is called when production userWithHostAndBlanket is entered. -func (s *BaseDorisSQLListener) EnterUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) {} - -// ExitUserWithHostAndBlanket is called when production userWithHostAndBlanket is exited. -func (s *BaseDorisSQLListener) ExitUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) {} - -// EnterAssignment is called when production assignment is entered. -func (s *BaseDorisSQLListener) EnterAssignment(ctx *AssignmentContext) {} - -// ExitAssignment is called when production assignment is exited. -func (s *BaseDorisSQLListener) ExitAssignment(ctx *AssignmentContext) {} - -// EnterAssignmentList is called when production assignmentList is entered. -func (s *BaseDorisSQLListener) EnterAssignmentList(ctx *AssignmentListContext) {} - -// ExitAssignmentList is called when production assignmentList is exited. -func (s *BaseDorisSQLListener) ExitAssignmentList(ctx *AssignmentListContext) {} - -// EnterDecimalValue is called when production decimalValue is entered. -func (s *BaseDorisSQLListener) EnterDecimalValue(ctx *DecimalValueContext) {} - -// ExitDecimalValue is called when production decimalValue is exited. -func (s *BaseDorisSQLListener) ExitDecimalValue(ctx *DecimalValueContext) {} - -// EnterDoubleValue is called when production doubleValue is entered. -func (s *BaseDorisSQLListener) EnterDoubleValue(ctx *DoubleValueContext) {} - -// ExitDoubleValue is called when production doubleValue is exited. -func (s *BaseDorisSQLListener) ExitDoubleValue(ctx *DoubleValueContext) {} - -// EnterIntegerValue is called when production integerValue is entered. -func (s *BaseDorisSQLListener) EnterIntegerValue(ctx *IntegerValueContext) {} - -// ExitIntegerValue is called when production integerValue is exited. -func (s *BaseDorisSQLListener) ExitIntegerValue(ctx *IntegerValueContext) {} - -// EnterNonReserved is called when production nonReserved is entered. -func (s *BaseDorisSQLListener) EnterNonReserved(ctx *NonReservedContext) {} - -// ExitNonReserved is called when production nonReserved is exited. -func (s *BaseDorisSQLListener) ExitNonReserved(ctx *NonReservedContext) {} diff --git a/doris/dorissql_base_visitor.go b/doris/dorissql_base_visitor.go deleted file mode 100644 index b20f0be..0000000 --- a/doris/dorissql_base_visitor.go +++ /dev/null @@ -1,2568 +0,0 @@ -// Code generated from DorisSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. - -package doris // DorisSQL -import "github.com/antlr4-go/antlr/v4" - -type BaseDorisSQLVisitor struct { - *antlr.BaseParseTreeVisitor -} - -func (v *BaseDorisSQLVisitor) VisitSqlStatements(ctx *SqlStatementsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSingleStatement(ctx *SingleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitStatement(ctx *StatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUseDatabaseStatement(ctx *UseDatabaseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUseCatalogStatement(ctx *UseCatalogStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetCatalogStatement(ctx *SetCatalogStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateDbStatement(ctx *CreateDbStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropDbStatement(ctx *DropDbStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateDbStatement(ctx *ShowCreateDbStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRecoverDbStmt(ctx *RecoverDbStmtContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDataStmt(ctx *ShowDataStmtContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateTableStatement(ctx *CreateTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnDesc(ctx *ColumnDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCharsetName(ctx *CharsetNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDefaultDesc(ctx *DefaultDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGeneratedColumnDesc(ctx *GeneratedColumnDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIndexDesc(ctx *IndexDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitEngineDesc(ctx *EngineDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCharsetDesc(ctx *CharsetDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCollateDesc(ctx *CollateDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitKeyDesc(ctx *KeyDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOrderByDesc(ctx *OrderByDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnNullable(ctx *ColumnNullableContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTypeWithNullable(ctx *TypeWithNullableContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAggStateDesc(ctx *AggStateDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAggDesc(ctx *AggDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRollupDesc(ctx *RollupDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRollupItem(ctx *RollupItemContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDupKeys(ctx *DupKeysContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitFromRollup(ctx *FromRollupContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOrReplace(ctx *OrReplaceContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIfNotExists(ctx *IfNotExistsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropTableStatement(ctx *DropTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterTableStatement(ctx *AlterTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateIndexStatement(ctx *CreateIndexStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropIndexStatement(ctx *DropIndexStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIndexType(ctx *IndexTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTableStatement(ctx *ShowTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateTableStatement(ctx *ShowCreateTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowColumnStatement(ctx *ShowColumnStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTableStatusStatement(ctx *ShowTableStatusStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRefreshTableStatement(ctx *RefreshTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowAlterStatement(ctx *ShowAlterStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDescTableStatement(ctx *DescTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowIndexStatement(ctx *ShowIndexStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRecoverTableStatement(ctx *RecoverTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTruncateTableStatement(ctx *TruncateTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPartitionsStatement(ctx *ShowPartitionsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateViewStatement(ctx *CreateViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterViewStatement(ctx *AlterViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropViewStatement(ctx *DropViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnNameWithComment(ctx *ColumnNameWithCommentContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubmitTaskStatement(ctx *SubmitTaskStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTaskClause(ctx *TaskClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropTaskStatement(ctx *DropTaskStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTaskScheduleDesc(ctx *TaskScheduleDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMvPartitionExprs(ctx *MvPartitionExprsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMaterializedViewDesc(ctx *MaterializedViewDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitKillStatement(ctx *KillStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSyncStatement(ctx *SyncStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterSystemStatement(ctx *AlterSystemStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCatalogsStatement(ctx *ShowCatalogsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterCatalogStatement(ctx *AlterCatalogStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTypeDesc(ctx *TypeDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLocationsDesc(ctx *LocationsDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowFailPointStatement(ctx *ShowFailPointStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropDictionaryStatement(ctx *DropDictionaryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDictionaryStatement(ctx *ShowDictionaryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDictionaryColumnDesc(ctx *DictionaryColumnDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDictionaryName(ctx *DictionaryNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterClause(ctx *AlterClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddFrontendClause(ctx *AddFrontendClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropFrontendClause(ctx *DropFrontendClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddBackendClause(ctx *AddBackendClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropBackendClause(ctx *DropBackendClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyBackendClause(ctx *ModifyBackendClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddComputeNodeClause(ctx *AddComputeNodeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropComputeNodeClause(ctx *DropComputeNodeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyBrokerClause(ctx *ModifyBrokerClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateImageClause(ctx *CreateImageClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDecommissionDiskClause(ctx *DecommissionDiskClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDisableDiskClause(ctx *DisableDiskClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateIndexClause(ctx *CreateIndexClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropIndexClause(ctx *DropIndexClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTableRenameClause(ctx *TableRenameClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSwapTableClause(ctx *SwapTableClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyCommentClause(ctx *ModifyCommentClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOptimizeRange(ctx *OptimizeRangeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOptimizeClause(ctx *OptimizeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddColumnClause(ctx *AddColumnClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddColumnsClause(ctx *AddColumnsClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropColumnClause(ctx *DropColumnClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyColumnClause(ctx *ModifyColumnClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnRenameClause(ctx *ColumnRenameClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitReorderColumnsClause(ctx *ReorderColumnsClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRollupRenameClause(ctx *RollupRenameClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCompactionClause(ctx *CompactionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubfieldName(ctx *SubfieldNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNestedFieldName(ctx *NestedFieldNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddFieldClause(ctx *AddFieldClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropFieldClause(ctx *DropFieldClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropBranchClause(ctx *DropBranchClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropTagClause(ctx *DropTagClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTableOperationClause(ctx *TableOperationClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTagOptions(ctx *TagOptionsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBranchOptions(ctx *BranchOptionsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSnapshotRetention(ctx *SnapshotRetentionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRefRetain(ctx *RefRetainContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMaxSnapshotAge(ctx *MaxSnapshotAgeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSnapshotId(ctx *SnapshotIdContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTimeUnit(ctx *TimeUnitContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInteger_list(ctx *Integer_listContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddPartitionClause(ctx *AddPartitionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropPartitionClause(ctx *DropPartitionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTruncatePartitionClause(ctx *TruncatePartitionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitModifyPartitionClause(ctx *ModifyPartitionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitReplacePartitionClause(ctx *ReplacePartitionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionRenameClause(ctx *PartitionRenameClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInsertStatement(ctx *InsertStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUpdateStatement(ctx *UpdateStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDeleteStatement(ctx *DeleteStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDataSource(ctx *DataSourceContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLoadProperties(ctx *LoadPropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColSeparatorProperty(ctx *ColSeparatorPropertyContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRowDelimiterProperty(ctx *RowDelimiterPropertyContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitImportColumns(ctx *ImportColumnsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnProperties(ctx *ColumnPropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitJobProperties(ctx *JobPropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDataSourceProperties(ctx *DataSourcePropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAnalyzeStatement(ctx *AnalyzeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRegularColumns(ctx *RegularColumnsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAllColumns(ctx *AllColumnsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPredicateColumns(ctx *PredicateColumnsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMultiColumnSet(ctx *MultiColumnSetContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropStatsStatement(ctx *DropStatsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitHistogramStatement(ctx *HistogramStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropHistogramStatement(ctx *DropHistogramStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateResourceStatement(ctx *CreateResourceStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterResourceStatement(ctx *AlterResourceStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropResourceStatement(ctx *DropResourceStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowResourceStatement(ctx *ShowResourceStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitClassifier(ctx *ClassifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowFunctionsStatement(ctx *ShowFunctionsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropFunctionStatement(ctx *DropFunctionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateFunctionStatement(ctx *CreateFunctionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInlineFunction(ctx *InlineFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTypeList(ctx *TypeListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLoadStatement(ctx *LoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLabelName(ctx *LabelNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDataDescList(ctx *DataDescListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDataDesc(ctx *DataDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitFormatProps(ctx *FormatPropsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBrokerDesc(ctx *BrokerDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitResourceDesc(ctx *ResourceDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowLoadStatement(ctx *ShowLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelLoadStatement(ctx *CancelLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterLoadStatement(ctx *AlterLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelCompactionStatement(ctx *CancelCompactionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowAuthorStatement(ctx *ShowAuthorStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowBackendsStatement(ctx *ShowBackendsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowBrokerStatement(ctx *ShowBrokerStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCharsetStatement(ctx *ShowCharsetStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCollationStatement(ctx *ShowCollationStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDeleteStatement(ctx *ShowDeleteStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowEventsStatement(ctx *ShowEventsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowEnginesStatement(ctx *ShowEnginesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowFrontendsStatement(ctx *ShowFrontendsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPluginsStatement(ctx *ShowPluginsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowOpenTableStatement(ctx *ShowOpenTableStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowProcedureStatement(ctx *ShowProcedureStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowProcStatement(ctx *ShowProcStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowProcesslistStatement(ctx *ShowProcesslistStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowProfilelistStatement(ctx *ShowProfilelistStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowStatusStatement(ctx *ShowStatusStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTabletStatement(ctx *ShowTabletStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTransactionStatement(ctx *ShowTransactionStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTriggersStatement(ctx *ShowTriggersStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowVariablesStatement(ctx *ShowVariablesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowWarningStatement(ctx *ShowWarningStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitHelpStatement(ctx *HelpStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDataSkewStatement(ctx *ShowDataSkewStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDataTypesStatement(ctx *ShowDataTypesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowSyncJobStatement(ctx *ShowSyncJobStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPolicyStatement(ctx *ShowPolicyStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowLastInsertStatement(ctx *ShowLastInsertStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTableIdStatement(ctx *ShowTableIdStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTableStatsStatement(ctx *ShowTableStatsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowTrashStatement(ctx *ShowTrashStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowMigrationsStatement(ctx *ShowMigrationsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowJobTaskStatement(ctx *ShowJobTaskStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateUserStatement(ctx *CreateUserStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropUserStatement(ctx *DropUserStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterUserStatement(ctx *AlterUserStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowUserStatement(ctx *ShowUserStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowAllAuthentication(ctx *ShowAllAuthenticationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExecuteAsStatement(ctx *ExecuteAsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateRoleStatement(ctx *CreateRoleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterRoleStatement(ctx *AlterRoleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropRoleStatement(ctx *DropRoleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowRolesStatement(ctx *ShowRolesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantRoleToUser(ctx *GrantRoleToUserContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantRoleToRole(ctx *GrantRoleToRoleContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetRoleStatement(ctx *SetRoleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantRevokeClause(ctx *GrantRevokeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantOnUser(ctx *GrantOnUserContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantOnTableBrief(ctx *GrantOnTableBriefContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantOnFunc(ctx *GrantOnFuncContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantOnSystem(ctx *GrantOnSystemContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGrantOnAll(ctx *GrantOnAllContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeOnUser(ctx *RevokeOnUserContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeOnFunc(ctx *RevokeOnFuncContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeOnSystem(ctx *RevokeOnSystemContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRevokeOnAll(ctx *RevokeOnAllContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowGrantsStatement(ctx *ShowGrantsStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAuthWithoutPlugin(ctx *AuthWithoutPluginContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAuthWithPlugin(ctx *AuthWithPluginContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivObjectName(ctx *PrivObjectNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivObjectNameList(ctx *PrivObjectNameListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivilegeTypeList(ctx *PrivilegeTypeListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivilegeType(ctx *PrivilegeTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivObjectType(ctx *PrivObjectTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBackupStatement(ctx *BackupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelBackupStatement(ctx *CancelBackupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowBackupStatement(ctx *ShowBackupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRestoreStatement(ctx *RestoreStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelRestoreStatement(ctx *CancelRestoreStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowRestoreStatement(ctx *ShowRestoreStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowSnapshotStatement(ctx *ShowSnapshotStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropRepositoryStatement(ctx *DropRepositoryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowWhiteListStatement(ctx *ShowWhiteListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDataCacheTarget(ctx *DataCacheTargetContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExportStatement(ctx *ExportStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCancelExportStatement(ctx *CancelExportStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowExportStatement(ctx *ShowExportStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInstallPluginStatement(ctx *InstallPluginStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUninstallPluginStatement(ctx *UninstallPluginStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateFileStatement(ctx *CreateFileStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropFileStatement(ctx *DropFileStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreatePipeStatement(ctx *CreatePipeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropPipeStatement(ctx *DropPipeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterPipeClause(ctx *AlterPipeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterPipeStatement(ctx *AlterPipeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDescPipeStatement(ctx *DescPipeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPipeStatement(ctx *ShowPipeStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetStatement(ctx *SetStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetNames(ctx *SetNamesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetPassword(ctx *SetPasswordContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetUserVar(ctx *SetUserVarContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetSystemVar(ctx *SetSystemVarContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetTransaction(ctx *SetTransactionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTransaction_characteristics(ctx *Transaction_characteristicsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTransaction_access_mode(ctx *Transaction_access_modeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIsolation_level(ctx *Isolation_levelContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIsolation_types(ctx *Isolation_typesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetExprOrDefault(ctx *SetExprOrDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRoleList(ctx *RoleListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExecuteScriptStatement(ctx *ExecuteScriptStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUnsupportedStatement(ctx *UnsupportedStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLock_item(ctx *Lock_itemContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLock_type(ctx *Lock_typeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropWarehouseStatement(ctx *DropWarehouseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetWarehouseStatement(ctx *SetWarehouseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowWarehousesStatement(ctx *ShowWarehousesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowClustersStatement(ctx *ShowClustersStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitShowNodesStatement(ctx *ShowNodesStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDropCNGroupStatement(ctx *DropCNGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBeginStatement(ctx *BeginStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCommitStatement(ctx *CommitStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRollbackStatement(ctx *RollbackStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTranslateStatement(ctx *TranslateStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDialect(ctx *DialectContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTranslateSQL(ctx *TranslateSQLContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQueryStatement(ctx *QueryStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQueryRelation(ctx *QueryRelationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitWithClause(ctx *WithClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQueryNoWith(ctx *QueryNoWithContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQueryPeriod(ctx *QueryPeriodContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPeriodType(ctx *PeriodTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQueryWithParentheses(ctx *QueryWithParenthesesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetOperation(ctx *SetOperationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubquery(ctx *SubqueryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRowConstructor(ctx *RowConstructorContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSortItem(ctx *SortItemContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLimitConstExpr(ctx *LimitConstExprContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLimitElement(ctx *LimitElementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQuerySpecification(ctx *QuerySpecificationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitFrom(ctx *FromContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDual(ctx *DualContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRollup(ctx *RollupContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCube(ctx *CubeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMultipleGroupingSets(ctx *MultipleGroupingSetsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSingleGroupingSet(ctx *SingleGroupingSetContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGroupingSet(ctx *GroupingSetContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCommonTableExpression(ctx *CommonTableExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSetQuantifier(ctx *SetQuantifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSelectSingle(ctx *SelectSingleContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSelectAll(ctx *SelectAllContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExcludeClause(ctx *ExcludeClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRelations(ctx *RelationsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRelationLateralView(ctx *RelationLateralViewContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLateralView(ctx *LateralViewContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGeneratorFunction(ctx *GeneratorFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRelation(ctx *RelationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTableAtom(ctx *TableAtomContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInlineTable(ctx *InlineTableContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubqueryWithAlias(ctx *SubqueryWithAliasContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTableFunction(ctx *TableFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNormalizedTableFunction(ctx *NormalizedTableFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitFileTableFunction(ctx *FileTableFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitParenthesizedRelation(ctx *ParenthesizedRelationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPivotClause(ctx *PivotClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPivotAggregationExpression(ctx *PivotAggregationExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPivotValue(ctx *PivotValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSampleClause(ctx *SampleClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArgumentList(ctx *ArgumentListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNamedArgumentList(ctx *NamedArgumentListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNamedArguments(ctx *NamedArgumentsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitJoinRelation(ctx *JoinRelationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBracketHint(ctx *BracketHintContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitHintMap(ctx *HintMapContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitJoinCriteria(ctx *JoinCriteriaContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnAliases(ctx *ColumnAliasesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionNames(ctx *PartitionNamesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitKeyPartitionList(ctx *KeyPartitionListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTabletList(ctx *TabletListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrepareStatement(ctx *PrepareStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPrepareSql(ctx *PrepareSqlContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExecuteStatement(ctx *ExecuteStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDeallocateStatement(ctx *DeallocateStatementContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitReplicaList(ctx *ReplicaListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExpressionOrDefault(ctx *ExpressionOrDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMapExpressionList(ctx *MapExpressionListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMapExpression(ctx *MapExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExpressionSingleton(ctx *ExpressionSingletonContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExpressionDefault(ctx *ExpressionDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLogicalNot(ctx *LogicalNotContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLogicalBinary(ctx *LogicalBinaryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExpressionList(ctx *ExpressionListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitComparison(ctx *ComparisonContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIsNull(ctx *IsNullContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitScalarSubquery(ctx *ScalarSubqueryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPredicate(ctx *PredicateContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTupleInSubquery(ctx *TupleInSubqueryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInSubquery(ctx *InSubqueryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInList(ctx *InListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBetween(ctx *BetweenContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLike(ctx *LikeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitValueExpressionDefault(ctx *ValueExpressionDefaultContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArithmeticBinary(ctx *ArithmeticBinaryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDereference(ctx *DereferenceContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMatchExpr(ctx *MatchExprContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnRef(ctx *ColumnRefContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitConvert(ctx *ConvertContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCollectionSubscript(ctx *CollectionSubscriptContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLiteral(ctx *LiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCast(ctx *CastContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUserVariableExpression(ctx *UserVariableExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSimpleCase(ctx *SimpleCaseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArrowExpression(ctx *ArrowExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArrayExpr(ctx *ArrayExprContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSystemVariableExpression(ctx *SystemVariableExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitConcat(ctx *ConcatContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubqueryExpression(ctx *SubqueryExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLambdaFunctionExpr(ctx *LambdaFunctionExprContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDictionaryGetExpr(ctx *DictionaryGetExprContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCollate(ctx *CollateContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArrayConstructor(ctx *ArrayConstructorContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMapConstructor(ctx *MapConstructorContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArraySlice(ctx *ArraySliceContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExists(ctx *ExistsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSearchedCase(ctx *SearchedCaseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArithmeticUnary(ctx *ArithmeticUnaryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNullLiteral(ctx *NullLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNumericLiteral(ctx *NumericLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDateLiteral(ctx *DateLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIntervalLiteral(ctx *IntervalLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBinaryLiteral(ctx *BinaryLiteralContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitParameter(ctx *ParameterContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExtract(ctx *ExtractContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitGroupingOperation(ctx *GroupingOperationContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInformationFunction(ctx *InformationFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSpecialDateTime(ctx *SpecialDateTimeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSpecialFunction(ctx *SpecialFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAggregationFunctionCall(ctx *AggregationFunctionCallContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitWindowFunctionCall(ctx *WindowFunctionCallContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTranslateFunctionCall(ctx *TranslateFunctionCallContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSimpleFunctionCall(ctx *SimpleFunctionCallContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAggregationFunction(ctx *AggregationFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUserVariable(ctx *UserVariableContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSystemVariable(ctx *SystemVariableContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitColumnReference(ctx *ColumnReferenceContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInformationFunctionExpression(ctx *InformationFunctionExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitWindowFunction(ctx *WindowFunctionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitWhenClause(ctx *WhenClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOver(ctx *OverContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIgnoreNulls(ctx *IgnoreNullsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitWindowFrame(ctx *WindowFrameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUnboundedFrame(ctx *UnboundedFrameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitCurrentRowBound(ctx *CurrentRowBoundContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBoundedFrame(ctx *BoundedFrameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTableDesc(ctx *TableDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExplainDesc(ctx *ExplainDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOptimizerTrace(ctx *OptimizerTraceContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionExpr(ctx *PartitionExprContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionDesc(ctx *PartitionDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitListPartitionDesc(ctx *ListPartitionDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMultiListPartitionValues(ctx *MultiListPartitionValuesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSingleListPartitionValues(ctx *SingleListPartitionValuesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitListPartitionValues(ctx *ListPartitionValuesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitListPartitionValue(ctx *ListPartitionValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitStringList(ctx *StringListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitLiteralExpressionList(ctx *LiteralExpressionListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRangePartitionDesc(ctx *RangePartitionDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSingleRangePartition(ctx *SingleRangePartitionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMultiRangePartition(ctx *MultiRangePartitionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionRangeDesc(ctx *PartitionRangeDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionKeyDesc(ctx *PartitionKeyDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionValueList(ctx *PartitionValueListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitKeyPartition(ctx *KeyPartitionContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPartitionValue(ctx *PartitionValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDistributionClause(ctx *DistributionClauseContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDistributionDesc(ctx *DistributionDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitRefreshSchemeDesc(ctx *RefreshSchemeDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitStatusDesc(ctx *StatusDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitProperties(ctx *PropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitExtProperties(ctx *ExtPropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitPropertyList(ctx *PropertyListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUserPropertyList(ctx *UserPropertyListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitProperty(ctx *PropertyContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInlineProperties(ctx *InlinePropertiesContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInlineProperty(ctx *InlinePropertyContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitVarType(ctx *VarTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitComment(ctx *CommentContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitOutfile(ctx *OutfileContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitFileFormat(ctx *FileFormatContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitString(ctx *StringContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBinary(ctx *BinaryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBooleanValue(ctx *BooleanValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitInterval(ctx *IntervalContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTaskInterval(ctx *TaskIntervalContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUnitIdentifier(ctx *UnitIdentifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUnitBoundary(ctx *UnitBoundaryContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitType(ctx *TypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitArrayType(ctx *ArrayTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitMapType(ctx *MapTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubfieldDesc(ctx *SubfieldDescContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitSubfieldDescs(ctx *SubfieldDescsContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitStructType(ctx *StructTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTypeParameter(ctx *TypeParameterContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBaseType(ctx *BaseTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDecimalType(ctx *DecimalTypeContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitQualifiedName(ctx *QualifiedNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitTableName(ctx *TableNameContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitWriteBranch(ctx *WriteBranchContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUnquotedIdentifier(ctx *UnquotedIdentifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDigitIdentifier(ctx *DigitIdentifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIdentifierWithAlias(ctx *IdentifierWithAliasContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIdentifierList(ctx *IdentifierListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIdentifierOrString(ctx *IdentifierOrStringContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIdentifierOrStringList(ctx *IdentifierOrStringListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUserWithoutHost(ctx *UserWithoutHostContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUserWithHost(ctx *UserWithHostContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAssignment(ctx *AssignmentContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitAssignmentList(ctx *AssignmentListContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDecimalValue(ctx *DecimalValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitDoubleValue(ctx *DoubleValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitIntegerValue(ctx *IntegerValueContext) interface{} { - return v.VisitChildren(ctx) -} - -func (v *BaseDorisSQLVisitor) VisitNonReserved(ctx *NonReservedContext) interface{} { - return v.VisitChildren(ctx) -} diff --git a/doris/examples/account_alter_user.sql b/doris/examples/account_alter_user.sql new file mode 100644 index 0000000..7f9a84d --- /dev/null +++ b/doris/examples/account_alter_user.sql @@ -0,0 +1,4 @@ +ALTER USER jack@'%' IDENTIFIED BY "12345"; +ALTER USER jack@'%' FAILED_LOGIN_ATTEMPTS 3 PASSWORD_LOCK_TIME 1 DAY; +ALTER USER jack@'%' ACCOUNT_UNLOCK; +ALTER USER jack@'%' COMMENT "this is my first user" diff --git a/doris/examples/account_create_user.sql b/doris/examples/account_create_user.sql new file mode 100644 index 0000000..adaa45c --- /dev/null +++ b/doris/examples/account_create_user.sql @@ -0,0 +1,9 @@ +CREATE USER 'jack'; +CREATE USER jack@'172.10.1.10' IDENTIFIED BY '123456'; +CREATE USER jack@'172.10.1.10' IDENTIFIED BY PASSWORD '*6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9'; +CREATE USER 'jack'@'192.168.%' DEFAULT ROLE 'example_role'; +CREATE USER 'jack'@'example_domain' IDENTIFIED BY '12345'; +CREATE USER 'jack'@'%' IDENTIFIED BY '12345' DEFAULT ROLE 'my_role'; +CREATE USER 'jack' IDENTIFIED BY '12345' PASSWORD_EXPIRE INTERVAL 10 DAY FAILED_LOGIN_ATTEMPTS 3 PASSWORD_LOCK_TIME 1 DAY; +CREATE USER 'jack' IDENTIFIED BY '12345' PASSWORD_HISTORY 8; +CREATE USER 'jack' COMMENT "this is my first user" diff --git a/doris/examples/account_drop_user.sql b/doris/examples/account_drop_user.sql new file mode 100644 index 0000000..01b60e6 --- /dev/null +++ b/doris/examples/account_drop_user.sql @@ -0,0 +1 @@ +DROP USER 'jack'@'192.%' diff --git a/doris/examples/account_grant.sql b/doris/examples/account_grant.sql new file mode 100644 index 0000000..f1fc7aa --- /dev/null +++ b/doris/examples/account_grant.sql @@ -0,0 +1,17 @@ +GRANT SELECT_PRIV ON *.*.* TO 'jack'@'%'; +GRANT SELECT_PRIV, ALTER_PRIV, LOAD_PRIV ON ctl1.db1.tbl1 TO 'jack'@'192.8.%'; +GRANT LOAD_PRIV ON ctl1.db1.* TO ROLE 'my_role'; +GRANT USAGE_PRIV ON RESOURCE * TO 'jack'@'%'; +GRANT USAGE_PRIV ON RESOURCE 'spark_resource' TO 'jack'@'%'; +GRANT USAGE_PRIV ON RESOURCE 'spark_resource' TO ROLE 'my_role'; +GRANT 'role1', 'role2' TO 'jack'@'%'; +GRANT USAGE_PRIV ON WORKLOAD GROUP 'g1' TO 'jack'@'%'; +GRANT USAGE_PRIV ON WORKLOAD GROUP '%' TO 'jack'@'%'; +GRANT USAGE_PRIV ON WORKLOAD GROUP 'g1' TO ROLE 'my_role'; +GRANT SHOW_VIEW_PRIV ON db1.view1 TO 'jack'@'%'; +GRANT USAGE_PRIV ON COMPUTE GROUP 'group1' TO 'jack'@'%'; +GRANT USAGE_PRIV ON COMPUTE GROUP 'group1' TO ROLE 'my_role'; +GRANT USAGE_PRIV ON COMPUTE GROUP '*' TO 'jack'@'%'; +GRANT USAGE_PRIV ON STORAGE VAULT 'vault1' TO 'jack'@'%'; +GRANT USAGE_PRIV ON STORAGE VAULT 'vault1' TO ROLE 'my_role'; +GRANT USAGE_PRIV ON STORAGE VAULT '*' TO 'jack'@'%' diff --git a/doris/examples/account_revoke.sql b/doris/examples/account_revoke.sql new file mode 100644 index 0000000..dea8b3e --- /dev/null +++ b/doris/examples/account_revoke.sql @@ -0,0 +1,10 @@ +REVOKE SELECT_PRIV ON db1.* FROM 'jack'@'192.%'; +REVOKE USAGE_PRIV ON RESOURCE 'spark_resource' FROM 'jack'@'192.%'; +REVOKE 'role1', 'role2' FROM 'jack'@'192.%'; +REVOKE USAGE_PRIV ON WORKLOAD GROUP 'g1' FROM 'jack'@'%'; +REVOKE USAGE_PRIV ON WORKLOAD GROUP '%' FROM 'jack'@'%'; +REVOKE USAGE_PRIV ON COMPUTE GROUP 'group1' FROM 'jack'@'%'; +REVOKE USAGE_PRIV ON COMPUTE GROUP 'group1' FROM ROLE 'my_role'; +REVOKE USAGE_PRIV ON STORAGE VAULT 'vault1' FROM 'jack'@'%'; +REVOKE USAGE_PRIV ON STORAGE VAULT 'vault1' FROM ROLE 'my_role'; +REVOKE USAGE_PRIV ON STORAGE VAULT '%' FROM 'jack'@'%'; \ No newline at end of file diff --git a/doris/examples/account_role.sql b/doris/examples/account_role.sql new file mode 100644 index 0000000..0b20c62 --- /dev/null +++ b/doris/examples/account_role.sql @@ -0,0 +1,4 @@ +CREATE ROLE role1; +CREATE ROLE role2 COMMENT "this is my first role"; +DROP ROLE role1; +DROP ROLE IF EXISTS role1 diff --git a/doris/examples/account_set_password.sql b/doris/examples/account_set_password.sql new file mode 100644 index 0000000..cca144e --- /dev/null +++ b/doris/examples/account_set_password.sql @@ -0,0 +1,4 @@ +SET PASSWORD = PASSWORD('123456'); +SET PASSWORD = '*6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9'; +SET PASSWORD FOR 'jack'@'192.%' = PASSWORD('123456'); +SET PASSWORD FOR 'jack'@'domain' = '*6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9' diff --git a/doris/examples/account_show.sql b/doris/examples/account_show.sql new file mode 100644 index 0000000..7c4f8dd --- /dev/null +++ b/doris/examples/account_show.sql @@ -0,0 +1,4 @@ +SHOW ALL GRANTS; +SHOW GRANTS FOR jack@'%'; +SHOW GRANTS; +SHOW ROLES diff --git a/doris/examples/async_materialized_view.sql b/doris/examples/async_materialized_view.sql new file mode 100644 index 0000000..558b852 --- /dev/null +++ b/doris/examples/async_materialized_view.sql @@ -0,0 +1,38 @@ +CREATE MATERIALIZED VIEW complete_mv (orderdate COMMENT 'Order date', orderkey COMMENT 'Order key', partkey COMMENT 'Part key') +BUILD IMMEDIATE +REFRESH AUTO +ON SCHEDULE EVERY 1 DAY STARTS '2024-12-01 20:30:00' +DISTRIBUTED BY HASH (orderkey) BUCKETS 2 +PROPERTIES("replication_num" = "1") +AS +SELECT + o_orderdate, + l_orderkey, + l_partkey +FROM orders +LEFT JOIN lineitem ON l_orderkey = o_orderkey +LEFT JOIN partsupp ON ps_partkey = l_partkey AND l_suppkey = ps_suppkey; + +CREATE MATERIALIZED VIEW partition_mv +BUILD IMMEDIATE +REFRESH AUTO +ON SCHEDULE EVERY 1 DAY STARTS '2024-12-01 20:30:00' +PARTITION BY (DATE_TRUNC(o_orderdate, 'MONTH')) +DISTRIBUTED BY HASH (l_orderkey) BUCKETS 2 +PROPERTIES("replication_num" = "3") +AS +SELECT + o_orderdate, + l_orderkey, + l_partkey +FROM orders +LEFT JOIN lineitem ON l_orderkey = o_orderkey +LEFT JOIN partsupp ON ps_partkey = l_partkey AND l_suppkey = ps_suppkey; + +ALTER MATERIALIZED VIEW partition_mv SET ("grace_period" = "10", "excluded_trigger_tables" = "lineitem,partsupp"); +ALTER MATERIALIZED VIEW partition_mv REFRESH COMPLETE; +DROP MATERIALIZED VIEW mv1; +DROP MATERIALIZED VIEW IF EXISTS db1.mv1; +REFRESH MATERIALIZED VIEW mv1 AUTO; +REFRESH MATERIALIZED VIEW mv1 PARTITIONS(p_19950801_19950901, p_19950901_19951001); +REFRESH MATERIALIZED VIEW mv1 COMPLETE diff --git a/doris/examples/catalog_alter.sql b/doris/examples/catalog_alter.sql new file mode 100644 index 0000000..c347725 --- /dev/null +++ b/doris/examples/catalog_alter.sql @@ -0,0 +1,3 @@ +ALTER CATALOG ctlg_hive RENAME hive; +ALTER CATALOG hive SET PROPERTIES ('hive.metastore.uris'='thrift://172.21.0.1:9083'); +ALTER CATALOG hive MODIFY COMMENT "new catalog comment" diff --git a/doris/examples/catalog_create.sql b/doris/examples/catalog_create.sql new file mode 100644 index 0000000..7a0fae5 --- /dev/null +++ b/doris/examples/catalog_create.sql @@ -0,0 +1,77 @@ +CREATE CATALOG hive COMMENT 'hive catalog' PROPERTIES ( + 'type'='hms', + 'hive.metastore.uris' = 'thrift://127.0.0.1:7004', + 'dfs.nameservices'='HANN', + 'dfs.ha.namenodes.HANN'='nn1,nn2', + 'dfs.namenode.rpc-address.HANN.nn1'='nn1_host:rpc_port', + 'dfs.namenode.rpc-address.HANN.nn2'='nn2_host:rpc_port', + 'dfs.client.failover.proxy.provider.HANN'='org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider' +); +CREATE CATALOG es PROPERTIES ( + "type"="es", + "hosts"="http://127.0.0.1:9200" +); +CREATE CATALOG jdbc PROPERTIES ( + "type"="jdbc", + "user"="root", + "password"="123456", + "jdbc_url" = "jdbc:mysql://127.0.0.1:3316/doris_test?useSSL=false", + "driver_url" = "https://doris-community-test-1308700295.cos.ap-hongkong.myqcloud.com/jdbc_driver/mysql-connector-java-8.0.25.jar", + "driver_class" = "com.mysql.cj.jdbc.Driver" +); +CREATE CATALOG jdbc_pg PROPERTIES ( + "type"="jdbc", + "user"="postgres", + "password"="123456", + "jdbc_url" = "jdbc:postgresql://127.0.0.1:5432/demo", + "driver_url" = "file:///path/to/postgresql-42.5.1.jar", + "driver_class" = "org.postgresql.Driver" +); +CREATE CATALOG jdbc_clickhouse PROPERTIES ( + "type"="jdbc", + "user"="default", + "password"="123456", + "jdbc_url" = "jdbc:clickhouse://127.0.0.1:8123/demo", + "driver_url" = "file:///path/to/clickhouse-jdbc-0.3.2-patch11-all.jar", + "driver_class" = "com.clickhouse.jdbc.ClickHouseDriver" +); +CREATE CATALOG jdbc_oracle PROPERTIES ( + "type"="jdbc", + "user"="doris", + "password"="123456", + "jdbc_url" = "jdbc:oracle:thin:@127.0.0.1:1521:helowin", + "driver_url" = "file:///path/to/ojdbc8.jar", + "driver_class" = "oracle.jdbc.driver.OracleDriver" +); +CREATE CATALOG sqlserver_catalog PROPERTIES ( + "type"="jdbc", + "user"="SA", + "password"="Doris123456", + "jdbc_url" = "jdbc:sqlserver://localhost:1433;DataBaseName=doris_test", + "driver_url" = "file:///path/to/mssql-jdbc-11.2.3.jre8.jar", + "driver_class" = "com.microsoft.sqlserver.jdbc.SQLServerDriver" +); +CREATE CATALOG saphana_catalog PROPERTIES ( + "type"="jdbc", + "user"="SYSTEM", + "password"="SAPHANA", + "jdbc_url" = "jdbc:sap://localhost:31515/TEST", + "driver_url" = "file:///path/to/ngdbc.jar", + "driver_class" = "com.sap.db.jdbc.Driver" +); +CREATE CATALOG trino_catalog PROPERTIES ( + "type"="jdbc", + "user"="hadoop", + "password"="", + "jdbc_url" = "jdbc:trino://localhost:8080/hive", + "driver_url" = "file:///path/to/trino-jdbc-389.jar", + "driver_class" = "io.trino.jdbc.TrinoDriver" +); +CREATE CATALOG oceanbase_catalog PROPERTIES ( + "type"="jdbc", + "user"="root", + "password"="", + "jdbc_url" = "jdbc:oceanbase://localhost:2881/demo", + "driver_url" = "file:///path/to/oceanbase-client-2.4.2.jar", + "driver_class" = "com.oceanbase.jdbc.Driver" +) diff --git a/doris/examples/catalog_drop.sql b/doris/examples/catalog_drop.sql new file mode 100644 index 0000000..a70fb6f --- /dev/null +++ b/doris/examples/catalog_drop.sql @@ -0,0 +1,2 @@ +DROP CATALOG hive; +DROP CATALOG IF EXISTS hive diff --git a/doris/examples/catalog_show.sql b/doris/examples/catalog_show.sql new file mode 100644 index 0000000..5acc7b7 --- /dev/null +++ b/doris/examples/catalog_show.sql @@ -0,0 +1,3 @@ +SHOW CATALOGS; +SHOW CATALOGS LIKE 'hi%'; +SHOW CREATE CATALOG oracle diff --git a/doris/examples/cluster_backend.sql b/doris/examples/cluster_backend.sql new file mode 100644 index 0000000..56bface --- /dev/null +++ b/doris/examples/cluster_backend.sql @@ -0,0 +1,12 @@ +ALTER SYSTEM ADD BACKEND "192.168.0.1:9050,192.168.0.2:9050"; +ALTER SYSTEM ADD BACKEND "doris-be01:9050" PROPERTIES ("tag.location" = "groupb"); +ALTER SYSTEM ADD BACKEND "192.168.0.3:9050" PROPERTIES ("tag.compute_group_name" = "cloud_groupc"); +ALTER SYSTEM DROP BACKEND "192.168.0.1:9050", "192.168.0.2:9050"; +ALTER SYSTEM DROP BACKEND "10002"; +SHOW BACKENDS; +SELECT * FROM BACKENDS(); +ALTER SYSTEM DECOMMISSION BACKEND "192.168.0.1:9050", "192.168.0.2:9050"; +ALTER SYSTEM DECOMMISSION BACKEND "10002"; +ALTER SYSTEM MODIFY BACKEND "127.0.0.1:9050" SET ("tag.location" = "group_a"); +ALTER SYSTEM MODIFY BACKEND "10002" SET ("disable_query" = "true"); +ALTER SYSTEM MODIFY BACKEND "127.0.0.1:9050" SET ("disable_load" = "true") diff --git a/doris/examples/cluster_broker.sql b/doris/examples/cluster_broker.sql new file mode 100644 index 0000000..d4552b0 --- /dev/null +++ b/doris/examples/cluster_broker.sql @@ -0,0 +1,5 @@ +ALTER SYSTEM ADD BROKER broker_name "host1:port", "host2:port"; +ALTER SYSTEM ADD BROKER broker_fqdn1 "broker_fqdn1:port"; +ALTER SYSTEM DROP ALL BROKER broker_name; +ALTER SYSTEM DROP BROKER broker_name "10.10.10.1:8000"; +SHOW BROKER diff --git a/doris/examples/cluster_frontend.sql b/doris/examples/cluster_frontend.sql new file mode 100644 index 0000000..5c8e537 --- /dev/null +++ b/doris/examples/cluster_frontend.sql @@ -0,0 +1,3 @@ +SHOW FRONTENDS; +SELECT * FROM FRONTENDS(); +ALTER SYSTEM ADD OBSERVER "host_ip:9010" diff --git a/doris/examples/cluster_resource.sql b/doris/examples/cluster_resource.sql new file mode 100644 index 0000000..d37f3fd --- /dev/null +++ b/doris/examples/cluster_resource.sql @@ -0,0 +1,66 @@ +CREATE EXTERNAL RESOURCE "spark0" +PROPERTIES( + "type" = "spark", + "spark.master" = "yarn", + "spark.submit.deployMode" = "cluster", + "spark.jars" = "xxx.jar,yyy.jar", + "spark.files" = "/tmp/aaa,/tmp/bbb", + "spark.executor.memory" = "1g", + "spark.yarn.queue" = "queue0", + "spark.hadoop.yarn.resourcemanager.address" = "127.0.0.1:9999", + "spark.hadoop.fs.defaultFS" = "hdfs://127.0.0.1:10000", + "working_dir" = "hdfs://127.0.0.1:10000/tmp/doris", + "broker" = "broker0", + "broker.username" = "user0", + "broker.password" = "password0" +); +CREATE EXTERNAL RESOURCE `oracle_odbc` +PROPERTIES ( + "type" = "odbc_catalog", + "host" = "192.168.0.1", + "port" = "8086", + "user" = "test", + "password" = "test", + "database" = "test", + "odbc_type" = "oracle", + "driver" = "Oracle 19 ODBC driver" +); +CREATE RESOURCE "remote_s3" +PROPERTIES( + "type" = "s3", + "s3.endpoint" = "bj.s3.com", + "s3.region" = "bj", + "s3.access_key" = "bbb", + "s3.secret_key" = "aaaa", + "s3.connection.maximum" = "50", + "s3.connection.request.timeout" = "3000", + "s3.connection.timeout" = "1000" +); +CREATE RESOURCE mysql_resource PROPERTIES ( + "type"="jdbc", + "user"="root", + "password"="123456", + "jdbc_url" = "jdbc:mysql://127.0.0.1:3316/doris_test?useSSL=false", + "driver_url" = "https://doris-community-test-1308700295.cos.ap-hongkong.myqcloud.com/jdbc_driver/mysql-connector-java-8.0.25.jar", + "driver_class" = "com.mysql.cj.jdbc.Driver" +); +CREATE RESOURCE hdfs_resource PROPERTIES ( + "type"="hdfs", + "hadoop.username"="user", + "dfs.nameservices" = "my_ha", + "dfs.ha.namenodes.my_ha" = "my_namenode1, my_namenode2", + "dfs.namenode.rpc-address.my_ha.my_namenode1" = "nn1_host:rpc_port", + "dfs.namenode.rpc-address.my_ha.my_namenode2" = "nn2_host:rpc_port", + "dfs.client.failover.proxy.provider.my_ha" = "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider" +); +CREATE RESOURCE es_resource PROPERTIES ( + "type"="es", + "hosts"="http://127.0.0.1:29200", + "nodes_discovery"="false", + "enable_keyword_sniff"="true" +); +DROP RESOURCE 'spark0'; +SHOW RESOURCES; +SHOW RESOURCES WHERE NAME LIKE "2014_01_02" LIMIT 10; +SHOW RESOURCES WHERE NAME = "20140102" ORDER BY `KEY` DESC; +SHOW RESOURCES LIKE "jdbc%" diff --git a/doris/examples/cluster_storage_policy.sql b/doris/examples/cluster_storage_policy.sql new file mode 100644 index 0000000..e8c2e1f --- /dev/null +++ b/doris/examples/cluster_storage_policy.sql @@ -0,0 +1,11 @@ +CREATE STORAGE POLICY testPolicy +PROPERTIES( + "storage_resource" = "s3", + "cooldown_datetime" = "2022-06-08 00:00:00" +); +CREATE STORAGE POLICY testPolicy +PROPERTIES( + "storage_resource" = "s3", + "cooldown_ttl" = "1d" +); +DROP STORAGE POLICY policy1 diff --git a/doris/examples/cluster_storage_vault.sql b/doris/examples/cluster_storage_vault.sql new file mode 100644 index 0000000..a41ca2a --- /dev/null +++ b/doris/examples/cluster_storage_vault.sql @@ -0,0 +1,80 @@ +CREATE STORAGE VAULT IF NOT EXISTS hdfs_vault_demo PROPERTIES ( + "type" = "hdfs", + "fs.defaultFS" = "hdfs://127.0.0.1:8020", + "path_prefix" = "big/data", + "hadoop.username" = "user", + "hadoop.security.authentication" = "kerberos", + "hadoop.kerberos.principal" = "hadoop/127.0.0.1@XXX", + "hadoop.kerberos.keytab" = "/etc/emr.keytab" +); +CREATE STORAGE VAULT IF NOT EXISTS oss_demo_vault PROPERTIES ( + "type" = "S3", + "s3.endpoint" = "oss-cn-beijing.aliyuncs.com", + "s3.access_key" = "xxxxxx", + "s3.secret_key" = "xxxxxx", + "s3.region" = "cn-beijing", + "s3.root.path" = "oss_demo_vault_prefix", + "s3.bucket" = "xxxxxx", + "provider" = "OSS", + "use_path_style" = "false" +); +CREATE STORAGE VAULT IF NOT EXISTS cos_demo_vault PROPERTIES ( + "type" = "S3", + "s3.endpoint" = "cos.ap-guangzhou.myqcloud.com", + "s3.access_key" = "xxxxxx", + "s3.secret_key" = "xxxxxx", + "s3.region" = "ap-guangzhou", + "s3.root.path" = "cos_demo_vault_prefix", + "s3.bucket" = "xxxxxx", + "provider" = "COS", + "use_path_style" = "false" +); +CREATE STORAGE VAULT IF NOT EXISTS s3_demo_vault PROPERTIES ( + "type" = "S3", + "s3.endpoint" = "s3.us-east-1.amazonaws.com", + "s3.access_key" = "xxxxxx", + "s3.secret_key" = "xxxxxx", + "s3.region" = "us-east-1", + "s3.root.path" = "s3_demo_vault_prefix", + "s3.bucket" = "xxxxxx", + "provider" = "S3", + "use_path_style" = "false" +); +CREATE STORAGE VAULT IF NOT EXISTS minio_demo_vault PROPERTIES ( + "type" = "S3", + "s3.endpoint" = "127.0.0.1:9000", + "s3.access_key" = "xxxxxx", + "s3.secret_key" = "xxxxxx", + "s3.region" = "us-east-1", + "s3.root.path" = "minio_demo_vault_prefix", + "s3.bucket" = "xxxxxx", + "provider" = "S3", + "use_path_style" = "true" +); +CREATE STORAGE VAULT IF NOT EXISTS azure_demo_vault PROPERTIES ( + "type" = "S3", + "s3.endpoint" = "blob.core.windows.net", + "s3.access_key" = "xxxxxx", + "s3.secret_key" = "xxxxxx", + "s3.region" = "us-east-1", + "s3.root.path" = "azure_demo_vault_prefix", + "s3.bucket" = "xxxxxx", + "provider" = "AZURE" +); +CREATE STORAGE VAULT IF NOT EXISTS gcp_demo_vault PROPERTIES ( + "type" = "S3", + "s3.endpoint" = "storage.googleapis.com", + "s3.access_key" = "xxxxxx", + "s3.secret_key" = "xxxxxx", + "s3.region" = "us-east-1", + "s3.root.path" = "gcp_demo_vault_prefix", + "s3.bucket" = "xxxxxx", + "provider" = "GCP" +); +ALTER STORAGE VAULT old_vault_name PROPERTIES ( + "type"="S3", + "VAULT_NAME" = "new_vault_name", + "s3.access_key" = "new_ak" +); +SHOW STORAGE VAULTS; +SHOW COMPUTE GROUPS diff --git a/doris/examples/cluster_workload_group.sql b/doris/examples/cluster_workload_group.sql new file mode 100644 index 0000000..c04b043 --- /dev/null +++ b/doris/examples/cluster_workload_group.sql @@ -0,0 +1,11 @@ +CREATE WORKLOAD GROUP IF NOT EXISTS g1 PROPERTIES ( + "max_cpu_percent"="10%", + "max_memory_percent"="30%" +); +ALTER WORKLOAD GROUP g1 PROPERTIES ( + "max_cpu_percent"="20%", + "max_memory_percent"="40%" +); +DROP WORKLOAD GROUP IF EXISTS g1; +SHOW WORKLOAD GROUPS; +SHOW WORKLOAD GROUPS LIKE "normal%" diff --git a/doris/examples/data_query_select.sql b/doris/examples/data_query_select.sql new file mode 100644 index 0000000..9a4781d --- /dev/null +++ b/doris/examples/data_query_select.sql @@ -0,0 +1,27 @@ +SELECT Name FROM student WHERE age IN (18,20,25); +SELECT * EXCEPT(age) FROM student; +SELECT type, AVG(price) FROM tb_book GROUP BY type; +SELECT DISTINCT type FROM tb_book; +SELECT * FROM tb_book ORDER BY id DESC LIMIT 3; +SELECT * FROM tb_book WHERE name LIKE('_h%'); +SELECT * FROM tb_book ORDER BY price DESC LIMIT 3; +SELECT id, CONCAT(name, ":", price) AS info, type FROM tb_book; +SELECT SUM(price) AS total, type FROM tb_book GROUP BY type; +SELECT *, (price * 0.8) AS "20%" FROM tb_book; +WITH cte AS (SELECT 1 AS col1, 2 AS col2 UNION ALL SELECT 3, 4) SELECT col1, col2 FROM cte; +SELECT * FROM t1 LEFT JOIN (t2, t3, t4) ON (t2.a = t1.a AND t3.b = t1.b AND t4.c = t1.c); +SELECT * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4) ON (t2.a = t1.a AND t3.b = t1.b AND t4.c = t1.c); +SELECT t1.name, t2.salary FROM employee AS t1 INNER JOIN info AS t2 ON t1.name = t2.name; +SELECT t1.name, t2.salary FROM employee t1 INNER JOIN info t2 ON t1.name = t2.name; +SELECT left_tbl.* FROM left_tbl LEFT JOIN right_tbl ON left_tbl.id = right_tbl.id WHERE right_tbl.id IS NULL; +SELECT * FROM t1 RIGHT JOIN t2 ON (t1.a = t2.a); +SELECT * FROM t1 TABLET(10001) TABLESAMPLE(1000 ROWS) REPEATABLE 2 LIMIT 1000; +SELECT college, region, seed FROM tournament ORDER BY region, seed; +SELECT college, region AS r, seed AS s FROM tournament ORDER BY r, s; +SELECT college, region, seed FROM tournament ORDER BY 2, 3; +SELECT a, COUNT(b) FROM test_table GROUP BY a ORDER BY NULL; +SELECT COUNT(col1) AS col2 FROM t GROUP BY col2 HAVING col2 = 2; +SELECT user, MAX(salary) FROM users GROUP BY user HAVING MAX(salary) > 10; +SELECT * FROM tbl LIMIT 5, 10; +SELECT * FROM tbl LIMIT 95, 18446744073709551615; +SELECT * FROM (SELECT age FROM student_01 UNION ALL SELECT age FROM student_02) AS t1 ORDER BY age LIMIT 4 diff --git a/doris/examples/ddl_alter_table_column.sql b/doris/examples/ddl_alter_table_column.sql new file mode 100644 index 0000000..70ee051 --- /dev/null +++ b/doris/examples/ddl_alter_table_column.sql @@ -0,0 +1,12 @@ +ALTER TABLE example_db.my_table ADD COLUMN new_col INT KEY DEFAULT "0" AFTER key_1; +ALTER TABLE example_db.my_table ADD COLUMN new_col INT DEFAULT "0" AFTER value_1; +ALTER TABLE example_db.my_table ADD COLUMN new_col INT SUM DEFAULT "0" AFTER value_1; +ALTER TABLE example_db.my_table ADD COLUMN new_col INT KEY DEFAULT "0" FIRST; +ALTER TABLE example_db.my_table ADD COLUMN (new_col1 INT SUM DEFAULT "0", new_col2 INT SUM DEFAULT "0"); +ALTER TABLE example_db.my_table ADD COLUMN (new_col1 INT KEY DEFAULT "0", new_col2 INT DEFAULT "0"); +ALTER TABLE example_db.my_table DROP COLUMN col1; +ALTER TABLE example_db.my_table MODIFY COLUMN col1 BIGINT KEY DEFAULT "1" AFTER col2; +ALTER TABLE example_db.my_table MODIFY COLUMN val1 VARCHAR(64) REPLACE DEFAULT "abc"; +ALTER TABLE example_db.my_table MODIFY COLUMN k3 VARCHAR(50) KEY NULL COMMENT 'to 50'; +ALTER TABLE example_db.my_table ORDER BY (k_2, k_1, v_3, v_2, v_1); +ALTER TABLE example_db.my_table ADD COLUMN col INT DEFAULT "0" AFTER v_1, ORDER BY (k_2, k_1, v_3, v_2, v_1, col) diff --git a/doris/examples/ddl_alter_table_partition.sql b/doris/examples/ddl_alter_table_partition.sql new file mode 100644 index 0000000..9f9ec2a --- /dev/null +++ b/doris/examples/ddl_alter_table_partition.sql @@ -0,0 +1,9 @@ +ALTER TABLE example_db.my_table ADD PARTITION p1 VALUES LESS THAN ("2014-01-01"); +ALTER TABLE example_db.my_table ADD PARTITION p1 VALUES LESS THAN ("2015-01-01") DISTRIBUTED BY HASH(k1) BUCKETS 20; +ALTER TABLE example_db.my_table ADD PARTITION p1 VALUES LESS THAN ("2015-01-01") ("replication_num" = "1"); +ALTER TABLE example_db.my_table MODIFY PARTITION p1 SET("replication_num" = "1"); +ALTER TABLE example_db.my_table MODIFY PARTITION (p1, p2, p4) SET("replication_num" = "1"); +ALTER TABLE example_db.my_table MODIFY PARTITION (*) SET("storage_medium" = "HDD"); +ALTER TABLE example_db.my_table DROP PARTITION p1; +ALTER TABLE example_db.my_table DROP PARTITION p1, DROP PARTITION p2, DROP PARTITION p3; +ALTER TABLE example_db.my_table ADD PARTITION p1 VALUES [("2014-01-01"), ("2014-02-01")) diff --git a/doris/examples/ddl_alter_table_property.sql b/doris/examples/ddl_alter_table_property.sql new file mode 100644 index 0000000..9c2eb3b --- /dev/null +++ b/doris/examples/ddl_alter_table_property.sql @@ -0,0 +1,18 @@ +ALTER TABLE example_db.my_table SET ("bloom_filter_columns"="k1,k2,k3"); +ALTER TABLE example_db.my_table SET ("colocate_with" = "t1"); +ALTER TABLE example_db.my_table SET ("distribution_type" = "random"); +ALTER TABLE example_db.my_table SET ("dynamic_partition.enable" = "false"); +ALTER TABLE example_db.my_table SET ("dynamic_partition.enable" = "true", "dynamic_partition.time_unit" = "DAY", "dynamic_partition.end" = "3", "dynamic_partition.prefix" = "p", "dynamic_partition.buckets" = "32"); +ALTER TABLE example_db.my_table SET ("in_memory" = "false"); +ALTER TABLE example_db.my_table ENABLE FEATURE "BATCH_DELETE"; +ALTER TABLE example_db.my_table ENABLE FEATURE "SEQUENCE_LOAD" WITH PROPERTIES ("function_column.sequence_type" = "Date"); +ALTER TABLE example_db.my_table MODIFY DISTRIBUTION DISTRIBUTED BY HASH(k1) BUCKETS 50; +ALTER TABLE example_db.my_table MODIFY COMMENT "new comment"; +ALTER TABLE example_db.my_table MODIFY COLUMN k1 COMMENT "k1", MODIFY COLUMN k2 COMMENT "k2"; +ALTER TABLE example_db.mysql_table SET ("replication_num" = "2"); +ALTER TABLE example_db.mysql_table SET ("default.replication_num" = "2"); +ALTER TABLE example_db.mysql_table SET ("replication_allocation" = "tag.location.default: 1"); +ALTER TABLE example_db.mysql_table SET ("default.replication_allocation" = "tag.location.default: 1"); +ALTER TABLE example_db.mysql_table SET ("light_schema_change" = "true"); +ALTER TABLE create_table_not_have_policy SET ("storage_policy" = "created_create_table_alter_policy"); +ALTER TABLE create_table_partition MODIFY PARTITION (*) SET("storage_policy"="created_create_table_partition_alter_policy") diff --git a/doris/examples/ddl_alter_table_rename.sql b/doris/examples/ddl_alter_table_rename.sql new file mode 100644 index 0000000..b7ae2f1 --- /dev/null +++ b/doris/examples/ddl_alter_table_rename.sql @@ -0,0 +1,4 @@ +ALTER TABLE table1 RENAME table2; +ALTER TABLE example_table RENAME ROLLUP rollup1 rollup2; +ALTER TABLE example_table RENAME PARTITION p1 p2; +ALTER TABLE example_table RENAME COLUMN c1 c2 diff --git a/doris/examples/ddl_alter_table_replace.sql b/doris/examples/ddl_alter_table_replace.sql new file mode 100644 index 0000000..7ef0465 --- /dev/null +++ b/doris/examples/ddl_alter_table_replace.sql @@ -0,0 +1,3 @@ +ALTER TABLE tbl1 REPLACE WITH TABLE tbl2; +ALTER TABLE tbl1 REPLACE WITH TABLE tbl2 PROPERTIES('swap' = 'true'); +ALTER TABLE tbl1 REPLACE WITH TABLE tbl2 PROPERTIES('swap' = 'false') diff --git a/doris/examples/ddl_alter_table_rollup.sql b/doris/examples/ddl_alter_table_rollup.sql new file mode 100644 index 0000000..ed427fd --- /dev/null +++ b/doris/examples/ddl_alter_table_rollup.sql @@ -0,0 +1,12 @@ +ALTER TABLE example_db.my_table +ADD ROLLUP example_rollup_index(k1, k3, v1, v2); +ALTER TABLE example_db.my_table +ADD ROLLUP example_rollup_index2 (k1, v1) +FROM example_rollup_index; +ALTER TABLE example_db.my_table +ADD ROLLUP example_rollup_index(k1, k3, v1) +PROPERTIES("timeout" = "3600"); +ALTER TABLE example_db.my_table +DROP ROLLUP example_rollup_index2; +ALTER TABLE example_db.my_table +DROP ROLLUP example_rollup_index2,example_rollup_index3 diff --git a/doris/examples/ddl_create_table.sql b/doris/examples/ddl_create_table.sql new file mode 100644 index 0000000..e107a67 --- /dev/null +++ b/doris/examples/ddl_create_table.sql @@ -0,0 +1,18 @@ +CREATE TABLE t1(c1 INT, c2 STRING) DUPLICATE KEY(c1) DISTRIBUTED BY HASH(c1) PROPERTIES ('replication_num' = '1'); +CREATE TABLE t2(c1 INT, c2 INT MAX) AGGREGATE KEY(c1) DISTRIBUTED BY HASH(c1) PROPERTIES ('replication_num' = '1'); +CREATE TABLE t3(c1 INT, c2 INT) UNIQUE KEY(c1) DISTRIBUTED BY HASH(c1) PROPERTIES ('replication_num' = '1'); +CREATE TABLE t4(c1 INT, c2 INT GENERATED ALWAYS AS (c1 + 1)) DUPLICATE KEY(c1) DISTRIBUTED BY HASH(c1) PROPERTIES ('replication_num' = '1'); +CREATE TABLE t5(c1 INT, c2 INT DEFAULT 10) DUPLICATE KEY(c1) DISTRIBUTED BY HASH(c1) PROPERTIES ('replication_num' = '1'); +CREATE TABLE t6(c1 INT, c2 INT) DUPLICATE KEY(c1) DISTRIBUTED BY RANDOM PROPERTIES ('replication_num' = '1'); +CREATE TABLE t7(c1 INT, c2 DATETIME NOT NULL) DUPLICATE KEY(c1) AUTO PARTITION BY RANGE(date_trunc(c2, 'day')) () DISTRIBUTED BY RANDOM PROPERTIES ('replication_num' = '1'); +CREATE TABLE t8(c1 INT, c2 DATETIME NOT NULL) DUPLICATE KEY(c1) PARTITION BY RANGE(c2) (FROM ('2020-01-01') TO ('2020-01-10') INTERVAL 1 DAY) DISTRIBUTED BY RANDOM PROPERTIES ('replication_num' = '1'); +CREATE TABLE t9(c1 INT, c2 DATE NOT NULL) DUPLICATE KEY(c1) PARTITION BY LIST(c2) (PARTITION p1 VALUES IN (('2020-01-01'), ('2020-01-02'))) DISTRIBUTED BY RANDOM PROPERTIES ('replication_num' = '1'); +CREATE TABLE example_db.table_hash(k1 BIGINT, k2 LARGEINT, v1 VARCHAR(2048), v2 SMALLINT DEFAULT "10") UNIQUE KEY(k1, k2) DISTRIBUTED BY HASH(k1, k2) BUCKETS 32 PROPERTIES("storage_medium" = "SSD", "storage_cooldown_time" = "2015-06-04 00:00:00"); +CREATE TABLE IF NOT EXISTS create_table_use_created_policy (k1 BIGINT, k2 LARGEINT, v1 VARCHAR(2048)) UNIQUE KEY(k1) DISTRIBUTED BY HASH(k1) BUCKETS 3 PROPERTIES("storage_policy" = "test_create_table_use_policy", "replication_num" = "1"); +CREATE TABLE t1 (id INT COMMENT "", value VARCHAR(8) COMMENT "") DUPLICATE KEY(id) DISTRIBUTED BY HASH(id) BUCKETS 10 PROPERTIES ("colocate_with" = "group1"); +CREATE TABLE t2 (id INT COMMENT "", value1 VARCHAR(8) COMMENT "", value2 VARCHAR(8) COMMENT "") DUPLICATE KEY(id) DISTRIBUTED BY HASH(id) BUCKETS 10 PROPERTIES ("colocate_with" = "group1"); +CREATE TABLE example_db.table_hash(k1 TINYINT, k2 DECIMAL(10, 2) DEFAULT "10.5", v1 CHAR(10) REPLACE, v2 INT SUM, INDEX k1_idx (k1) USING INVERTED COMMENT 'my first index') AGGREGATE KEY(k1, k2) DISTRIBUTED BY HASH(k1) BUCKETS 32 PROPERTIES ("bloom_filter_columns" = "k2"); +CREATE TABLE example_db.table_hash(k1 TINYINT, k2 DECIMAL(10, 2) DEFAULT "10.5") DISTRIBUTED BY HASH(k1) BUCKETS 32 PROPERTIES ("replication_allocation" = "tag.location.group_a:1, tag.location.group_b:2"); +CREATE TABLE example_db.dynamic_partition(k1 DATE, k2 INT, k3 SMALLINT, v1 VARCHAR(2048), v2 DATETIME DEFAULT "2014-02-04 15:36:00") DUPLICATE KEY(k1, k2, k3) PARTITION BY RANGE(k1) () DISTRIBUTED BY HASH(k2) BUCKETS 32 PROPERTIES("dynamic_partition.time_unit" = "DAY", "dynamic_partition.start" = "-3", "dynamic_partition.end" = "3", "dynamic_partition.prefix" = "p", "dynamic_partition.buckets" = "32"); +CREATE TABLE t10 PROPERTIES ('replication_num' = '1') AS SELECT * FROM t1; +CREATE TABLE t11 LIKE t10 diff --git a/doris/examples/ddl_database.sql b/doris/examples/ddl_database.sql new file mode 100644 index 0000000..ef42cec --- /dev/null +++ b/doris/examples/ddl_database.sql @@ -0,0 +1,14 @@ +CREATE DATABASE db_test; +CREATE DATABASE `db_test` PROPERTIES ("replication_allocation" = "tag.location.group_1:3"); +CREATE DATABASE `db_test` PROPERTIES ("storage_vault_name" = "hdfs_demo_vault"); +ALTER DATABASE example_db SET DATA QUOTA 10995116277760; +ALTER DATABASE example_db RENAME example_db2; +ALTER DATABASE example_db SET REPLICA QUOTA 102400; +ALTER DATABASE example_db SET PROPERTIES("replication_allocation" = "tag.location.default:2"); +ALTER DATABASE example_db SET PROPERTIES("replication_allocation" = ""); +ALTER DATABASE example_db SET PROPERTIES("storage_vault_name" = "hdfs_demo_vault"); +ALTER DATABASE example_db SET PROPERTIES("storage_vault_name" = ""); +DROP DATABASE db_test; +SHOW DATABASES; +SHOW DATABASES FROM hms_catalog; +SHOW DATABASES LIKE 'infor%' diff --git a/doris/examples/ddl_drop_table.sql b/doris/examples/ddl_drop_table.sql new file mode 100644 index 0000000..2b69dcf --- /dev/null +++ b/doris/examples/ddl_drop_table.sql @@ -0,0 +1,3 @@ +DROP TABLE my_table; +DROP TABLE IF EXISTS example_db.my_table; +DROP TABLE IF EXISTS example_db.my_table FORCE diff --git a/doris/examples/ddl_index.sql b/doris/examples/ddl_index.sql new file mode 100644 index 0000000..80c3795 --- /dev/null +++ b/doris/examples/ddl_index.sql @@ -0,0 +1,5 @@ +CREATE INDEX index1 ON table1 (col1) USING INVERTED; +CREATE INDEX index2 ON table1 (col1) USING NGRAM_BF PROPERTIES("gram_size" = "3", "bf_size" = "1024"); +DROP INDEX IF EXISTS index_name ON table1; +BUILD INDEX index1 ON table1; +BUILD INDEX index1 ON table1 PARTITION(p1, p2) diff --git a/doris/examples/ddl_truncate_table.sql b/doris/examples/ddl_truncate_table.sql new file mode 100644 index 0000000..5bd6995 --- /dev/null +++ b/doris/examples/ddl_truncate_table.sql @@ -0,0 +1,2 @@ +TRUNCATE TABLE example_db.tbl; +TRUNCATE TABLE tbl PARTITION(p1, p2) diff --git a/doris/examples/ddl_view.sql b/doris/examples/ddl_view.sql new file mode 100644 index 0000000..3eca373 --- /dev/null +++ b/doris/examples/ddl_view.sql @@ -0,0 +1,2 @@ +CREATE VIEW example_db.example_view (k1, k2, k3, v1) AS SELECT c1 AS k1, k2, k3, SUM(v1) FROM example_table WHERE k1 = 20160112 GROUP BY k1, k2, k3; +CREATE VIEW example_db.example_view(k1 COMMENT "first key", k2 COMMENT "second key", k3 COMMENT "third key", v1 COMMENT "first value") COMMENT "my first view" AS SELECT c1 AS k1, k2, k3, SUM(v1) FROM example_table WHERE k1 = 20160112 GROUP BY k1, k2, k3 diff --git a/doris/examples/dml_delete.sql b/doris/examples/dml_delete.sql new file mode 100644 index 0000000..c8a09f1 --- /dev/null +++ b/doris/examples/dml_delete.sql @@ -0,0 +1,4 @@ +DELETE FROM my_table PARTITION p1 WHERE k1 = 3; +DELETE FROM my_table PARTITION p1 WHERE k1 >= 3 AND k2 = "abc"; +DELETE FROM my_table PARTITIONS (p1, p2) WHERE k1 >= 3 AND k2 = "abc"; +DELETE FROM t1 USING t2 INNER JOIN t3 ON t2.id = t3.id WHERE t1.id = t2.id diff --git a/doris/examples/dml_insert.sql b/doris/examples/dml_insert.sql new file mode 100644 index 0000000..753c15c --- /dev/null +++ b/doris/examples/dml_insert.sql @@ -0,0 +1,16 @@ +INSERT INTO test VALUES (1, 2); +INSERT INTO test (c1, c2) VALUES (1, 2); +INSERT INTO test (c1, c2) VALUES (1, DEFAULT); +INSERT INTO test (c1) VALUES (1); +INSERT INTO test VALUES (1, 2), (3, 2 + 2); +INSERT INTO test (c1, c2) VALUES (1, 2), (3, 2 * 2); +INSERT INTO test (c1) VALUES (1), (3); +INSERT INTO test (c1, c2) VALUES (1, DEFAULT), (3, DEFAULT); +INSERT INTO test SELECT * FROM test2; +INSERT INTO test (c1, c2) SELECT * FROM test2; +INSERT INTO test PARTITION(p1, p2) WITH LABEL `label1` SELECT * FROM test2; +INSERT INTO test WITH LABEL `label1` (c1, c2) SELECT * FROM test2; +INSERT INTO tbl1 SELECT * FROM empty_tbl; +INSERT INTO tbl1 SELECT * FROM tbl2; +INSERT INTO tbl1 WITH LABEL my_label1 SELECT * FROM tbl2; +INSERT INTO tbl1 SELECT * FROM tbl2 WHERE k1 = "a" diff --git a/doris/examples/dml_insert_overwrite.sql b/doris/examples/dml_insert_overwrite.sql new file mode 100644 index 0000000..6df0db4 --- /dev/null +++ b/doris/examples/dml_insert_overwrite.sql @@ -0,0 +1,25 @@ +INSERT OVERWRITE TABLE test VALUES (1, 2); +INSERT OVERWRITE TABLE test (c1, c2) VALUES (1, 2); +INSERT OVERWRITE TABLE test (c1, c2) VALUES (1, DEFAULT); +INSERT OVERWRITE TABLE test (c1) VALUES (1); +INSERT OVERWRITE TABLE test VALUES (1, 2), (3, 2 + 2); +INSERT OVERWRITE TABLE test (c1, c2) VALUES (1, 2), (3, 2 * 2); +INSERT OVERWRITE TABLE test (c1, c2) VALUES (1, DEFAULT), (3, DEFAULT); +INSERT OVERWRITE TABLE test (c1) VALUES (1), (3); +INSERT OVERWRITE TABLE test SELECT * FROM test2; +INSERT OVERWRITE TABLE test (c1, c2) SELECT * FROM test2; +INSERT OVERWRITE TABLE test WITH LABEL `label1` SELECT * FROM test2; +INSERT OVERWRITE TABLE test WITH LABEL `label2` (c1, c2) SELECT * FROM test2; +INSERT OVERWRITE TABLE test PARTITION(p1, p2) VALUES (1, 2); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1, c2) VALUES (1, 2); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1, c2) VALUES (1, DEFAULT); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1) VALUES (1); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) VALUES (1, 2), (4, 2 + 2); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1, c2) VALUES (1, 2), (4, 2 * 2); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1, c2) VALUES (1, DEFAULT), (4, DEFAULT); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1) VALUES (1), (4); +INSERT OVERWRITE TABLE test PARTITION(p1, p2) SELECT * FROM test2; +INSERT OVERWRITE TABLE test PARTITION(p1, p2) (c1, c2) SELECT * FROM test2; +INSERT OVERWRITE TABLE test PARTITION(p1, p2) WITH LABEL `label3` SELECT * FROM test2; +INSERT OVERWRITE TABLE test PARTITION(p1, p2) WITH LABEL `label4` (c1, c2) SELECT * FROM test2; +INSERT OVERWRITE TABLE test PARTITION(*) VALUES (3), (1234) diff --git a/doris/examples/dml_update.sql b/doris/examples/dml_update.sql new file mode 100644 index 0000000..2c0afe1 --- /dev/null +++ b/doris/examples/dml_update.sql @@ -0,0 +1,3 @@ +UPDATE test SET v1 = 1 WHERE k1 = 1 AND k2 = 2; +UPDATE test SET v1 = v1 + 1 WHERE k1 = 1; +UPDATE t1 SET t1.c1 = t2.c1, t1.c3 = t2.c3 * 100 FROM t2 INNER JOIN t3 ON t2.id = t3.id WHERE t1.id = t2.id diff --git a/doris/examples/function.sql b/doris/examples/function.sql new file mode 100644 index 0000000..d32d102 --- /dev/null +++ b/doris/examples/function.sql @@ -0,0 +1,20 @@ +CREATE FUNCTION java_udf_add_one(INT) RETURNS INT PROPERTIES ( + "file"="file:///path/to/java-udf-demo-jar-with-dependencies.jar", + "symbol"="org.apache.doris.udf.AddOne", + "always_nullable"="true", + "type"="JAVA_UDF" +); +CREATE AGGREGATE FUNCTION simple_sum(INT) RETURNS INT PROPERTIES ( + "file"="file:///pathTo/java-udaf.jar", + "symbol"="org.apache.doris.udf.demo.SimpleDemo", + "always_nullable"="true", + "type"="JAVA_UDF" +); +CREATE ALIAS FUNCTION id_masking(INT) WITH PARAMETER(id) AS CONCAT(LEFT(id, 3), '****', RIGHT(id, 4)); +CREATE GLOBAL ALIAS FUNCTION id_masking(INT) WITH PARAMETER(id) AS CONCAT(LEFT(id, 3), '****', RIGHT(id, 4)); +DROP FUNCTION my_add(INT, INT); +DROP GLOBAL FUNCTION my_add(INT, INT); +SHOW FULL FUNCTIONS IN testDb; +SHOW BUILTIN FUNCTIONS IN testDb LIKE 'year%'; +SHOW GLOBAL FULL FUNCTIONS; +SHOW GLOBAL FUNCTIONS diff --git a/doris/examples/job.sql b/doris/examples/job.sql new file mode 100644 index 0000000..ade83ed --- /dev/null +++ b/doris/examples/job.sql @@ -0,0 +1,7 @@ +CREATE JOB my_job ON SCHEDULE EVERY 1 MINUTE DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2; +CREATE JOB my_job ON SCHEDULE AT '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2; +CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >= days_add(now(),-1); +CREATE JOB my_job ON SCHEDULE EVERY 1 DAY STARTS '2020-01-01 00:00:00' ENDS '2020-01-01 00:10:00' DO INSERT INTO db1.tbl1 SELECT * FROM db2.tbl2 WHERE create_time >= days_add(now(),-1); +PAUSE JOB WHERE jobname='example'; +RESUME JOB WHERE jobName='example'; +DROP JOB WHERE jobName='example' diff --git a/doris/examples/materialized_view.sql b/doris/examples/materialized_view.sql new file mode 100644 index 0000000..c750189 --- /dev/null +++ b/doris/examples/materialized_view.sql @@ -0,0 +1,5 @@ +CREATE MATERIALIZED VIEW complete_mv (orderdate COMMENT 'Order date', orderkey COMMENT 'Order key', partkey COMMENT 'Part key') BUILD IMMEDIATE REFRESH AUTO ON SCHEDULE EVERY 1 DAY STARTS '2024-12-01 20:30:00' DISTRIBUTED BY HASH(orderkey) BUCKETS 2 PROPERTIES("replication_num" = "1") AS SELECT o_orderdate, l_orderkey, l_partkey FROM orders LEFT JOIN lineitem ON l_orderkey = o_orderkey LEFT JOIN partsupp ON ps_partkey = l_partkey AND l_suppkey = ps_suppkey; +CREATE MATERIALIZED VIEW partition_mv BUILD IMMEDIATE REFRESH AUTO ON SCHEDULE EVERY 1 DAY STARTS '2024-12-01 20:30:00' PARTITION BY (DATE_TRUNC(o_orderdate, 'MONTH')) DISTRIBUTED BY HASH(l_orderkey) BUCKETS 2 PROPERTIES("replication_num" = "3") AS SELECT o_orderdate, l_orderkey, l_partkey FROM orders LEFT JOIN lineitem ON l_orderkey = o_orderkey LEFT JOIN partsupp ON ps_partkey = l_partkey AND l_suppkey = ps_suppkey; +ALTER MATERIALIZED VIEW partition_mv SET ("grace_period" = "10", "excluded_trigger_tables" = "lineitem,partsupp"); +ALTER MATERIALIZED VIEW partition_mv REFRESH COMPLETE; +SHOW CREATE MATERIALIZED VIEW partition_mv diff --git a/doris/examples/plugin.sql b/doris/examples/plugin.sql new file mode 100644 index 0000000..ba39505 --- /dev/null +++ b/doris/examples/plugin.sql @@ -0,0 +1,6 @@ +INSTALL PLUGIN FROM "/home/users/doris/auditdemo.zip"; +INSTALL PLUGIN FROM "/home/users/doris/auditdemo/"; +INSTALL PLUGIN FROM "http://mywebsite.com/plugin.zip"; +INSTALL PLUGIN FROM "http://mywebsite.com/plugin.zip" PROPERTIES("md5sum" = "73877f6029216f4314d712086a146570"); +UNINSTALL PLUGIN auditdemo; +SHOW PLUGINS diff --git a/doris/examples/recycle_recover.sql b/doris/examples/recycle_recover.sql new file mode 100644 index 0000000..85ea0c6 --- /dev/null +++ b/doris/examples/recycle_recover.sql @@ -0,0 +1,9 @@ +RECOVER DATABASE example_db; +RECOVER TABLE example_db.example_tbl; +RECOVER PARTITION p1 FROM example_tbl; +RECOVER DATABASE example_db 12345; +RECOVER TABLE example_db.example_tbl 12346; +RECOVER PARTITION p1 12347 FROM example_tbl; +RECOVER DATABASE example_db 12345 AS new_example_db; +RECOVER TABLE example_db.example_tbl AS new_example_tbl; +RECOVER PARTITION p1 12347 AS new_p1 FROM example_tbl diff --git a/doris/examples/regression/routine_load.sql b/doris/examples/regression/routine_load.sql new file mode 100644 index 0000000..13f1c14 --- /dev/null +++ b/doris/examples/regression/routine_load.sql @@ -0,0 +1 @@ +SHOW CREATE ROUTINE LOAD FOR uDA6TB9nkmLWHYWLFCdCP6XrykhxxNa4gXA9yxZJU0; diff --git a/doris/examples/security_encryptkey.sql b/doris/examples/security_encryptkey.sql new file mode 100644 index 0000000..f0f95ba --- /dev/null +++ b/doris/examples/security_encryptkey.sql @@ -0,0 +1,6 @@ +CREATE ENCRYPTKEY my_key AS "ABCD123456789"; +CREATE ENCRYPTKEY testdb.test_key AS "ABCD123456789"; +SELECT HEX(AES_ENCRYPT("Doris is Great", KEY my_key)); +SELECT AES_DECRYPT(UNHEX('D26DB38579D6A343350EDDC6F2AD47C6'), KEY my_key); +DROP ENCRYPTKEY my_key; +DROP ENCRYPTKEY IF EXISTS testdb.my_key diff --git a/doris/examples/session_context.sql b/doris/examples/session_context.sql new file mode 100644 index 0000000..057265a --- /dev/null +++ b/doris/examples/session_context.sql @@ -0,0 +1,3 @@ +USE demo; +USE hms_catalog.demo; +SWITCH hive diff --git a/doris/examples/session_variable.sql b/doris/examples/session_variable.sql new file mode 100644 index 0000000..3edf9f4 --- /dev/null +++ b/doris/examples/session_variable.sql @@ -0,0 +1,6 @@ +SET time_zone = "Asia/Shanghai"; +SET GLOBAL exec_mem_limit = 137438953472; +SET @@exec_mem_limit = 137438953472; +SHOW VARIABLES LIKE 'max_connections'; +SHOW VARIABLES LIKE '%connec%'; +SHOW VARIABLES WHERE variable_name = 'version' diff --git a/doris/examples/show_partitions.sql b/doris/examples/show_partitions.sql new file mode 100644 index 0000000..f2f0bce --- /dev/null +++ b/doris/examples/show_partitions.sql @@ -0,0 +1,4 @@ +SHOW PARTITIONS FROM t_agg; +SHOW TEMPORARY PARTITIONS FROM t_temp; +SHOW PARTITIONS FROM t_agg WHERE PartitionName = "p2024"; +SHOW PARTITIONS FROM t_agg ORDER BY PartitionId DESC LIMIT 1 diff --git a/doris/examples/show_statements.sql b/doris/examples/show_statements.sql new file mode 100644 index 0000000..589f233 --- /dev/null +++ b/doris/examples/show_statements.sql @@ -0,0 +1,3 @@ +SHOW CREATE TABLE demo.test_table; +SHOW BRIEF CREATE TABLE demo.test_table; +DESC test_table diff --git a/doris/examples/show_table.sql b/doris/examples/show_table.sql new file mode 100644 index 0000000..4c5935b --- /dev/null +++ b/doris/examples/show_table.sql @@ -0,0 +1,13 @@ +SHOW TABLES; +SHOW TABLES LIKE '%cm%'; +SHOW FULL TABLES; +SHOW CREATE TABLE demo.test_table; +SHOW BRIEF CREATE TABLE demo.test_table; +DESC test_table; +SHOW TABLE STATUS; +SHOW TABLE STATUS FROM db LIKE "%test%"; +SHOW ALTER TABLE COLUMN; +SHOW ALTER TABLE COLUMN WHERE TableName = "table1" ORDER BY CreateTime DESC LIMIT 1; +SHOW ALTER TABLE ROLLUP FROM example_db; +SHOW FULL COLUMNS FROM t_agg; +SHOW COLUMNS FROM t_agg diff --git a/doris/examples/statistics.sql b/doris/examples/statistics.sql new file mode 100644 index 0000000..7358067 --- /dev/null +++ b/doris/examples/statistics.sql @@ -0,0 +1,7 @@ +ANALYZE TABLE lineitem WITH SAMPLE PERCENT 10; +ANALYZE TABLE lineitem WITH SAMPLE ROWS 100000; +DROP STATS table1; +DROP STATS table1 (col1, col2); +SHOW TABLE STATS test1; +SHOW ANALYZE test1 WHERE STATE="FINISHED"; +SHOW ANALYZE 1738725887903 diff --git a/doris/examples/transaction.sql b/doris/examples/transaction.sql new file mode 100644 index 0000000..0cb07fd --- /dev/null +++ b/doris/examples/transaction.sql @@ -0,0 +1,3 @@ +BEGIN; +BEGIN WITH LABEL load_1; +COMMIT diff --git a/doris/parser_test.go b/doris/parser_test.go index 94d0d4a..6cedc61 100644 --- a/doris/parser_test.go +++ b/doris/parser_test.go @@ -1,9 +1,9 @@ package doris_test import ( + "io/fs" "io/ioutil" - "os" - "path" + "path/filepath" "strings" "testing" @@ -37,49 +37,51 @@ func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) } -func TestDorisSQLParser(t *testing.T) { - examples, err := os.ReadDir("examples") - require.NoError(t, err) - - for _, file := range examples { - filePath := path.Join("examples", file.Name()) +func TestDorisParser(t *testing.T) { + err := filepath.WalkDir("examples", func(filePath string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() || !strings.HasSuffix(d.Name(), ".sql") { + return nil + } t.Run(filePath, func(t *testing.T) { t.Parallel() - // read all the bytes from the file - data, err := ioutil.ReadFile(filePath) - require.NoError(t, err) - - dataString := strings.TrimRight(string(data), " \t\r\n;") + "\n;" - // dataString := string(data) - // antlr.ConfigureRuntime(antlr.WithParserATNSimulatorDebug(true)) + runParserTest(t, filePath) + }) + return nil + }) + require.NoError(t, err) +} - input := antlr.NewInputStream(dataString) +func runParserTest(t *testing.T, filePath string) { + // read all the bytes from the file + data, err := ioutil.ReadFile(filePath) + require.NoError(t, err) - lexer := doris.NewDorisSQLLexer(input) + dataString := strings.TrimRight(string(data), " \t\r\n;") + "\n;" - stream := antlr.NewCommonTokenStream(lexer, 0) - p := doris.NewDorisSQLParser(stream) + input := antlr.NewInputStream(dataString) - lexerErrors := &CustomErrorListener{} - lexer.RemoveErrorListeners() - lexer.AddErrorListener(lexerErrors) + lexer := doris.NewDorisLexer(input) - parserErrors := &CustomErrorListener{} - p.RemoveErrorListeners() - p.AddErrorListener(parserErrors) + stream := antlr.NewCommonTokenStream(lexer, 0) + p := doris.NewDorisParser(stream) - p.BuildParseTrees = true + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) - tree := p.SqlStatements() + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) - // tree := p.FromClause() + p.BuildParseTrees = true - // fmt.Println(stream.GetAllText()) + tree := p.MultiStatements() - require.Equal(t, 0, lexerErrors.errors) - require.Equal(t, 0, parserErrors.errors) + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) - require.Equal(t, dataString, stream.GetTextFromRuleContext(tree)) - }) - } + require.Equal(t, dataString, stream.GetTextFromRuleContext(tree)) } diff --git a/starrocks/Makefile b/starrocks/Makefile new file mode 100644 index 0000000..5f95774 --- /dev/null +++ b/starrocks/Makefile @@ -0,0 +1,7 @@ +all: build test + +build: + antlr -Dlanguage=Go -package starrocks -visitor -o . StarRocksSQLLex.g4 StarRocksSQL.g4 + +test: + go test -v -run TestStarRocksSQLParser diff --git a/starrocks/README.md b/starrocks/README.md new file mode 100644 index 0000000..aa99eef --- /dev/null +++ b/starrocks/README.md @@ -0,0 +1,32 @@ +The StarRocks parser is a parser for StarRocks SQL. It is based on the [ANTLR4](https://github.com/antlr/antlr4). + +## Build + +Before build, you need to install the ANTLR4. + +requirements: +- https://github.com/antlr/antlr4/blob/master/doc/getting-started.md +- https://github.com/antlr/antlr4/blob/master/doc/go-target.md + +```bash +./build.sh +``` + +## Update grammar + +### Manually change the grammar file in this project + +1. run `./build.sh` to generate the parser code. + +## Test the parser + +Run `TestStarRocksSQLParser` in `parser_test.go` to test the parser. + +```bash +go test -v +``` + +## References + +- ANTLR4 Getting Started https://github.com/antlr/antlr4/blob/master/doc/getting-started.md +- ANTLR4 Go Garget https://github.com/antlr/antlr4/blob/master/doc/go-target.md \ No newline at end of file diff --git a/doris/DorisSQL.g4 b/starrocks/StarRocksSQL.g4 similarity index 99% rename from doris/DorisSQL.g4 rename to starrocks/StarRocksSQL.g4 index 0c54a78..a957291 100644 --- a/doris/DorisSQL.g4 +++ b/starrocks/StarRocksSQL.g4 @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -grammar DorisSQL; -import DorisSQLLex; +grammar StarRocksSQL; +import StarRocksSQLLex; sqlStatements : singleStatement+ EOF diff --git a/doris/DorisSQLLex.g4 b/starrocks/StarRocksSQLLex.g4 similarity index 99% rename from doris/DorisSQLLex.g4 rename to starrocks/StarRocksSQLLex.g4 index c44607f..4937365 100644 --- a/doris/DorisSQLLex.g4 +++ b/starrocks/StarRocksSQLLex.g4 @@ -13,7 +13,7 @@ // limitations under the License. -lexer grammar DorisSQLLex; +lexer grammar StarRocksSQLLex; tokens { CONCAT } diff --git a/doris/examples/for_test.sql b/starrocks/examples/for_test.sql similarity index 100% rename from doris/examples/for_test.sql rename to starrocks/examples/for_test.sql diff --git a/starrocks/parser_test.go b/starrocks/parser_test.go new file mode 100644 index 0000000..bcecb27 --- /dev/null +++ b/starrocks/parser_test.go @@ -0,0 +1,85 @@ +package starrocks_test + +import ( + "io/ioutil" + "os" + "path" + "strings" + "testing" + + "github.com/antlr4-go/antlr/v4" + starrocks "github.com/bytebase/parser/starrocks" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func NewCustomErrorListener() *CustomErrorListener { + return new(CustomErrorListener) +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestStarRocksSQLParser(t *testing.T) { + examples, err := os.ReadDir("examples") + require.NoError(t, err) + + for _, file := range examples { + filePath := path.Join("examples", file.Name()) + t.Run(filePath, func(t *testing.T) { + t.Parallel() + // read all the bytes from the file + data, err := ioutil.ReadFile(filePath) + require.NoError(t, err) + + dataString := strings.TrimRight(string(data), " \t\r\n;") + "\n;" + // dataString := string(data) + // antlr.ConfigureRuntime(antlr.WithParserATNSimulatorDebug(true)) + + input := antlr.NewInputStream(dataString) + + lexer := starrocks.NewStarRocksSQLLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := starrocks.NewStarRocksSQLParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + tree := p.SqlStatements() + + // tree := p.FromClause() + + // fmt.Println(stream.GetAllText()) + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + + require.Equal(t, dataString, stream.GetTextFromRuleContext(tree)) + }) + } +} diff --git a/starrocks/starrockssql_base_listener.go b/starrocks/starrockssql_base_listener.go new file mode 100644 index 0000000..a041f13 --- /dev/null +++ b/starrocks/starrockssql_base_listener.go @@ -0,0 +1,4165 @@ +// Code generated from StarRocksSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package starrocks // StarRocksSQL +import "github.com/antlr4-go/antlr/v4" + +// BaseStarRocksSQLListener is a complete listener for a parse tree produced by StarRocksSQLParser. +type BaseStarRocksSQLListener struct{} + +var _ StarRocksSQLListener = &BaseStarRocksSQLListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseStarRocksSQLListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseStarRocksSQLListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseStarRocksSQLListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseStarRocksSQLListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterSqlStatements is called when production sqlStatements is entered. +func (s *BaseStarRocksSQLListener) EnterSqlStatements(ctx *SqlStatementsContext) {} + +// ExitSqlStatements is called when production sqlStatements is exited. +func (s *BaseStarRocksSQLListener) ExitSqlStatements(ctx *SqlStatementsContext) {} + +// EnterSingleStatement is called when production singleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSingleStatement(ctx *SingleStatementContext) {} + +// ExitSingleStatement is called when production singleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSingleStatement(ctx *SingleStatementContext) {} + +// EnterStatement is called when production statement is entered. +func (s *BaseStarRocksSQLListener) EnterStatement(ctx *StatementContext) {} + +// ExitStatement is called when production statement is exited. +func (s *BaseStarRocksSQLListener) ExitStatement(ctx *StatementContext) {} + +// EnterUseDatabaseStatement is called when production useDatabaseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterUseDatabaseStatement(ctx *UseDatabaseStatementContext) {} + +// ExitUseDatabaseStatement is called when production useDatabaseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitUseDatabaseStatement(ctx *UseDatabaseStatementContext) {} + +// EnterUseCatalogStatement is called when production useCatalogStatement is entered. +func (s *BaseStarRocksSQLListener) EnterUseCatalogStatement(ctx *UseCatalogStatementContext) {} + +// ExitUseCatalogStatement is called when production useCatalogStatement is exited. +func (s *BaseStarRocksSQLListener) ExitUseCatalogStatement(ctx *UseCatalogStatementContext) {} + +// EnterSetCatalogStatement is called when production setCatalogStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetCatalogStatement(ctx *SetCatalogStatementContext) {} + +// ExitSetCatalogStatement is called when production setCatalogStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetCatalogStatement(ctx *SetCatalogStatementContext) {} + +// EnterShowDatabasesStatement is called when production showDatabasesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDatabasesStatement(ctx *ShowDatabasesStatementContext) {} + +// ExitShowDatabasesStatement is called when production showDatabasesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) {} + +// EnterAlterDbQuotaStatement is called when production alterDbQuotaStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) {} + +// ExitAlterDbQuotaStatement is called when production alterDbQuotaStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) {} + +// EnterCreateDbStatement is called when production createDbStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateDbStatement(ctx *CreateDbStatementContext) {} + +// ExitCreateDbStatement is called when production createDbStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateDbStatement(ctx *CreateDbStatementContext) {} + +// EnterDropDbStatement is called when production dropDbStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropDbStatement(ctx *DropDbStatementContext) {} + +// ExitDropDbStatement is called when production dropDbStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropDbStatement(ctx *DropDbStatementContext) {} + +// EnterShowCreateDbStatement is called when production showCreateDbStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateDbStatement(ctx *ShowCreateDbStatementContext) {} + +// ExitShowCreateDbStatement is called when production showCreateDbStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateDbStatement(ctx *ShowCreateDbStatementContext) {} + +// EnterAlterDatabaseRenameStatement is called when production alterDatabaseRenameStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) { +} + +// ExitAlterDatabaseRenameStatement is called when production alterDatabaseRenameStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) { +} + +// EnterRecoverDbStmt is called when production recoverDbStmt is entered. +func (s *BaseStarRocksSQLListener) EnterRecoverDbStmt(ctx *RecoverDbStmtContext) {} + +// ExitRecoverDbStmt is called when production recoverDbStmt is exited. +func (s *BaseStarRocksSQLListener) ExitRecoverDbStmt(ctx *RecoverDbStmtContext) {} + +// EnterShowDataStmt is called when production showDataStmt is entered. +func (s *BaseStarRocksSQLListener) EnterShowDataStmt(ctx *ShowDataStmtContext) {} + +// ExitShowDataStmt is called when production showDataStmt is exited. +func (s *BaseStarRocksSQLListener) ExitShowDataStmt(ctx *ShowDataStmtContext) {} + +// EnterShowDataDistributionStmt is called when production showDataDistributionStmt is entered. +func (s *BaseStarRocksSQLListener) EnterShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) { +} + +// ExitShowDataDistributionStmt is called when production showDataDistributionStmt is exited. +func (s *BaseStarRocksSQLListener) ExitShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) { +} + +// EnterCreateTableStatement is called when production createTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateTableStatement(ctx *CreateTableStatementContext) {} + +// ExitCreateTableStatement is called when production createTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateTableStatement(ctx *CreateTableStatementContext) {} + +// EnterColumnDesc is called when production columnDesc is entered. +func (s *BaseStarRocksSQLListener) EnterColumnDesc(ctx *ColumnDescContext) {} + +// ExitColumnDesc is called when production columnDesc is exited. +func (s *BaseStarRocksSQLListener) ExitColumnDesc(ctx *ColumnDescContext) {} + +// EnterCharsetName is called when production charsetName is entered. +func (s *BaseStarRocksSQLListener) EnterCharsetName(ctx *CharsetNameContext) {} + +// ExitCharsetName is called when production charsetName is exited. +func (s *BaseStarRocksSQLListener) ExitCharsetName(ctx *CharsetNameContext) {} + +// EnterDefaultDesc is called when production defaultDesc is entered. +func (s *BaseStarRocksSQLListener) EnterDefaultDesc(ctx *DefaultDescContext) {} + +// ExitDefaultDesc is called when production defaultDesc is exited. +func (s *BaseStarRocksSQLListener) ExitDefaultDesc(ctx *DefaultDescContext) {} + +// EnterGeneratedColumnDesc is called when production generatedColumnDesc is entered. +func (s *BaseStarRocksSQLListener) EnterGeneratedColumnDesc(ctx *GeneratedColumnDescContext) {} + +// ExitGeneratedColumnDesc is called when production generatedColumnDesc is exited. +func (s *BaseStarRocksSQLListener) ExitGeneratedColumnDesc(ctx *GeneratedColumnDescContext) {} + +// EnterIndexDesc is called when production indexDesc is entered. +func (s *BaseStarRocksSQLListener) EnterIndexDesc(ctx *IndexDescContext) {} + +// ExitIndexDesc is called when production indexDesc is exited. +func (s *BaseStarRocksSQLListener) ExitIndexDesc(ctx *IndexDescContext) {} + +// EnterEngineDesc is called when production engineDesc is entered. +func (s *BaseStarRocksSQLListener) EnterEngineDesc(ctx *EngineDescContext) {} + +// ExitEngineDesc is called when production engineDesc is exited. +func (s *BaseStarRocksSQLListener) ExitEngineDesc(ctx *EngineDescContext) {} + +// EnterCharsetDesc is called when production charsetDesc is entered. +func (s *BaseStarRocksSQLListener) EnterCharsetDesc(ctx *CharsetDescContext) {} + +// ExitCharsetDesc is called when production charsetDesc is exited. +func (s *BaseStarRocksSQLListener) ExitCharsetDesc(ctx *CharsetDescContext) {} + +// EnterCollateDesc is called when production collateDesc is entered. +func (s *BaseStarRocksSQLListener) EnterCollateDesc(ctx *CollateDescContext) {} + +// ExitCollateDesc is called when production collateDesc is exited. +func (s *BaseStarRocksSQLListener) ExitCollateDesc(ctx *CollateDescContext) {} + +// EnterKeyDesc is called when production keyDesc is entered. +func (s *BaseStarRocksSQLListener) EnterKeyDesc(ctx *KeyDescContext) {} + +// ExitKeyDesc is called when production keyDesc is exited. +func (s *BaseStarRocksSQLListener) ExitKeyDesc(ctx *KeyDescContext) {} + +// EnterOrderByDesc is called when production orderByDesc is entered. +func (s *BaseStarRocksSQLListener) EnterOrderByDesc(ctx *OrderByDescContext) {} + +// ExitOrderByDesc is called when production orderByDesc is exited. +func (s *BaseStarRocksSQLListener) ExitOrderByDesc(ctx *OrderByDescContext) {} + +// EnterColumnNullable is called when production columnNullable is entered. +func (s *BaseStarRocksSQLListener) EnterColumnNullable(ctx *ColumnNullableContext) {} + +// ExitColumnNullable is called when production columnNullable is exited. +func (s *BaseStarRocksSQLListener) ExitColumnNullable(ctx *ColumnNullableContext) {} + +// EnterTypeWithNullable is called when production typeWithNullable is entered. +func (s *BaseStarRocksSQLListener) EnterTypeWithNullable(ctx *TypeWithNullableContext) {} + +// ExitTypeWithNullable is called when production typeWithNullable is exited. +func (s *BaseStarRocksSQLListener) ExitTypeWithNullable(ctx *TypeWithNullableContext) {} + +// EnterAggStateDesc is called when production aggStateDesc is entered. +func (s *BaseStarRocksSQLListener) EnterAggStateDesc(ctx *AggStateDescContext) {} + +// ExitAggStateDesc is called when production aggStateDesc is exited. +func (s *BaseStarRocksSQLListener) ExitAggStateDesc(ctx *AggStateDescContext) {} + +// EnterAggDesc is called when production aggDesc is entered. +func (s *BaseStarRocksSQLListener) EnterAggDesc(ctx *AggDescContext) {} + +// ExitAggDesc is called when production aggDesc is exited. +func (s *BaseStarRocksSQLListener) ExitAggDesc(ctx *AggDescContext) {} + +// EnterRollupDesc is called when production rollupDesc is entered. +func (s *BaseStarRocksSQLListener) EnterRollupDesc(ctx *RollupDescContext) {} + +// ExitRollupDesc is called when production rollupDesc is exited. +func (s *BaseStarRocksSQLListener) ExitRollupDesc(ctx *RollupDescContext) {} + +// EnterRollupItem is called when production rollupItem is entered. +func (s *BaseStarRocksSQLListener) EnterRollupItem(ctx *RollupItemContext) {} + +// ExitRollupItem is called when production rollupItem is exited. +func (s *BaseStarRocksSQLListener) ExitRollupItem(ctx *RollupItemContext) {} + +// EnterDupKeys is called when production dupKeys is entered. +func (s *BaseStarRocksSQLListener) EnterDupKeys(ctx *DupKeysContext) {} + +// ExitDupKeys is called when production dupKeys is exited. +func (s *BaseStarRocksSQLListener) ExitDupKeys(ctx *DupKeysContext) {} + +// EnterFromRollup is called when production fromRollup is entered. +func (s *BaseStarRocksSQLListener) EnterFromRollup(ctx *FromRollupContext) {} + +// ExitFromRollup is called when production fromRollup is exited. +func (s *BaseStarRocksSQLListener) ExitFromRollup(ctx *FromRollupContext) {} + +// EnterOrReplace is called when production orReplace is entered. +func (s *BaseStarRocksSQLListener) EnterOrReplace(ctx *OrReplaceContext) {} + +// ExitOrReplace is called when production orReplace is exited. +func (s *BaseStarRocksSQLListener) ExitOrReplace(ctx *OrReplaceContext) {} + +// EnterIfNotExists is called when production ifNotExists is entered. +func (s *BaseStarRocksSQLListener) EnterIfNotExists(ctx *IfNotExistsContext) {} + +// ExitIfNotExists is called when production ifNotExists is exited. +func (s *BaseStarRocksSQLListener) ExitIfNotExists(ctx *IfNotExistsContext) {} + +// EnterCreateTableAsSelectStatement is called when production createTableAsSelectStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) { +} + +// ExitCreateTableAsSelectStatement is called when production createTableAsSelectStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) { +} + +// EnterDropTableStatement is called when production dropTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropTableStatement(ctx *DropTableStatementContext) {} + +// ExitDropTableStatement is called when production dropTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropTableStatement(ctx *DropTableStatementContext) {} + +// EnterCleanTemporaryTableStatement is called when production cleanTemporaryTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) { +} + +// ExitCleanTemporaryTableStatement is called when production cleanTemporaryTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) { +} + +// EnterAlterTableStatement is called when production alterTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterTableStatement(ctx *AlterTableStatementContext) {} + +// ExitAlterTableStatement is called when production alterTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterTableStatement(ctx *AlterTableStatementContext) {} + +// EnterCreateIndexStatement is called when production createIndexStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateIndexStatement(ctx *CreateIndexStatementContext) {} + +// ExitCreateIndexStatement is called when production createIndexStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateIndexStatement(ctx *CreateIndexStatementContext) {} + +// EnterDropIndexStatement is called when production dropIndexStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropIndexStatement(ctx *DropIndexStatementContext) {} + +// ExitDropIndexStatement is called when production dropIndexStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropIndexStatement(ctx *DropIndexStatementContext) {} + +// EnterIndexType is called when production indexType is entered. +func (s *BaseStarRocksSQLListener) EnterIndexType(ctx *IndexTypeContext) {} + +// ExitIndexType is called when production indexType is exited. +func (s *BaseStarRocksSQLListener) ExitIndexType(ctx *IndexTypeContext) {} + +// EnterShowTableStatement is called when production showTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTableStatement(ctx *ShowTableStatementContext) {} + +// ExitShowTableStatement is called when production showTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTableStatement(ctx *ShowTableStatementContext) {} + +// EnterShowTemporaryTablesStatement is called when production showTemporaryTablesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) { +} + +// ExitShowTemporaryTablesStatement is called when production showTemporaryTablesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) { +} + +// EnterShowCreateTableStatement is called when production showCreateTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateTableStatement(ctx *ShowCreateTableStatementContext) { +} + +// ExitShowCreateTableStatement is called when production showCreateTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateTableStatement(ctx *ShowCreateTableStatementContext) { +} + +// EnterShowColumnStatement is called when production showColumnStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowColumnStatement(ctx *ShowColumnStatementContext) {} + +// ExitShowColumnStatement is called when production showColumnStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowColumnStatement(ctx *ShowColumnStatementContext) {} + +// EnterShowTableStatusStatement is called when production showTableStatusStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTableStatusStatement(ctx *ShowTableStatusStatementContext) { +} + +// ExitShowTableStatusStatement is called when production showTableStatusStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTableStatusStatement(ctx *ShowTableStatusStatementContext) { +} + +// EnterRefreshTableStatement is called when production refreshTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRefreshTableStatement(ctx *RefreshTableStatementContext) {} + +// ExitRefreshTableStatement is called when production refreshTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRefreshTableStatement(ctx *RefreshTableStatementContext) {} + +// EnterShowAlterStatement is called when production showAlterStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowAlterStatement(ctx *ShowAlterStatementContext) {} + +// ExitShowAlterStatement is called when production showAlterStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowAlterStatement(ctx *ShowAlterStatementContext) {} + +// EnterDescTableStatement is called when production descTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDescTableStatement(ctx *DescTableStatementContext) {} + +// ExitDescTableStatement is called when production descTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDescTableStatement(ctx *DescTableStatementContext) {} + +// EnterCreateTableLikeStatement is called when production createTableLikeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) { +} + +// ExitCreateTableLikeStatement is called when production createTableLikeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) { +} + +// EnterShowIndexStatement is called when production showIndexStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowIndexStatement(ctx *ShowIndexStatementContext) {} + +// ExitShowIndexStatement is called when production showIndexStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowIndexStatement(ctx *ShowIndexStatementContext) {} + +// EnterRecoverTableStatement is called when production recoverTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRecoverTableStatement(ctx *RecoverTableStatementContext) {} + +// ExitRecoverTableStatement is called when production recoverTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRecoverTableStatement(ctx *RecoverTableStatementContext) {} + +// EnterTruncateTableStatement is called when production truncateTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterTruncateTableStatement(ctx *TruncateTableStatementContext) {} + +// ExitTruncateTableStatement is called when production truncateTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitTruncateTableStatement(ctx *TruncateTableStatementContext) {} + +// EnterCancelAlterTableStatement is called when production cancelAlterTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) { +} + +// ExitCancelAlterTableStatement is called when production cancelAlterTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) { +} + +// EnterShowPartitionsStatement is called when production showPartitionsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPartitionsStatement(ctx *ShowPartitionsStatementContext) { +} + +// ExitShowPartitionsStatement is called when production showPartitionsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPartitionsStatement(ctx *ShowPartitionsStatementContext) {} + +// EnterRecoverPartitionStatement is called when production recoverPartitionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) { +} + +// ExitRecoverPartitionStatement is called when production recoverPartitionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) { +} + +// EnterCreateViewStatement is called when production createViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateViewStatement(ctx *CreateViewStatementContext) {} + +// ExitCreateViewStatement is called when production createViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateViewStatement(ctx *CreateViewStatementContext) {} + +// EnterAlterViewStatement is called when production alterViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterViewStatement(ctx *AlterViewStatementContext) {} + +// ExitAlterViewStatement is called when production alterViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterViewStatement(ctx *AlterViewStatementContext) {} + +// EnterDropViewStatement is called when production dropViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropViewStatement(ctx *DropViewStatementContext) {} + +// ExitDropViewStatement is called when production dropViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropViewStatement(ctx *DropViewStatementContext) {} + +// EnterColumnNameWithComment is called when production columnNameWithComment is entered. +func (s *BaseStarRocksSQLListener) EnterColumnNameWithComment(ctx *ColumnNameWithCommentContext) {} + +// ExitColumnNameWithComment is called when production columnNameWithComment is exited. +func (s *BaseStarRocksSQLListener) ExitColumnNameWithComment(ctx *ColumnNameWithCommentContext) {} + +// EnterSubmitTaskStatement is called when production submitTaskStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSubmitTaskStatement(ctx *SubmitTaskStatementContext) {} + +// ExitSubmitTaskStatement is called when production submitTaskStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSubmitTaskStatement(ctx *SubmitTaskStatementContext) {} + +// EnterTaskClause is called when production taskClause is entered. +func (s *BaseStarRocksSQLListener) EnterTaskClause(ctx *TaskClauseContext) {} + +// ExitTaskClause is called when production taskClause is exited. +func (s *BaseStarRocksSQLListener) ExitTaskClause(ctx *TaskClauseContext) {} + +// EnterDropTaskStatement is called when production dropTaskStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropTaskStatement(ctx *DropTaskStatementContext) {} + +// ExitDropTaskStatement is called when production dropTaskStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropTaskStatement(ctx *DropTaskStatementContext) {} + +// EnterTaskScheduleDesc is called when production taskScheduleDesc is entered. +func (s *BaseStarRocksSQLListener) EnterTaskScheduleDesc(ctx *TaskScheduleDescContext) {} + +// ExitTaskScheduleDesc is called when production taskScheduleDesc is exited. +func (s *BaseStarRocksSQLListener) ExitTaskScheduleDesc(ctx *TaskScheduleDescContext) {} + +// EnterCreateMaterializedViewStatement is called when production createMaterializedViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) { +} + +// ExitCreateMaterializedViewStatement is called when production createMaterializedViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) { +} + +// EnterMvPartitionExprs is called when production mvPartitionExprs is entered. +func (s *BaseStarRocksSQLListener) EnterMvPartitionExprs(ctx *MvPartitionExprsContext) {} + +// ExitMvPartitionExprs is called when production mvPartitionExprs is exited. +func (s *BaseStarRocksSQLListener) ExitMvPartitionExprs(ctx *MvPartitionExprsContext) {} + +// EnterMaterializedViewDesc is called when production materializedViewDesc is entered. +func (s *BaseStarRocksSQLListener) EnterMaterializedViewDesc(ctx *MaterializedViewDescContext) {} + +// ExitMaterializedViewDesc is called when production materializedViewDesc is exited. +func (s *BaseStarRocksSQLListener) ExitMaterializedViewDesc(ctx *MaterializedViewDescContext) {} + +// EnterShowMaterializedViewsStatement is called when production showMaterializedViewsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) { +} + +// ExitShowMaterializedViewsStatement is called when production showMaterializedViewsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) { +} + +// EnterDropMaterializedViewStatement is called when production dropMaterializedViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) { +} + +// ExitDropMaterializedViewStatement is called when production dropMaterializedViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) { +} + +// EnterAlterMaterializedViewStatement is called when production alterMaterializedViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) { +} + +// ExitAlterMaterializedViewStatement is called when production alterMaterializedViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) { +} + +// EnterRefreshMaterializedViewStatement is called when production refreshMaterializedViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) { +} + +// ExitRefreshMaterializedViewStatement is called when production refreshMaterializedViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) { +} + +// EnterCancelRefreshMaterializedViewStatement is called when production cancelRefreshMaterializedViewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) { +} + +// ExitCancelRefreshMaterializedViewStatement is called when production cancelRefreshMaterializedViewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) { +} + +// EnterAdminSetConfigStatement is called when production adminSetConfigStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) { +} + +// ExitAdminSetConfigStatement is called when production adminSetConfigStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) {} + +// EnterAdminSetReplicaStatusStatement is called when production adminSetReplicaStatusStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) { +} + +// ExitAdminSetReplicaStatusStatement is called when production adminSetReplicaStatusStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) { +} + +// EnterAdminShowConfigStatement is called when production adminShowConfigStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) { +} + +// ExitAdminShowConfigStatement is called when production adminShowConfigStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) { +} + +// EnterAdminShowReplicaDistributionStatement is called when production adminShowReplicaDistributionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) { +} + +// ExitAdminShowReplicaDistributionStatement is called when production adminShowReplicaDistributionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) { +} + +// EnterAdminShowReplicaStatusStatement is called when production adminShowReplicaStatusStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) { +} + +// ExitAdminShowReplicaStatusStatement is called when production adminShowReplicaStatusStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) { +} + +// EnterAdminRepairTableStatement is called when production adminRepairTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) { +} + +// ExitAdminRepairTableStatement is called when production adminRepairTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) { +} + +// EnterAdminCancelRepairTableStatement is called when production adminCancelRepairTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) { +} + +// ExitAdminCancelRepairTableStatement is called when production adminCancelRepairTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) { +} + +// EnterAdminCheckTabletsStatement is called when production adminCheckTabletsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) { +} + +// ExitAdminCheckTabletsStatement is called when production adminCheckTabletsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) { +} + +// EnterAdminSetPartitionVersion is called when production adminSetPartitionVersion is entered. +func (s *BaseStarRocksSQLListener) EnterAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) { +} + +// ExitAdminSetPartitionVersion is called when production adminSetPartitionVersion is exited. +func (s *BaseStarRocksSQLListener) ExitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) { +} + +// EnterKillStatement is called when production killStatement is entered. +func (s *BaseStarRocksSQLListener) EnterKillStatement(ctx *KillStatementContext) {} + +// ExitKillStatement is called when production killStatement is exited. +func (s *BaseStarRocksSQLListener) ExitKillStatement(ctx *KillStatementContext) {} + +// EnterSyncStatement is called when production syncStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSyncStatement(ctx *SyncStatementContext) {} + +// ExitSyncStatement is called when production syncStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSyncStatement(ctx *SyncStatementContext) {} + +// EnterAdminSetAutomatedSnapshotOnStatement is called when production adminSetAutomatedSnapshotOnStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) { +} + +// ExitAdminSetAutomatedSnapshotOnStatement is called when production adminSetAutomatedSnapshotOnStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) { +} + +// EnterAdminSetAutomatedSnapshotOffStatement is called when production adminSetAutomatedSnapshotOffStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) { +} + +// ExitAdminSetAutomatedSnapshotOffStatement is called when production adminSetAutomatedSnapshotOffStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) { +} + +// EnterAlterSystemStatement is called when production alterSystemStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterSystemStatement(ctx *AlterSystemStatementContext) {} + +// ExitAlterSystemStatement is called when production alterSystemStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterSystemStatement(ctx *AlterSystemStatementContext) {} + +// EnterCancelAlterSystemStatement is called when production cancelAlterSystemStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) { +} + +// ExitCancelAlterSystemStatement is called when production cancelAlterSystemStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) { +} + +// EnterShowComputeNodesStatement is called when production showComputeNodesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) { +} + +// ExitShowComputeNodesStatement is called when production showComputeNodesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) { +} + +// EnterCreateExternalCatalogStatement is called when production createExternalCatalogStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) { +} + +// ExitCreateExternalCatalogStatement is called when production createExternalCatalogStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) { +} + +// EnterShowCreateExternalCatalogStatement is called when production showCreateExternalCatalogStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) { +} + +// ExitShowCreateExternalCatalogStatement is called when production showCreateExternalCatalogStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) { +} + +// EnterDropExternalCatalogStatement is called when production dropExternalCatalogStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) { +} + +// ExitDropExternalCatalogStatement is called when production dropExternalCatalogStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) { +} + +// EnterShowCatalogsStatement is called when production showCatalogsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCatalogsStatement(ctx *ShowCatalogsStatementContext) {} + +// ExitShowCatalogsStatement is called when production showCatalogsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCatalogsStatement(ctx *ShowCatalogsStatementContext) {} + +// EnterAlterCatalogStatement is called when production alterCatalogStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterCatalogStatement(ctx *AlterCatalogStatementContext) {} + +// ExitAlterCatalogStatement is called when production alterCatalogStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterCatalogStatement(ctx *AlterCatalogStatementContext) {} + +// EnterCreateStorageVolumeStatement is called when production createStorageVolumeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) { +} + +// ExitCreateStorageVolumeStatement is called when production createStorageVolumeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) { +} + +// EnterTypeDesc is called when production typeDesc is entered. +func (s *BaseStarRocksSQLListener) EnterTypeDesc(ctx *TypeDescContext) {} + +// ExitTypeDesc is called when production typeDesc is exited. +func (s *BaseStarRocksSQLListener) ExitTypeDesc(ctx *TypeDescContext) {} + +// EnterLocationsDesc is called when production locationsDesc is entered. +func (s *BaseStarRocksSQLListener) EnterLocationsDesc(ctx *LocationsDescContext) {} + +// ExitLocationsDesc is called when production locationsDesc is exited. +func (s *BaseStarRocksSQLListener) ExitLocationsDesc(ctx *LocationsDescContext) {} + +// EnterShowStorageVolumesStatement is called when production showStorageVolumesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) { +} + +// ExitShowStorageVolumesStatement is called when production showStorageVolumesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) { +} + +// EnterDropStorageVolumeStatement is called when production dropStorageVolumeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) { +} + +// ExitDropStorageVolumeStatement is called when production dropStorageVolumeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) { +} + +// EnterAlterStorageVolumeStatement is called when production alterStorageVolumeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) { +} + +// ExitAlterStorageVolumeStatement is called when production alterStorageVolumeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) { +} + +// EnterAlterStorageVolumeClause is called when production alterStorageVolumeClause is entered. +func (s *BaseStarRocksSQLListener) EnterAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) { +} + +// ExitAlterStorageVolumeClause is called when production alterStorageVolumeClause is exited. +func (s *BaseStarRocksSQLListener) ExitAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) { +} + +// EnterModifyStorageVolumePropertiesClause is called when production modifyStorageVolumePropertiesClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) { +} + +// ExitModifyStorageVolumePropertiesClause is called when production modifyStorageVolumePropertiesClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) { +} + +// EnterModifyStorageVolumeCommentClause is called when production modifyStorageVolumeCommentClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) { +} + +// ExitModifyStorageVolumeCommentClause is called when production modifyStorageVolumeCommentClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) { +} + +// EnterDescStorageVolumeStatement is called when production descStorageVolumeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) { +} + +// ExitDescStorageVolumeStatement is called when production descStorageVolumeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) { +} + +// EnterSetDefaultStorageVolumeStatement is called when production setDefaultStorageVolumeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) { +} + +// ExitSetDefaultStorageVolumeStatement is called when production setDefaultStorageVolumeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) { +} + +// EnterUpdateFailPointStatusStatement is called when production updateFailPointStatusStatement is entered. +func (s *BaseStarRocksSQLListener) EnterUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) { +} + +// ExitUpdateFailPointStatusStatement is called when production updateFailPointStatusStatement is exited. +func (s *BaseStarRocksSQLListener) ExitUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) { +} + +// EnterShowFailPointStatement is called when production showFailPointStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowFailPointStatement(ctx *ShowFailPointStatementContext) {} + +// ExitShowFailPointStatement is called when production showFailPointStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowFailPointStatement(ctx *ShowFailPointStatementContext) {} + +// EnterCreateDictionaryStatement is called when production createDictionaryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) { +} + +// ExitCreateDictionaryStatement is called when production createDictionaryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) { +} + +// EnterDropDictionaryStatement is called when production dropDictionaryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropDictionaryStatement(ctx *DropDictionaryStatementContext) { +} + +// ExitDropDictionaryStatement is called when production dropDictionaryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropDictionaryStatement(ctx *DropDictionaryStatementContext) {} + +// EnterRefreshDictionaryStatement is called when production refreshDictionaryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) { +} + +// ExitRefreshDictionaryStatement is called when production refreshDictionaryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) { +} + +// EnterShowDictionaryStatement is called when production showDictionaryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDictionaryStatement(ctx *ShowDictionaryStatementContext) { +} + +// ExitShowDictionaryStatement is called when production showDictionaryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDictionaryStatement(ctx *ShowDictionaryStatementContext) {} + +// EnterCancelRefreshDictionaryStatement is called when production cancelRefreshDictionaryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) { +} + +// ExitCancelRefreshDictionaryStatement is called when production cancelRefreshDictionaryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) { +} + +// EnterDictionaryColumnDesc is called when production dictionaryColumnDesc is entered. +func (s *BaseStarRocksSQLListener) EnterDictionaryColumnDesc(ctx *DictionaryColumnDescContext) {} + +// ExitDictionaryColumnDesc is called when production dictionaryColumnDesc is exited. +func (s *BaseStarRocksSQLListener) ExitDictionaryColumnDesc(ctx *DictionaryColumnDescContext) {} + +// EnterDictionaryName is called when production dictionaryName is entered. +func (s *BaseStarRocksSQLListener) EnterDictionaryName(ctx *DictionaryNameContext) {} + +// ExitDictionaryName is called when production dictionaryName is exited. +func (s *BaseStarRocksSQLListener) ExitDictionaryName(ctx *DictionaryNameContext) {} + +// EnterAlterClause is called when production alterClause is entered. +func (s *BaseStarRocksSQLListener) EnterAlterClause(ctx *AlterClauseContext) {} + +// ExitAlterClause is called when production alterClause is exited. +func (s *BaseStarRocksSQLListener) ExitAlterClause(ctx *AlterClauseContext) {} + +// EnterAddFrontendClause is called when production addFrontendClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddFrontendClause(ctx *AddFrontendClauseContext) {} + +// ExitAddFrontendClause is called when production addFrontendClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddFrontendClause(ctx *AddFrontendClauseContext) {} + +// EnterDropFrontendClause is called when production dropFrontendClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropFrontendClause(ctx *DropFrontendClauseContext) {} + +// ExitDropFrontendClause is called when production dropFrontendClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropFrontendClause(ctx *DropFrontendClauseContext) {} + +// EnterModifyFrontendHostClause is called when production modifyFrontendHostClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) { +} + +// ExitModifyFrontendHostClause is called when production modifyFrontendHostClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) { +} + +// EnterAddBackendClause is called when production addBackendClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddBackendClause(ctx *AddBackendClauseContext) {} + +// ExitAddBackendClause is called when production addBackendClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddBackendClause(ctx *AddBackendClauseContext) {} + +// EnterDropBackendClause is called when production dropBackendClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropBackendClause(ctx *DropBackendClauseContext) {} + +// ExitDropBackendClause is called when production dropBackendClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropBackendClause(ctx *DropBackendClauseContext) {} + +// EnterDecommissionBackendClause is called when production decommissionBackendClause is entered. +func (s *BaseStarRocksSQLListener) EnterDecommissionBackendClause(ctx *DecommissionBackendClauseContext) { +} + +// ExitDecommissionBackendClause is called when production decommissionBackendClause is exited. +func (s *BaseStarRocksSQLListener) ExitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) { +} + +// EnterModifyBackendClause is called when production modifyBackendClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyBackendClause(ctx *ModifyBackendClauseContext) {} + +// ExitModifyBackendClause is called when production modifyBackendClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyBackendClause(ctx *ModifyBackendClauseContext) {} + +// EnterAddComputeNodeClause is called when production addComputeNodeClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddComputeNodeClause(ctx *AddComputeNodeClauseContext) {} + +// ExitAddComputeNodeClause is called when production addComputeNodeClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddComputeNodeClause(ctx *AddComputeNodeClauseContext) {} + +// EnterDropComputeNodeClause is called when production dropComputeNodeClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropComputeNodeClause(ctx *DropComputeNodeClauseContext) {} + +// ExitDropComputeNodeClause is called when production dropComputeNodeClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropComputeNodeClause(ctx *DropComputeNodeClauseContext) {} + +// EnterModifyBrokerClause is called when production modifyBrokerClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyBrokerClause(ctx *ModifyBrokerClauseContext) {} + +// ExitModifyBrokerClause is called when production modifyBrokerClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyBrokerClause(ctx *ModifyBrokerClauseContext) {} + +// EnterAlterLoadErrorUrlClause is called when production alterLoadErrorUrlClause is entered. +func (s *BaseStarRocksSQLListener) EnterAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) { +} + +// ExitAlterLoadErrorUrlClause is called when production alterLoadErrorUrlClause is exited. +func (s *BaseStarRocksSQLListener) ExitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) {} + +// EnterCreateImageClause is called when production createImageClause is entered. +func (s *BaseStarRocksSQLListener) EnterCreateImageClause(ctx *CreateImageClauseContext) {} + +// ExitCreateImageClause is called when production createImageClause is exited. +func (s *BaseStarRocksSQLListener) ExitCreateImageClause(ctx *CreateImageClauseContext) {} + +// EnterCleanTabletSchedQClause is called when production cleanTabletSchedQClause is entered. +func (s *BaseStarRocksSQLListener) EnterCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) { +} + +// ExitCleanTabletSchedQClause is called when production cleanTabletSchedQClause is exited. +func (s *BaseStarRocksSQLListener) ExitCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) {} + +// EnterDecommissionDiskClause is called when production decommissionDiskClause is entered. +func (s *BaseStarRocksSQLListener) EnterDecommissionDiskClause(ctx *DecommissionDiskClauseContext) {} + +// ExitDecommissionDiskClause is called when production decommissionDiskClause is exited. +func (s *BaseStarRocksSQLListener) ExitDecommissionDiskClause(ctx *DecommissionDiskClauseContext) {} + +// EnterCancelDecommissionDiskClause is called when production cancelDecommissionDiskClause is entered. +func (s *BaseStarRocksSQLListener) EnterCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) { +} + +// ExitCancelDecommissionDiskClause is called when production cancelDecommissionDiskClause is exited. +func (s *BaseStarRocksSQLListener) ExitCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) { +} + +// EnterDisableDiskClause is called when production disableDiskClause is entered. +func (s *BaseStarRocksSQLListener) EnterDisableDiskClause(ctx *DisableDiskClauseContext) {} + +// ExitDisableDiskClause is called when production disableDiskClause is exited. +func (s *BaseStarRocksSQLListener) ExitDisableDiskClause(ctx *DisableDiskClauseContext) {} + +// EnterCancelDisableDiskClause is called when production cancelDisableDiskClause is entered. +func (s *BaseStarRocksSQLListener) EnterCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) { +} + +// ExitCancelDisableDiskClause is called when production cancelDisableDiskClause is exited. +func (s *BaseStarRocksSQLListener) ExitCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) {} + +// EnterCreateIndexClause is called when production createIndexClause is entered. +func (s *BaseStarRocksSQLListener) EnterCreateIndexClause(ctx *CreateIndexClauseContext) {} + +// ExitCreateIndexClause is called when production createIndexClause is exited. +func (s *BaseStarRocksSQLListener) ExitCreateIndexClause(ctx *CreateIndexClauseContext) {} + +// EnterDropIndexClause is called when production dropIndexClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropIndexClause(ctx *DropIndexClauseContext) {} + +// ExitDropIndexClause is called when production dropIndexClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropIndexClause(ctx *DropIndexClauseContext) {} + +// EnterTableRenameClause is called when production tableRenameClause is entered. +func (s *BaseStarRocksSQLListener) EnterTableRenameClause(ctx *TableRenameClauseContext) {} + +// ExitTableRenameClause is called when production tableRenameClause is exited. +func (s *BaseStarRocksSQLListener) ExitTableRenameClause(ctx *TableRenameClauseContext) {} + +// EnterSwapTableClause is called when production swapTableClause is entered. +func (s *BaseStarRocksSQLListener) EnterSwapTableClause(ctx *SwapTableClauseContext) {} + +// ExitSwapTableClause is called when production swapTableClause is exited. +func (s *BaseStarRocksSQLListener) ExitSwapTableClause(ctx *SwapTableClauseContext) {} + +// EnterModifyPropertiesClause is called when production modifyPropertiesClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) {} + +// ExitModifyPropertiesClause is called when production modifyPropertiesClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) {} + +// EnterModifyCommentClause is called when production modifyCommentClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyCommentClause(ctx *ModifyCommentClauseContext) {} + +// ExitModifyCommentClause is called when production modifyCommentClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyCommentClause(ctx *ModifyCommentClauseContext) {} + +// EnterOptimizeRange is called when production optimizeRange is entered. +func (s *BaseStarRocksSQLListener) EnterOptimizeRange(ctx *OptimizeRangeContext) {} + +// ExitOptimizeRange is called when production optimizeRange is exited. +func (s *BaseStarRocksSQLListener) ExitOptimizeRange(ctx *OptimizeRangeContext) {} + +// EnterOptimizeClause is called when production optimizeClause is entered. +func (s *BaseStarRocksSQLListener) EnterOptimizeClause(ctx *OptimizeClauseContext) {} + +// ExitOptimizeClause is called when production optimizeClause is exited. +func (s *BaseStarRocksSQLListener) ExitOptimizeClause(ctx *OptimizeClauseContext) {} + +// EnterAddColumnClause is called when production addColumnClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddColumnClause(ctx *AddColumnClauseContext) {} + +// ExitAddColumnClause is called when production addColumnClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddColumnClause(ctx *AddColumnClauseContext) {} + +// EnterAddColumnsClause is called when production addColumnsClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddColumnsClause(ctx *AddColumnsClauseContext) {} + +// ExitAddColumnsClause is called when production addColumnsClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddColumnsClause(ctx *AddColumnsClauseContext) {} + +// EnterDropColumnClause is called when production dropColumnClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropColumnClause(ctx *DropColumnClauseContext) {} + +// ExitDropColumnClause is called when production dropColumnClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropColumnClause(ctx *DropColumnClauseContext) {} + +// EnterModifyColumnClause is called when production modifyColumnClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyColumnClause(ctx *ModifyColumnClauseContext) {} + +// ExitModifyColumnClause is called when production modifyColumnClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyColumnClause(ctx *ModifyColumnClauseContext) {} + +// EnterModifyColumnCommentClause is called when production modifyColumnCommentClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) { +} + +// ExitModifyColumnCommentClause is called when production modifyColumnCommentClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) { +} + +// EnterColumnRenameClause is called when production columnRenameClause is entered. +func (s *BaseStarRocksSQLListener) EnterColumnRenameClause(ctx *ColumnRenameClauseContext) {} + +// ExitColumnRenameClause is called when production columnRenameClause is exited. +func (s *BaseStarRocksSQLListener) ExitColumnRenameClause(ctx *ColumnRenameClauseContext) {} + +// EnterReorderColumnsClause is called when production reorderColumnsClause is entered. +func (s *BaseStarRocksSQLListener) EnterReorderColumnsClause(ctx *ReorderColumnsClauseContext) {} + +// ExitReorderColumnsClause is called when production reorderColumnsClause is exited. +func (s *BaseStarRocksSQLListener) ExitReorderColumnsClause(ctx *ReorderColumnsClauseContext) {} + +// EnterRollupRenameClause is called when production rollupRenameClause is entered. +func (s *BaseStarRocksSQLListener) EnterRollupRenameClause(ctx *RollupRenameClauseContext) {} + +// ExitRollupRenameClause is called when production rollupRenameClause is exited. +func (s *BaseStarRocksSQLListener) ExitRollupRenameClause(ctx *RollupRenameClauseContext) {} + +// EnterCompactionClause is called when production compactionClause is entered. +func (s *BaseStarRocksSQLListener) EnterCompactionClause(ctx *CompactionClauseContext) {} + +// ExitCompactionClause is called when production compactionClause is exited. +func (s *BaseStarRocksSQLListener) ExitCompactionClause(ctx *CompactionClauseContext) {} + +// EnterSubfieldName is called when production subfieldName is entered. +func (s *BaseStarRocksSQLListener) EnterSubfieldName(ctx *SubfieldNameContext) {} + +// ExitSubfieldName is called when production subfieldName is exited. +func (s *BaseStarRocksSQLListener) ExitSubfieldName(ctx *SubfieldNameContext) {} + +// EnterNestedFieldName is called when production nestedFieldName is entered. +func (s *BaseStarRocksSQLListener) EnterNestedFieldName(ctx *NestedFieldNameContext) {} + +// ExitNestedFieldName is called when production nestedFieldName is exited. +func (s *BaseStarRocksSQLListener) ExitNestedFieldName(ctx *NestedFieldNameContext) {} + +// EnterAddFieldClause is called when production addFieldClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddFieldClause(ctx *AddFieldClauseContext) {} + +// ExitAddFieldClause is called when production addFieldClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddFieldClause(ctx *AddFieldClauseContext) {} + +// EnterDropFieldClause is called when production dropFieldClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropFieldClause(ctx *DropFieldClauseContext) {} + +// ExitDropFieldClause is called when production dropFieldClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropFieldClause(ctx *DropFieldClauseContext) {} + +// EnterCreateOrReplaceTagClause is called when production createOrReplaceTagClause is entered. +func (s *BaseStarRocksSQLListener) EnterCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) { +} + +// ExitCreateOrReplaceTagClause is called when production createOrReplaceTagClause is exited. +func (s *BaseStarRocksSQLListener) ExitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) { +} + +// EnterCreateOrReplaceBranchClause is called when production createOrReplaceBranchClause is entered. +func (s *BaseStarRocksSQLListener) EnterCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) { +} + +// ExitCreateOrReplaceBranchClause is called when production createOrReplaceBranchClause is exited. +func (s *BaseStarRocksSQLListener) ExitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) { +} + +// EnterDropBranchClause is called when production dropBranchClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropBranchClause(ctx *DropBranchClauseContext) {} + +// ExitDropBranchClause is called when production dropBranchClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropBranchClause(ctx *DropBranchClauseContext) {} + +// EnterDropTagClause is called when production dropTagClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropTagClause(ctx *DropTagClauseContext) {} + +// ExitDropTagClause is called when production dropTagClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropTagClause(ctx *DropTagClauseContext) {} + +// EnterTableOperationClause is called when production tableOperationClause is entered. +func (s *BaseStarRocksSQLListener) EnterTableOperationClause(ctx *TableOperationClauseContext) {} + +// ExitTableOperationClause is called when production tableOperationClause is exited. +func (s *BaseStarRocksSQLListener) ExitTableOperationClause(ctx *TableOperationClauseContext) {} + +// EnterTagOptions is called when production tagOptions is entered. +func (s *BaseStarRocksSQLListener) EnterTagOptions(ctx *TagOptionsContext) {} + +// ExitTagOptions is called when production tagOptions is exited. +func (s *BaseStarRocksSQLListener) ExitTagOptions(ctx *TagOptionsContext) {} + +// EnterBranchOptions is called when production branchOptions is entered. +func (s *BaseStarRocksSQLListener) EnterBranchOptions(ctx *BranchOptionsContext) {} + +// ExitBranchOptions is called when production branchOptions is exited. +func (s *BaseStarRocksSQLListener) ExitBranchOptions(ctx *BranchOptionsContext) {} + +// EnterSnapshotRetention is called when production snapshotRetention is entered. +func (s *BaseStarRocksSQLListener) EnterSnapshotRetention(ctx *SnapshotRetentionContext) {} + +// ExitSnapshotRetention is called when production snapshotRetention is exited. +func (s *BaseStarRocksSQLListener) ExitSnapshotRetention(ctx *SnapshotRetentionContext) {} + +// EnterRefRetain is called when production refRetain is entered. +func (s *BaseStarRocksSQLListener) EnterRefRetain(ctx *RefRetainContext) {} + +// ExitRefRetain is called when production refRetain is exited. +func (s *BaseStarRocksSQLListener) ExitRefRetain(ctx *RefRetainContext) {} + +// EnterMaxSnapshotAge is called when production maxSnapshotAge is entered. +func (s *BaseStarRocksSQLListener) EnterMaxSnapshotAge(ctx *MaxSnapshotAgeContext) {} + +// ExitMaxSnapshotAge is called when production maxSnapshotAge is exited. +func (s *BaseStarRocksSQLListener) ExitMaxSnapshotAge(ctx *MaxSnapshotAgeContext) {} + +// EnterMinSnapshotsToKeep is called when production minSnapshotsToKeep is entered. +func (s *BaseStarRocksSQLListener) EnterMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) {} + +// ExitMinSnapshotsToKeep is called when production minSnapshotsToKeep is exited. +func (s *BaseStarRocksSQLListener) ExitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) {} + +// EnterSnapshotId is called when production snapshotId is entered. +func (s *BaseStarRocksSQLListener) EnterSnapshotId(ctx *SnapshotIdContext) {} + +// ExitSnapshotId is called when production snapshotId is exited. +func (s *BaseStarRocksSQLListener) ExitSnapshotId(ctx *SnapshotIdContext) {} + +// EnterTimeUnit is called when production timeUnit is entered. +func (s *BaseStarRocksSQLListener) EnterTimeUnit(ctx *TimeUnitContext) {} + +// ExitTimeUnit is called when production timeUnit is exited. +func (s *BaseStarRocksSQLListener) ExitTimeUnit(ctx *TimeUnitContext) {} + +// EnterInteger_list is called when production integer_list is entered. +func (s *BaseStarRocksSQLListener) EnterInteger_list(ctx *Integer_listContext) {} + +// ExitInteger_list is called when production integer_list is exited. +func (s *BaseStarRocksSQLListener) ExitInteger_list(ctx *Integer_listContext) {} + +// EnterDropPersistentIndexClause is called when production dropPersistentIndexClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) { +} + +// ExitDropPersistentIndexClause is called when production dropPersistentIndexClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) { +} + +// EnterAddPartitionClause is called when production addPartitionClause is entered. +func (s *BaseStarRocksSQLListener) EnterAddPartitionClause(ctx *AddPartitionClauseContext) {} + +// ExitAddPartitionClause is called when production addPartitionClause is exited. +func (s *BaseStarRocksSQLListener) ExitAddPartitionClause(ctx *AddPartitionClauseContext) {} + +// EnterDropPartitionClause is called when production dropPartitionClause is entered. +func (s *BaseStarRocksSQLListener) EnterDropPartitionClause(ctx *DropPartitionClauseContext) {} + +// ExitDropPartitionClause is called when production dropPartitionClause is exited. +func (s *BaseStarRocksSQLListener) ExitDropPartitionClause(ctx *DropPartitionClauseContext) {} + +// EnterTruncatePartitionClause is called when production truncatePartitionClause is entered. +func (s *BaseStarRocksSQLListener) EnterTruncatePartitionClause(ctx *TruncatePartitionClauseContext) { +} + +// ExitTruncatePartitionClause is called when production truncatePartitionClause is exited. +func (s *BaseStarRocksSQLListener) ExitTruncatePartitionClause(ctx *TruncatePartitionClauseContext) {} + +// EnterModifyPartitionClause is called when production modifyPartitionClause is entered. +func (s *BaseStarRocksSQLListener) EnterModifyPartitionClause(ctx *ModifyPartitionClauseContext) {} + +// ExitModifyPartitionClause is called when production modifyPartitionClause is exited. +func (s *BaseStarRocksSQLListener) ExitModifyPartitionClause(ctx *ModifyPartitionClauseContext) {} + +// EnterReplacePartitionClause is called when production replacePartitionClause is entered. +func (s *BaseStarRocksSQLListener) EnterReplacePartitionClause(ctx *ReplacePartitionClauseContext) {} + +// ExitReplacePartitionClause is called when production replacePartitionClause is exited. +func (s *BaseStarRocksSQLListener) ExitReplacePartitionClause(ctx *ReplacePartitionClauseContext) {} + +// EnterPartitionRenameClause is called when production partitionRenameClause is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionRenameClause(ctx *PartitionRenameClauseContext) {} + +// ExitPartitionRenameClause is called when production partitionRenameClause is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionRenameClause(ctx *PartitionRenameClauseContext) {} + +// EnterInsertStatement is called when production insertStatement is entered. +func (s *BaseStarRocksSQLListener) EnterInsertStatement(ctx *InsertStatementContext) {} + +// ExitInsertStatement is called when production insertStatement is exited. +func (s *BaseStarRocksSQLListener) ExitInsertStatement(ctx *InsertStatementContext) {} + +// EnterInsertLabelOrColumnAliases is called when production insertLabelOrColumnAliases is entered. +func (s *BaseStarRocksSQLListener) EnterInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) { +} + +// ExitInsertLabelOrColumnAliases is called when production insertLabelOrColumnAliases is exited. +func (s *BaseStarRocksSQLListener) ExitInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) { +} + +// EnterColumnAliasesOrByName is called when production columnAliasesOrByName is entered. +func (s *BaseStarRocksSQLListener) EnterColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) {} + +// ExitColumnAliasesOrByName is called when production columnAliasesOrByName is exited. +func (s *BaseStarRocksSQLListener) ExitColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) {} + +// EnterUpdateStatement is called when production updateStatement is entered. +func (s *BaseStarRocksSQLListener) EnterUpdateStatement(ctx *UpdateStatementContext) {} + +// ExitUpdateStatement is called when production updateStatement is exited. +func (s *BaseStarRocksSQLListener) ExitUpdateStatement(ctx *UpdateStatementContext) {} + +// EnterDeleteStatement is called when production deleteStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDeleteStatement(ctx *DeleteStatementContext) {} + +// ExitDeleteStatement is called when production deleteStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDeleteStatement(ctx *DeleteStatementContext) {} + +// EnterCreateRoutineLoadStatement is called when production createRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) { +} + +// ExitCreateRoutineLoadStatement is called when production createRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) { +} + +// EnterAlterRoutineLoadStatement is called when production alterRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) { +} + +// ExitAlterRoutineLoadStatement is called when production alterRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) { +} + +// EnterDataSource is called when production dataSource is entered. +func (s *BaseStarRocksSQLListener) EnterDataSource(ctx *DataSourceContext) {} + +// ExitDataSource is called when production dataSource is exited. +func (s *BaseStarRocksSQLListener) ExitDataSource(ctx *DataSourceContext) {} + +// EnterLoadProperties is called when production loadProperties is entered. +func (s *BaseStarRocksSQLListener) EnterLoadProperties(ctx *LoadPropertiesContext) {} + +// ExitLoadProperties is called when production loadProperties is exited. +func (s *BaseStarRocksSQLListener) ExitLoadProperties(ctx *LoadPropertiesContext) {} + +// EnterColSeparatorProperty is called when production colSeparatorProperty is entered. +func (s *BaseStarRocksSQLListener) EnterColSeparatorProperty(ctx *ColSeparatorPropertyContext) {} + +// ExitColSeparatorProperty is called when production colSeparatorProperty is exited. +func (s *BaseStarRocksSQLListener) ExitColSeparatorProperty(ctx *ColSeparatorPropertyContext) {} + +// EnterRowDelimiterProperty is called when production rowDelimiterProperty is entered. +func (s *BaseStarRocksSQLListener) EnterRowDelimiterProperty(ctx *RowDelimiterPropertyContext) {} + +// ExitRowDelimiterProperty is called when production rowDelimiterProperty is exited. +func (s *BaseStarRocksSQLListener) ExitRowDelimiterProperty(ctx *RowDelimiterPropertyContext) {} + +// EnterImportColumns is called when production importColumns is entered. +func (s *BaseStarRocksSQLListener) EnterImportColumns(ctx *ImportColumnsContext) {} + +// ExitImportColumns is called when production importColumns is exited. +func (s *BaseStarRocksSQLListener) ExitImportColumns(ctx *ImportColumnsContext) {} + +// EnterColumnProperties is called when production columnProperties is entered. +func (s *BaseStarRocksSQLListener) EnterColumnProperties(ctx *ColumnPropertiesContext) {} + +// ExitColumnProperties is called when production columnProperties is exited. +func (s *BaseStarRocksSQLListener) ExitColumnProperties(ctx *ColumnPropertiesContext) {} + +// EnterJobProperties is called when production jobProperties is entered. +func (s *BaseStarRocksSQLListener) EnterJobProperties(ctx *JobPropertiesContext) {} + +// ExitJobProperties is called when production jobProperties is exited. +func (s *BaseStarRocksSQLListener) ExitJobProperties(ctx *JobPropertiesContext) {} + +// EnterDataSourceProperties is called when production dataSourceProperties is entered. +func (s *BaseStarRocksSQLListener) EnterDataSourceProperties(ctx *DataSourcePropertiesContext) {} + +// ExitDataSourceProperties is called when production dataSourceProperties is exited. +func (s *BaseStarRocksSQLListener) ExitDataSourceProperties(ctx *DataSourcePropertiesContext) {} + +// EnterStopRoutineLoadStatement is called when production stopRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) { +} + +// ExitStopRoutineLoadStatement is called when production stopRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) { +} + +// EnterResumeRoutineLoadStatement is called when production resumeRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) { +} + +// ExitResumeRoutineLoadStatement is called when production resumeRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) { +} + +// EnterPauseRoutineLoadStatement is called when production pauseRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) { +} + +// ExitPauseRoutineLoadStatement is called when production pauseRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) { +} + +// EnterShowRoutineLoadStatement is called when production showRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) { +} + +// ExitShowRoutineLoadStatement is called when production showRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) { +} + +// EnterShowRoutineLoadTaskStatement is called when production showRoutineLoadTaskStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) { +} + +// ExitShowRoutineLoadTaskStatement is called when production showRoutineLoadTaskStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) { +} + +// EnterShowCreateRoutineLoadStatement is called when production showCreateRoutineLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) { +} + +// ExitShowCreateRoutineLoadStatement is called when production showCreateRoutineLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) { +} + +// EnterShowStreamLoadStatement is called when production showStreamLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) { +} + +// ExitShowStreamLoadStatement is called when production showStreamLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) {} + +// EnterAnalyzeStatement is called when production analyzeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAnalyzeStatement(ctx *AnalyzeStatementContext) {} + +// ExitAnalyzeStatement is called when production analyzeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAnalyzeStatement(ctx *AnalyzeStatementContext) {} + +// EnterRegularColumns is called when production regularColumns is entered. +func (s *BaseStarRocksSQLListener) EnterRegularColumns(ctx *RegularColumnsContext) {} + +// ExitRegularColumns is called when production regularColumns is exited. +func (s *BaseStarRocksSQLListener) ExitRegularColumns(ctx *RegularColumnsContext) {} + +// EnterAllColumns is called when production allColumns is entered. +func (s *BaseStarRocksSQLListener) EnterAllColumns(ctx *AllColumnsContext) {} + +// ExitAllColumns is called when production allColumns is exited. +func (s *BaseStarRocksSQLListener) ExitAllColumns(ctx *AllColumnsContext) {} + +// EnterPredicateColumns is called when production predicateColumns is entered. +func (s *BaseStarRocksSQLListener) EnterPredicateColumns(ctx *PredicateColumnsContext) {} + +// ExitPredicateColumns is called when production predicateColumns is exited. +func (s *BaseStarRocksSQLListener) ExitPredicateColumns(ctx *PredicateColumnsContext) {} + +// EnterMultiColumnSet is called when production multiColumnSet is entered. +func (s *BaseStarRocksSQLListener) EnterMultiColumnSet(ctx *MultiColumnSetContext) {} + +// ExitMultiColumnSet is called when production multiColumnSet is exited. +func (s *BaseStarRocksSQLListener) ExitMultiColumnSet(ctx *MultiColumnSetContext) {} + +// EnterDropStatsStatement is called when production dropStatsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropStatsStatement(ctx *DropStatsStatementContext) {} + +// ExitDropStatsStatement is called when production dropStatsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropStatsStatement(ctx *DropStatsStatementContext) {} + +// EnterHistogramStatement is called when production histogramStatement is entered. +func (s *BaseStarRocksSQLListener) EnterHistogramStatement(ctx *HistogramStatementContext) {} + +// ExitHistogramStatement is called when production histogramStatement is exited. +func (s *BaseStarRocksSQLListener) ExitHistogramStatement(ctx *HistogramStatementContext) {} + +// EnterAnalyzeHistogramStatement is called when production analyzeHistogramStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) { +} + +// ExitAnalyzeHistogramStatement is called when production analyzeHistogramStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) { +} + +// EnterDropHistogramStatement is called when production dropHistogramStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropHistogramStatement(ctx *DropHistogramStatementContext) {} + +// ExitDropHistogramStatement is called when production dropHistogramStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropHistogramStatement(ctx *DropHistogramStatementContext) {} + +// EnterCreateAnalyzeStatement is called when production createAnalyzeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) {} + +// ExitCreateAnalyzeStatement is called when production createAnalyzeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) {} + +// EnterDropAnalyzeJobStatement is called when production dropAnalyzeJobStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) { +} + +// ExitDropAnalyzeJobStatement is called when production dropAnalyzeJobStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) {} + +// EnterShowAnalyzeStatement is called when production showAnalyzeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) {} + +// ExitShowAnalyzeStatement is called when production showAnalyzeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) {} + +// EnterShowStatsMetaStatement is called when production showStatsMetaStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) {} + +// ExitShowStatsMetaStatement is called when production showStatsMetaStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) {} + +// EnterShowHistogramMetaStatement is called when production showHistogramMetaStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) { +} + +// ExitShowHistogramMetaStatement is called when production showHistogramMetaStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) { +} + +// EnterKillAnalyzeStatement is called when production killAnalyzeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) {} + +// ExitKillAnalyzeStatement is called when production killAnalyzeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) {} + +// EnterAnalyzeProfileStatement is called when production analyzeProfileStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) { +} + +// ExitAnalyzeProfileStatement is called when production analyzeProfileStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) {} + +// EnterCreateBaselinePlanStatement is called when production createBaselinePlanStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) { +} + +// ExitCreateBaselinePlanStatement is called when production createBaselinePlanStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) { +} + +// EnterDropBaselinePlanStatement is called when production dropBaselinePlanStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) { +} + +// ExitDropBaselinePlanStatement is called when production dropBaselinePlanStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) { +} + +// EnterShowBaselinePlanStatement is called when production showBaselinePlanStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) { +} + +// ExitShowBaselinePlanStatement is called when production showBaselinePlanStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) { +} + +// EnterCreateResourceGroupStatement is called when production createResourceGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) { +} + +// ExitCreateResourceGroupStatement is called when production createResourceGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) { +} + +// EnterDropResourceGroupStatement is called when production dropResourceGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) { +} + +// ExitDropResourceGroupStatement is called when production dropResourceGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) { +} + +// EnterAlterResourceGroupStatement is called when production alterResourceGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) { +} + +// ExitAlterResourceGroupStatement is called when production alterResourceGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) { +} + +// EnterShowResourceGroupStatement is called when production showResourceGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) { +} + +// ExitShowResourceGroupStatement is called when production showResourceGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) { +} + +// EnterShowResourceGroupUsageStatement is called when production showResourceGroupUsageStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) { +} + +// ExitShowResourceGroupUsageStatement is called when production showResourceGroupUsageStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) { +} + +// EnterCreateResourceStatement is called when production createResourceStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateResourceStatement(ctx *CreateResourceStatementContext) { +} + +// ExitCreateResourceStatement is called when production createResourceStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateResourceStatement(ctx *CreateResourceStatementContext) {} + +// EnterAlterResourceStatement is called when production alterResourceStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterResourceStatement(ctx *AlterResourceStatementContext) {} + +// ExitAlterResourceStatement is called when production alterResourceStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterResourceStatement(ctx *AlterResourceStatementContext) {} + +// EnterDropResourceStatement is called when production dropResourceStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropResourceStatement(ctx *DropResourceStatementContext) {} + +// ExitDropResourceStatement is called when production dropResourceStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropResourceStatement(ctx *DropResourceStatementContext) {} + +// EnterShowResourceStatement is called when production showResourceStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowResourceStatement(ctx *ShowResourceStatementContext) {} + +// ExitShowResourceStatement is called when production showResourceStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowResourceStatement(ctx *ShowResourceStatementContext) {} + +// EnterClassifier is called when production classifier is entered. +func (s *BaseStarRocksSQLListener) EnterClassifier(ctx *ClassifierContext) {} + +// ExitClassifier is called when production classifier is exited. +func (s *BaseStarRocksSQLListener) ExitClassifier(ctx *ClassifierContext) {} + +// EnterShowFunctionsStatement is called when production showFunctionsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowFunctionsStatement(ctx *ShowFunctionsStatementContext) {} + +// ExitShowFunctionsStatement is called when production showFunctionsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowFunctionsStatement(ctx *ShowFunctionsStatementContext) {} + +// EnterDropFunctionStatement is called when production dropFunctionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropFunctionStatement(ctx *DropFunctionStatementContext) {} + +// ExitDropFunctionStatement is called when production dropFunctionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropFunctionStatement(ctx *DropFunctionStatementContext) {} + +// EnterCreateFunctionStatement is called when production createFunctionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateFunctionStatement(ctx *CreateFunctionStatementContext) { +} + +// ExitCreateFunctionStatement is called when production createFunctionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateFunctionStatement(ctx *CreateFunctionStatementContext) {} + +// EnterInlineFunction is called when production inlineFunction is entered. +func (s *BaseStarRocksSQLListener) EnterInlineFunction(ctx *InlineFunctionContext) {} + +// ExitInlineFunction is called when production inlineFunction is exited. +func (s *BaseStarRocksSQLListener) ExitInlineFunction(ctx *InlineFunctionContext) {} + +// EnterTypeList is called when production typeList is entered. +func (s *BaseStarRocksSQLListener) EnterTypeList(ctx *TypeListContext) {} + +// ExitTypeList is called when production typeList is exited. +func (s *BaseStarRocksSQLListener) ExitTypeList(ctx *TypeListContext) {} + +// EnterLoadStatement is called when production loadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterLoadStatement(ctx *LoadStatementContext) {} + +// ExitLoadStatement is called when production loadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitLoadStatement(ctx *LoadStatementContext) {} + +// EnterLabelName is called when production labelName is entered. +func (s *BaseStarRocksSQLListener) EnterLabelName(ctx *LabelNameContext) {} + +// ExitLabelName is called when production labelName is exited. +func (s *BaseStarRocksSQLListener) ExitLabelName(ctx *LabelNameContext) {} + +// EnterDataDescList is called when production dataDescList is entered. +func (s *BaseStarRocksSQLListener) EnterDataDescList(ctx *DataDescListContext) {} + +// ExitDataDescList is called when production dataDescList is exited. +func (s *BaseStarRocksSQLListener) ExitDataDescList(ctx *DataDescListContext) {} + +// EnterDataDesc is called when production dataDesc is entered. +func (s *BaseStarRocksSQLListener) EnterDataDesc(ctx *DataDescContext) {} + +// ExitDataDesc is called when production dataDesc is exited. +func (s *BaseStarRocksSQLListener) ExitDataDesc(ctx *DataDescContext) {} + +// EnterFormatProps is called when production formatProps is entered. +func (s *BaseStarRocksSQLListener) EnterFormatProps(ctx *FormatPropsContext) {} + +// ExitFormatProps is called when production formatProps is exited. +func (s *BaseStarRocksSQLListener) ExitFormatProps(ctx *FormatPropsContext) {} + +// EnterBrokerDesc is called when production brokerDesc is entered. +func (s *BaseStarRocksSQLListener) EnterBrokerDesc(ctx *BrokerDescContext) {} + +// ExitBrokerDesc is called when production brokerDesc is exited. +func (s *BaseStarRocksSQLListener) ExitBrokerDesc(ctx *BrokerDescContext) {} + +// EnterResourceDesc is called when production resourceDesc is entered. +func (s *BaseStarRocksSQLListener) EnterResourceDesc(ctx *ResourceDescContext) {} + +// ExitResourceDesc is called when production resourceDesc is exited. +func (s *BaseStarRocksSQLListener) ExitResourceDesc(ctx *ResourceDescContext) {} + +// EnterShowLoadStatement is called when production showLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowLoadStatement(ctx *ShowLoadStatementContext) {} + +// ExitShowLoadStatement is called when production showLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowLoadStatement(ctx *ShowLoadStatementContext) {} + +// EnterShowLoadWarningsStatement is called when production showLoadWarningsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) { +} + +// ExitShowLoadWarningsStatement is called when production showLoadWarningsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) { +} + +// EnterCancelLoadStatement is called when production cancelLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelLoadStatement(ctx *CancelLoadStatementContext) {} + +// ExitCancelLoadStatement is called when production cancelLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelLoadStatement(ctx *CancelLoadStatementContext) {} + +// EnterAlterLoadStatement is called when production alterLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterLoadStatement(ctx *AlterLoadStatementContext) {} + +// ExitAlterLoadStatement is called when production alterLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterLoadStatement(ctx *AlterLoadStatementContext) {} + +// EnterCancelCompactionStatement is called when production cancelCompactionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelCompactionStatement(ctx *CancelCompactionStatementContext) { +} + +// ExitCancelCompactionStatement is called when production cancelCompactionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelCompactionStatement(ctx *CancelCompactionStatementContext) { +} + +// EnterShowAuthorStatement is called when production showAuthorStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowAuthorStatement(ctx *ShowAuthorStatementContext) {} + +// ExitShowAuthorStatement is called when production showAuthorStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowAuthorStatement(ctx *ShowAuthorStatementContext) {} + +// EnterShowBackendsStatement is called when production showBackendsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowBackendsStatement(ctx *ShowBackendsStatementContext) {} + +// ExitShowBackendsStatement is called when production showBackendsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowBackendsStatement(ctx *ShowBackendsStatementContext) {} + +// EnterShowBrokerStatement is called when production showBrokerStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowBrokerStatement(ctx *ShowBrokerStatementContext) {} + +// ExitShowBrokerStatement is called when production showBrokerStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowBrokerStatement(ctx *ShowBrokerStatementContext) {} + +// EnterShowCharsetStatement is called when production showCharsetStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCharsetStatement(ctx *ShowCharsetStatementContext) {} + +// ExitShowCharsetStatement is called when production showCharsetStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCharsetStatement(ctx *ShowCharsetStatementContext) {} + +// EnterShowCollationStatement is called when production showCollationStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCollationStatement(ctx *ShowCollationStatementContext) {} + +// ExitShowCollationStatement is called when production showCollationStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCollationStatement(ctx *ShowCollationStatementContext) {} + +// EnterShowDeleteStatement is called when production showDeleteStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDeleteStatement(ctx *ShowDeleteStatementContext) {} + +// ExitShowDeleteStatement is called when production showDeleteStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDeleteStatement(ctx *ShowDeleteStatementContext) {} + +// EnterShowDynamicPartitionStatement is called when production showDynamicPartitionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) { +} + +// ExitShowDynamicPartitionStatement is called when production showDynamicPartitionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) { +} + +// EnterShowEventsStatement is called when production showEventsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowEventsStatement(ctx *ShowEventsStatementContext) {} + +// ExitShowEventsStatement is called when production showEventsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowEventsStatement(ctx *ShowEventsStatementContext) {} + +// EnterShowEnginesStatement is called when production showEnginesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowEnginesStatement(ctx *ShowEnginesStatementContext) {} + +// ExitShowEnginesStatement is called when production showEnginesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowEnginesStatement(ctx *ShowEnginesStatementContext) {} + +// EnterShowFrontendsStatement is called when production showFrontendsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowFrontendsStatement(ctx *ShowFrontendsStatementContext) {} + +// ExitShowFrontendsStatement is called when production showFrontendsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowFrontendsStatement(ctx *ShowFrontendsStatementContext) {} + +// EnterShowFrontendsDisksStatement is called when production showFrontendsDisksStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) { +} + +// ExitShowFrontendsDisksStatement is called when production showFrontendsDisksStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) { +} + +// EnterShowPluginsStatement is called when production showPluginsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPluginsStatement(ctx *ShowPluginsStatementContext) {} + +// ExitShowPluginsStatement is called when production showPluginsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPluginsStatement(ctx *ShowPluginsStatementContext) {} + +// EnterShowRepositoriesStatement is called when production showRepositoriesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) { +} + +// ExitShowRepositoriesStatement is called when production showRepositoriesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) { +} + +// EnterShowOpenTableStatement is called when production showOpenTableStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowOpenTableStatement(ctx *ShowOpenTableStatementContext) {} + +// ExitShowOpenTableStatement is called when production showOpenTableStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowOpenTableStatement(ctx *ShowOpenTableStatementContext) {} + +// EnterShowPrivilegesStatement is called when production showPrivilegesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) { +} + +// ExitShowPrivilegesStatement is called when production showPrivilegesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) {} + +// EnterShowProcedureStatement is called when production showProcedureStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowProcedureStatement(ctx *ShowProcedureStatementContext) {} + +// ExitShowProcedureStatement is called when production showProcedureStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowProcedureStatement(ctx *ShowProcedureStatementContext) {} + +// EnterShowProcStatement is called when production showProcStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowProcStatement(ctx *ShowProcStatementContext) {} + +// ExitShowProcStatement is called when production showProcStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowProcStatement(ctx *ShowProcStatementContext) {} + +// EnterShowProcesslistStatement is called when production showProcesslistStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowProcesslistStatement(ctx *ShowProcesslistStatementContext) { +} + +// ExitShowProcesslistStatement is called when production showProcesslistStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowProcesslistStatement(ctx *ShowProcesslistStatementContext) { +} + +// EnterShowProfilelistStatement is called when production showProfilelistStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowProfilelistStatement(ctx *ShowProfilelistStatementContext) { +} + +// ExitShowProfilelistStatement is called when production showProfilelistStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowProfilelistStatement(ctx *ShowProfilelistStatementContext) { +} + +// EnterShowRunningQueriesStatement is called when production showRunningQueriesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) { +} + +// ExitShowRunningQueriesStatement is called when production showRunningQueriesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) { +} + +// EnterShowStatusStatement is called when production showStatusStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowStatusStatement(ctx *ShowStatusStatementContext) {} + +// ExitShowStatusStatement is called when production showStatusStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowStatusStatement(ctx *ShowStatusStatementContext) {} + +// EnterShowTabletStatement is called when production showTabletStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTabletStatement(ctx *ShowTabletStatementContext) {} + +// ExitShowTabletStatement is called when production showTabletStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTabletStatement(ctx *ShowTabletStatementContext) {} + +// EnterShowTransactionStatement is called when production showTransactionStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTransactionStatement(ctx *ShowTransactionStatementContext) { +} + +// ExitShowTransactionStatement is called when production showTransactionStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTransactionStatement(ctx *ShowTransactionStatementContext) { +} + +// EnterShowTriggersStatement is called when production showTriggersStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTriggersStatement(ctx *ShowTriggersStatementContext) {} + +// ExitShowTriggersStatement is called when production showTriggersStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTriggersStatement(ctx *ShowTriggersStatementContext) {} + +// EnterShowUserPropertyStatement is called when production showUserPropertyStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) { +} + +// ExitShowUserPropertyStatement is called when production showUserPropertyStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) { +} + +// EnterShowVariablesStatement is called when production showVariablesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowVariablesStatement(ctx *ShowVariablesStatementContext) {} + +// ExitShowVariablesStatement is called when production showVariablesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowVariablesStatement(ctx *ShowVariablesStatementContext) {} + +// EnterShowWarningStatement is called when production showWarningStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowWarningStatement(ctx *ShowWarningStatementContext) {} + +// ExitShowWarningStatement is called when production showWarningStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowWarningStatement(ctx *ShowWarningStatementContext) {} + +// EnterHelpStatement is called when production helpStatement is entered. +func (s *BaseStarRocksSQLListener) EnterHelpStatement(ctx *HelpStatementContext) {} + +// ExitHelpStatement is called when production helpStatement is exited. +func (s *BaseStarRocksSQLListener) ExitHelpStatement(ctx *HelpStatementContext) {} + +// EnterShowQueryProfileStatement is called when production showQueryProfileStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) { +} + +// ExitShowQueryProfileStatement is called when production showQueryProfileStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) { +} + +// EnterShowQueryStatsStatement is called when production showQueryStatsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) { +} + +// ExitShowQueryStatsStatement is called when production showQueryStatsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) {} + +// EnterShowLoadProfileStatement is called when production showLoadProfileStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) { +} + +// ExitShowLoadProfileStatement is called when production showLoadProfileStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) { +} + +// EnterShowDataSkewStatement is called when production showDataSkewStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDataSkewStatement(ctx *ShowDataSkewStatementContext) {} + +// ExitShowDataSkewStatement is called when production showDataSkewStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDataSkewStatement(ctx *ShowDataSkewStatementContext) {} + +// EnterShowDataTypesStatement is called when production showDataTypesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDataTypesStatement(ctx *ShowDataTypesStatementContext) {} + +// ExitShowDataTypesStatement is called when production showDataTypesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDataTypesStatement(ctx *ShowDataTypesStatementContext) {} + +// EnterShowSyncJobStatement is called when production showSyncJobStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowSyncJobStatement(ctx *ShowSyncJobStatementContext) {} + +// ExitShowSyncJobStatement is called when production showSyncJobStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowSyncJobStatement(ctx *ShowSyncJobStatementContext) {} + +// EnterShowPolicyStatement is called when production showPolicyStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPolicyStatement(ctx *ShowPolicyStatementContext) {} + +// ExitShowPolicyStatement is called when production showPolicyStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPolicyStatement(ctx *ShowPolicyStatementContext) {} + +// EnterShowSqlBlockRuleStatement is called when production showSqlBlockRuleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) { +} + +// ExitShowSqlBlockRuleStatement is called when production showSqlBlockRuleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) { +} + +// EnterShowEncryptKeysStatement is called when production showEncryptKeysStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) { +} + +// ExitShowEncryptKeysStatement is called when production showEncryptKeysStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) { +} + +// EnterShowCreateLoadStatement is called when production showCreateLoadStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) { +} + +// ExitShowCreateLoadStatement is called when production showCreateLoadStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) {} + +// EnterShowCreateRepositoryStatement is called when production showCreateRepositoryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) { +} + +// ExitShowCreateRepositoryStatement is called when production showCreateRepositoryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) { +} + +// EnterShowLastInsertStatement is called when production showLastInsertStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowLastInsertStatement(ctx *ShowLastInsertStatementContext) { +} + +// ExitShowLastInsertStatement is called when production showLastInsertStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowLastInsertStatement(ctx *ShowLastInsertStatementContext) {} + +// EnterShowTableIdStatement is called when production showTableIdStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTableIdStatement(ctx *ShowTableIdStatementContext) {} + +// ExitShowTableIdStatement is called when production showTableIdStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTableIdStatement(ctx *ShowTableIdStatementContext) {} + +// EnterShowDatabaseIdStatement is called when production showDatabaseIdStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) { +} + +// ExitShowDatabaseIdStatement is called when production showDatabaseIdStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) {} + +// EnterShowPartitionIdStatement is called when production showPartitionIdStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) { +} + +// ExitShowPartitionIdStatement is called when production showPartitionIdStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) { +} + +// EnterShowTableStatsStatement is called when production showTableStatsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTableStatsStatement(ctx *ShowTableStatsStatementContext) { +} + +// ExitShowTableStatsStatement is called when production showTableStatsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTableStatsStatement(ctx *ShowTableStatsStatementContext) {} + +// EnterShowColumnStatsStatement is called when production showColumnStatsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) { +} + +// ExitShowColumnStatsStatement is called when production showColumnStatsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) { +} + +// EnterShowConvertLightSchemaChangeStatement is called when production showConvertLightSchemaChangeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) { +} + +// ExitShowConvertLightSchemaChangeStatement is called when production showConvertLightSchemaChangeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) { +} + +// EnterShowCatalogRecycleBinStatement is called when production showCatalogRecycleBinStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) { +} + +// ExitShowCatalogRecycleBinStatement is called when production showCatalogRecycleBinStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) { +} + +// EnterShowTrashStatement is called when production showTrashStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowTrashStatement(ctx *ShowTrashStatementContext) {} + +// ExitShowTrashStatement is called when production showTrashStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowTrashStatement(ctx *ShowTrashStatementContext) {} + +// EnterShowMigrationsStatement is called when production showMigrationsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowMigrationsStatement(ctx *ShowMigrationsStatementContext) { +} + +// ExitShowMigrationsStatement is called when production showMigrationsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowMigrationsStatement(ctx *ShowMigrationsStatementContext) {} + +// EnterShowWorkloadGroupsStatement is called when production showWorkloadGroupsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) { +} + +// ExitShowWorkloadGroupsStatement is called when production showWorkloadGroupsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) { +} + +// EnterShowJobTaskStatement is called when production showJobTaskStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowJobTaskStatement(ctx *ShowJobTaskStatementContext) {} + +// ExitShowJobTaskStatement is called when production showJobTaskStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowJobTaskStatement(ctx *ShowJobTaskStatementContext) {} + +// EnterCreateUserStatement is called when production createUserStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateUserStatement(ctx *CreateUserStatementContext) {} + +// ExitCreateUserStatement is called when production createUserStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateUserStatement(ctx *CreateUserStatementContext) {} + +// EnterDropUserStatement is called when production dropUserStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropUserStatement(ctx *DropUserStatementContext) {} + +// ExitDropUserStatement is called when production dropUserStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropUserStatement(ctx *DropUserStatementContext) {} + +// EnterAlterUserStatement is called when production alterUserStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterUserStatement(ctx *AlterUserStatementContext) {} + +// ExitAlterUserStatement is called when production alterUserStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterUserStatement(ctx *AlterUserStatementContext) {} + +// EnterShowUserStatement is called when production showUserStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowUserStatement(ctx *ShowUserStatementContext) {} + +// ExitShowUserStatement is called when production showUserStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowUserStatement(ctx *ShowUserStatementContext) {} + +// EnterShowAllAuthentication is called when production showAllAuthentication is entered. +func (s *BaseStarRocksSQLListener) EnterShowAllAuthentication(ctx *ShowAllAuthenticationContext) {} + +// ExitShowAllAuthentication is called when production showAllAuthentication is exited. +func (s *BaseStarRocksSQLListener) ExitShowAllAuthentication(ctx *ShowAllAuthenticationContext) {} + +// EnterShowAuthenticationForUser is called when production showAuthenticationForUser is entered. +func (s *BaseStarRocksSQLListener) EnterShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) { +} + +// ExitShowAuthenticationForUser is called when production showAuthenticationForUser is exited. +func (s *BaseStarRocksSQLListener) ExitShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) { +} + +// EnterExecuteAsStatement is called when production executeAsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterExecuteAsStatement(ctx *ExecuteAsStatementContext) {} + +// ExitExecuteAsStatement is called when production executeAsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitExecuteAsStatement(ctx *ExecuteAsStatementContext) {} + +// EnterCreateRoleStatement is called when production createRoleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateRoleStatement(ctx *CreateRoleStatementContext) {} + +// ExitCreateRoleStatement is called when production createRoleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateRoleStatement(ctx *CreateRoleStatementContext) {} + +// EnterAlterRoleStatement is called when production alterRoleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterRoleStatement(ctx *AlterRoleStatementContext) {} + +// ExitAlterRoleStatement is called when production alterRoleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterRoleStatement(ctx *AlterRoleStatementContext) {} + +// EnterDropRoleStatement is called when production dropRoleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropRoleStatement(ctx *DropRoleStatementContext) {} + +// ExitDropRoleStatement is called when production dropRoleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropRoleStatement(ctx *DropRoleStatementContext) {} + +// EnterShowRolesStatement is called when production showRolesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowRolesStatement(ctx *ShowRolesStatementContext) {} + +// ExitShowRolesStatement is called when production showRolesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowRolesStatement(ctx *ShowRolesStatementContext) {} + +// EnterGrantRoleToUser is called when production grantRoleToUser is entered. +func (s *BaseStarRocksSQLListener) EnterGrantRoleToUser(ctx *GrantRoleToUserContext) {} + +// ExitGrantRoleToUser is called when production grantRoleToUser is exited. +func (s *BaseStarRocksSQLListener) ExitGrantRoleToUser(ctx *GrantRoleToUserContext) {} + +// EnterGrantRoleToRole is called when production grantRoleToRole is entered. +func (s *BaseStarRocksSQLListener) EnterGrantRoleToRole(ctx *GrantRoleToRoleContext) {} + +// ExitGrantRoleToRole is called when production grantRoleToRole is exited. +func (s *BaseStarRocksSQLListener) ExitGrantRoleToRole(ctx *GrantRoleToRoleContext) {} + +// EnterRevokeRoleFromUser is called when production revokeRoleFromUser is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) {} + +// ExitRevokeRoleFromUser is called when production revokeRoleFromUser is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) {} + +// EnterRevokeRoleFromRole is called when production revokeRoleFromRole is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) {} + +// ExitRevokeRoleFromRole is called when production revokeRoleFromRole is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) {} + +// EnterSetRoleStatement is called when production setRoleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetRoleStatement(ctx *SetRoleStatementContext) {} + +// ExitSetRoleStatement is called when production setRoleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetRoleStatement(ctx *SetRoleStatementContext) {} + +// EnterSetDefaultRoleStatement is called when production setDefaultRoleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) { +} + +// ExitSetDefaultRoleStatement is called when production setDefaultRoleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) {} + +// EnterGrantRevokeClause is called when production grantRevokeClause is entered. +func (s *BaseStarRocksSQLListener) EnterGrantRevokeClause(ctx *GrantRevokeClauseContext) {} + +// ExitGrantRevokeClause is called when production grantRevokeClause is exited. +func (s *BaseStarRocksSQLListener) ExitGrantRevokeClause(ctx *GrantRevokeClauseContext) {} + +// EnterGrantOnUser is called when production grantOnUser is entered. +func (s *BaseStarRocksSQLListener) EnterGrantOnUser(ctx *GrantOnUserContext) {} + +// ExitGrantOnUser is called when production grantOnUser is exited. +func (s *BaseStarRocksSQLListener) ExitGrantOnUser(ctx *GrantOnUserContext) {} + +// EnterGrantOnTableBrief is called when production grantOnTableBrief is entered. +func (s *BaseStarRocksSQLListener) EnterGrantOnTableBrief(ctx *GrantOnTableBriefContext) {} + +// ExitGrantOnTableBrief is called when production grantOnTableBrief is exited. +func (s *BaseStarRocksSQLListener) ExitGrantOnTableBrief(ctx *GrantOnTableBriefContext) {} + +// EnterGrantOnFunc is called when production grantOnFunc is entered. +func (s *BaseStarRocksSQLListener) EnterGrantOnFunc(ctx *GrantOnFuncContext) {} + +// ExitGrantOnFunc is called when production grantOnFunc is exited. +func (s *BaseStarRocksSQLListener) ExitGrantOnFunc(ctx *GrantOnFuncContext) {} + +// EnterGrantOnSystem is called when production grantOnSystem is entered. +func (s *BaseStarRocksSQLListener) EnterGrantOnSystem(ctx *GrantOnSystemContext) {} + +// ExitGrantOnSystem is called when production grantOnSystem is exited. +func (s *BaseStarRocksSQLListener) ExitGrantOnSystem(ctx *GrantOnSystemContext) {} + +// EnterGrantOnPrimaryObj is called when production grantOnPrimaryObj is entered. +func (s *BaseStarRocksSQLListener) EnterGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) {} + +// ExitGrantOnPrimaryObj is called when production grantOnPrimaryObj is exited. +func (s *BaseStarRocksSQLListener) ExitGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) {} + +// EnterGrantOnAll is called when production grantOnAll is entered. +func (s *BaseStarRocksSQLListener) EnterGrantOnAll(ctx *GrantOnAllContext) {} + +// ExitGrantOnAll is called when production grantOnAll is exited. +func (s *BaseStarRocksSQLListener) ExitGrantOnAll(ctx *GrantOnAllContext) {} + +// EnterRevokeOnUser is called when production revokeOnUser is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeOnUser(ctx *RevokeOnUserContext) {} + +// ExitRevokeOnUser is called when production revokeOnUser is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeOnUser(ctx *RevokeOnUserContext) {} + +// EnterRevokeOnTableBrief is called when production revokeOnTableBrief is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) {} + +// ExitRevokeOnTableBrief is called when production revokeOnTableBrief is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) {} + +// EnterRevokeOnFunc is called when production revokeOnFunc is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeOnFunc(ctx *RevokeOnFuncContext) {} + +// ExitRevokeOnFunc is called when production revokeOnFunc is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeOnFunc(ctx *RevokeOnFuncContext) {} + +// EnterRevokeOnSystem is called when production revokeOnSystem is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeOnSystem(ctx *RevokeOnSystemContext) {} + +// ExitRevokeOnSystem is called when production revokeOnSystem is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeOnSystem(ctx *RevokeOnSystemContext) {} + +// EnterRevokeOnPrimaryObj is called when production revokeOnPrimaryObj is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) {} + +// ExitRevokeOnPrimaryObj is called when production revokeOnPrimaryObj is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) {} + +// EnterRevokeOnAll is called when production revokeOnAll is entered. +func (s *BaseStarRocksSQLListener) EnterRevokeOnAll(ctx *RevokeOnAllContext) {} + +// ExitRevokeOnAll is called when production revokeOnAll is exited. +func (s *BaseStarRocksSQLListener) ExitRevokeOnAll(ctx *RevokeOnAllContext) {} + +// EnterShowGrantsStatement is called when production showGrantsStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowGrantsStatement(ctx *ShowGrantsStatementContext) {} + +// ExitShowGrantsStatement is called when production showGrantsStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowGrantsStatement(ctx *ShowGrantsStatementContext) {} + +// EnterAuthWithoutPlugin is called when production authWithoutPlugin is entered. +func (s *BaseStarRocksSQLListener) EnterAuthWithoutPlugin(ctx *AuthWithoutPluginContext) {} + +// ExitAuthWithoutPlugin is called when production authWithoutPlugin is exited. +func (s *BaseStarRocksSQLListener) ExitAuthWithoutPlugin(ctx *AuthWithoutPluginContext) {} + +// EnterAuthWithPlugin is called when production authWithPlugin is entered. +func (s *BaseStarRocksSQLListener) EnterAuthWithPlugin(ctx *AuthWithPluginContext) {} + +// ExitAuthWithPlugin is called when production authWithPlugin is exited. +func (s *BaseStarRocksSQLListener) ExitAuthWithPlugin(ctx *AuthWithPluginContext) {} + +// EnterPrivObjectName is called when production privObjectName is entered. +func (s *BaseStarRocksSQLListener) EnterPrivObjectName(ctx *PrivObjectNameContext) {} + +// ExitPrivObjectName is called when production privObjectName is exited. +func (s *BaseStarRocksSQLListener) ExitPrivObjectName(ctx *PrivObjectNameContext) {} + +// EnterPrivObjectNameList is called when production privObjectNameList is entered. +func (s *BaseStarRocksSQLListener) EnterPrivObjectNameList(ctx *PrivObjectNameListContext) {} + +// ExitPrivObjectNameList is called when production privObjectNameList is exited. +func (s *BaseStarRocksSQLListener) ExitPrivObjectNameList(ctx *PrivObjectNameListContext) {} + +// EnterPrivFunctionObjectNameList is called when production privFunctionObjectNameList is entered. +func (s *BaseStarRocksSQLListener) EnterPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) { +} + +// ExitPrivFunctionObjectNameList is called when production privFunctionObjectNameList is exited. +func (s *BaseStarRocksSQLListener) ExitPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) { +} + +// EnterPrivilegeTypeList is called when production privilegeTypeList is entered. +func (s *BaseStarRocksSQLListener) EnterPrivilegeTypeList(ctx *PrivilegeTypeListContext) {} + +// ExitPrivilegeTypeList is called when production privilegeTypeList is exited. +func (s *BaseStarRocksSQLListener) ExitPrivilegeTypeList(ctx *PrivilegeTypeListContext) {} + +// EnterPrivilegeType is called when production privilegeType is entered. +func (s *BaseStarRocksSQLListener) EnterPrivilegeType(ctx *PrivilegeTypeContext) {} + +// ExitPrivilegeType is called when production privilegeType is exited. +func (s *BaseStarRocksSQLListener) ExitPrivilegeType(ctx *PrivilegeTypeContext) {} + +// EnterPrivObjectType is called when production privObjectType is entered. +func (s *BaseStarRocksSQLListener) EnterPrivObjectType(ctx *PrivObjectTypeContext) {} + +// ExitPrivObjectType is called when production privObjectType is exited. +func (s *BaseStarRocksSQLListener) ExitPrivObjectType(ctx *PrivObjectTypeContext) {} + +// EnterPrivObjectTypePlural is called when production privObjectTypePlural is entered. +func (s *BaseStarRocksSQLListener) EnterPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) {} + +// ExitPrivObjectTypePlural is called when production privObjectTypePlural is exited. +func (s *BaseStarRocksSQLListener) ExitPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) {} + +// EnterCreateSecurityIntegrationStatement is called when production createSecurityIntegrationStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) { +} + +// ExitCreateSecurityIntegrationStatement is called when production createSecurityIntegrationStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) { +} + +// EnterAlterSecurityIntegrationStatement is called when production alterSecurityIntegrationStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) { +} + +// ExitAlterSecurityIntegrationStatement is called when production alterSecurityIntegrationStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) { +} + +// EnterDropSecurityIntegrationStatement is called when production dropSecurityIntegrationStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) { +} + +// ExitDropSecurityIntegrationStatement is called when production dropSecurityIntegrationStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) { +} + +// EnterShowSecurityIntegrationStatement is called when production showSecurityIntegrationStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) { +} + +// ExitShowSecurityIntegrationStatement is called when production showSecurityIntegrationStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) { +} + +// EnterShowCreateSecurityIntegrationStatement is called when production showCreateSecurityIntegrationStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) { +} + +// ExitShowCreateSecurityIntegrationStatement is called when production showCreateSecurityIntegrationStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) { +} + +// EnterCreateGroupProviderStatement is called when production createGroupProviderStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) { +} + +// ExitCreateGroupProviderStatement is called when production createGroupProviderStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) { +} + +// EnterDropGroupProviderStatement is called when production dropGroupProviderStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) { +} + +// ExitDropGroupProviderStatement is called when production dropGroupProviderStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) { +} + +// EnterShowGroupProvidersStatement is called when production showGroupProvidersStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) { +} + +// ExitShowGroupProvidersStatement is called when production showGroupProvidersStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) { +} + +// EnterShowCreateGroupProviderStatement is called when production showCreateGroupProviderStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) { +} + +// ExitShowCreateGroupProviderStatement is called when production showCreateGroupProviderStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) { +} + +// EnterBackupStatement is called when production backupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterBackupStatement(ctx *BackupStatementContext) {} + +// ExitBackupStatement is called when production backupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitBackupStatement(ctx *BackupStatementContext) {} + +// EnterCancelBackupStatement is called when production cancelBackupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelBackupStatement(ctx *CancelBackupStatementContext) {} + +// ExitCancelBackupStatement is called when production cancelBackupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelBackupStatement(ctx *CancelBackupStatementContext) {} + +// EnterShowBackupStatement is called when production showBackupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowBackupStatement(ctx *ShowBackupStatementContext) {} + +// ExitShowBackupStatement is called when production showBackupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowBackupStatement(ctx *ShowBackupStatementContext) {} + +// EnterRestoreStatement is called when production restoreStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRestoreStatement(ctx *RestoreStatementContext) {} + +// ExitRestoreStatement is called when production restoreStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRestoreStatement(ctx *RestoreStatementContext) {} + +// EnterCancelRestoreStatement is called when production cancelRestoreStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelRestoreStatement(ctx *CancelRestoreStatementContext) {} + +// ExitCancelRestoreStatement is called when production cancelRestoreStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelRestoreStatement(ctx *CancelRestoreStatementContext) {} + +// EnterShowRestoreStatement is called when production showRestoreStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowRestoreStatement(ctx *ShowRestoreStatementContext) {} + +// ExitShowRestoreStatement is called when production showRestoreStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowRestoreStatement(ctx *ShowRestoreStatementContext) {} + +// EnterShowSnapshotStatement is called when production showSnapshotStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowSnapshotStatement(ctx *ShowSnapshotStatementContext) {} + +// ExitShowSnapshotStatement is called when production showSnapshotStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowSnapshotStatement(ctx *ShowSnapshotStatementContext) {} + +// EnterCreateRepositoryStatement is called when production createRepositoryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) { +} + +// ExitCreateRepositoryStatement is called when production createRepositoryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) { +} + +// EnterDropRepositoryStatement is called when production dropRepositoryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropRepositoryStatement(ctx *DropRepositoryStatementContext) { +} + +// ExitDropRepositoryStatement is called when production dropRepositoryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropRepositoryStatement(ctx *DropRepositoryStatementContext) {} + +// EnterAddSqlBlackListStatement is called when production addSqlBlackListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) { +} + +// ExitAddSqlBlackListStatement is called when production addSqlBlackListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) { +} + +// EnterDelSqlBlackListStatement is called when production delSqlBlackListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) { +} + +// ExitDelSqlBlackListStatement is called when production delSqlBlackListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) { +} + +// EnterShowSqlBlackListStatement is called when production showSqlBlackListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) { +} + +// ExitShowSqlBlackListStatement is called when production showSqlBlackListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) { +} + +// EnterShowWhiteListStatement is called when production showWhiteListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowWhiteListStatement(ctx *ShowWhiteListStatementContext) {} + +// ExitShowWhiteListStatement is called when production showWhiteListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowWhiteListStatement(ctx *ShowWhiteListStatementContext) {} + +// EnterAddBackendBlackListStatement is called when production addBackendBlackListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) { +} + +// ExitAddBackendBlackListStatement is called when production addBackendBlackListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) { +} + +// EnterDelBackendBlackListStatement is called when production delBackendBlackListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) { +} + +// ExitDelBackendBlackListStatement is called when production delBackendBlackListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) { +} + +// EnterShowBackendBlackListStatement is called when production showBackendBlackListStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) { +} + +// ExitShowBackendBlackListStatement is called when production showBackendBlackListStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) { +} + +// EnterDataCacheTarget is called when production dataCacheTarget is entered. +func (s *BaseStarRocksSQLListener) EnterDataCacheTarget(ctx *DataCacheTargetContext) {} + +// ExitDataCacheTarget is called when production dataCacheTarget is exited. +func (s *BaseStarRocksSQLListener) ExitDataCacheTarget(ctx *DataCacheTargetContext) {} + +// EnterCreateDataCacheRuleStatement is called when production createDataCacheRuleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) { +} + +// ExitCreateDataCacheRuleStatement is called when production createDataCacheRuleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) { +} + +// EnterShowDataCacheRulesStatement is called when production showDataCacheRulesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) { +} + +// ExitShowDataCacheRulesStatement is called when production showDataCacheRulesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) { +} + +// EnterDropDataCacheRuleStatement is called when production dropDataCacheRuleStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) { +} + +// ExitDropDataCacheRuleStatement is called when production dropDataCacheRuleStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) { +} + +// EnterClearDataCacheRulesStatement is called when production clearDataCacheRulesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) { +} + +// ExitClearDataCacheRulesStatement is called when production clearDataCacheRulesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) { +} + +// EnterDataCacheSelectStatement is called when production dataCacheSelectStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) { +} + +// ExitDataCacheSelectStatement is called when production dataCacheSelectStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) { +} + +// EnterExportStatement is called when production exportStatement is entered. +func (s *BaseStarRocksSQLListener) EnterExportStatement(ctx *ExportStatementContext) {} + +// ExitExportStatement is called when production exportStatement is exited. +func (s *BaseStarRocksSQLListener) ExitExportStatement(ctx *ExportStatementContext) {} + +// EnterCancelExportStatement is called when production cancelExportStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCancelExportStatement(ctx *CancelExportStatementContext) {} + +// ExitCancelExportStatement is called when production cancelExportStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCancelExportStatement(ctx *CancelExportStatementContext) {} + +// EnterShowExportStatement is called when production showExportStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowExportStatement(ctx *ShowExportStatementContext) {} + +// ExitShowExportStatement is called when production showExportStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowExportStatement(ctx *ShowExportStatementContext) {} + +// EnterInstallPluginStatement is called when production installPluginStatement is entered. +func (s *BaseStarRocksSQLListener) EnterInstallPluginStatement(ctx *InstallPluginStatementContext) {} + +// ExitInstallPluginStatement is called when production installPluginStatement is exited. +func (s *BaseStarRocksSQLListener) ExitInstallPluginStatement(ctx *InstallPluginStatementContext) {} + +// EnterUninstallPluginStatement is called when production uninstallPluginStatement is entered. +func (s *BaseStarRocksSQLListener) EnterUninstallPluginStatement(ctx *UninstallPluginStatementContext) { +} + +// ExitUninstallPluginStatement is called when production uninstallPluginStatement is exited. +func (s *BaseStarRocksSQLListener) ExitUninstallPluginStatement(ctx *UninstallPluginStatementContext) { +} + +// EnterCreateFileStatement is called when production createFileStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateFileStatement(ctx *CreateFileStatementContext) {} + +// ExitCreateFileStatement is called when production createFileStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateFileStatement(ctx *CreateFileStatementContext) {} + +// EnterDropFileStatement is called when production dropFileStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropFileStatement(ctx *DropFileStatementContext) {} + +// ExitDropFileStatement is called when production dropFileStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropFileStatement(ctx *DropFileStatementContext) {} + +// EnterShowSmallFilesStatement is called when production showSmallFilesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) { +} + +// ExitShowSmallFilesStatement is called when production showSmallFilesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) {} + +// EnterCreatePipeStatement is called when production createPipeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreatePipeStatement(ctx *CreatePipeStatementContext) {} + +// ExitCreatePipeStatement is called when production createPipeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreatePipeStatement(ctx *CreatePipeStatementContext) {} + +// EnterDropPipeStatement is called when production dropPipeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropPipeStatement(ctx *DropPipeStatementContext) {} + +// ExitDropPipeStatement is called when production dropPipeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropPipeStatement(ctx *DropPipeStatementContext) {} + +// EnterAlterPipeClause is called when production alterPipeClause is entered. +func (s *BaseStarRocksSQLListener) EnterAlterPipeClause(ctx *AlterPipeClauseContext) {} + +// ExitAlterPipeClause is called when production alterPipeClause is exited. +func (s *BaseStarRocksSQLListener) ExitAlterPipeClause(ctx *AlterPipeClauseContext) {} + +// EnterAlterPipeStatement is called when production alterPipeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterPipeStatement(ctx *AlterPipeStatementContext) {} + +// ExitAlterPipeStatement is called when production alterPipeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterPipeStatement(ctx *AlterPipeStatementContext) {} + +// EnterDescPipeStatement is called when production descPipeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDescPipeStatement(ctx *DescPipeStatementContext) {} + +// ExitDescPipeStatement is called when production descPipeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDescPipeStatement(ctx *DescPipeStatementContext) {} + +// EnterShowPipeStatement is called when production showPipeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPipeStatement(ctx *ShowPipeStatementContext) {} + +// ExitShowPipeStatement is called when production showPipeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPipeStatement(ctx *ShowPipeStatementContext) {} + +// EnterSetStatement is called when production setStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetStatement(ctx *SetStatementContext) {} + +// ExitSetStatement is called when production setStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetStatement(ctx *SetStatementContext) {} + +// EnterSetNames is called when production setNames is entered. +func (s *BaseStarRocksSQLListener) EnterSetNames(ctx *SetNamesContext) {} + +// ExitSetNames is called when production setNames is exited. +func (s *BaseStarRocksSQLListener) ExitSetNames(ctx *SetNamesContext) {} + +// EnterSetPassword is called when production setPassword is entered. +func (s *BaseStarRocksSQLListener) EnterSetPassword(ctx *SetPasswordContext) {} + +// ExitSetPassword is called when production setPassword is exited. +func (s *BaseStarRocksSQLListener) ExitSetPassword(ctx *SetPasswordContext) {} + +// EnterSetUserVar is called when production setUserVar is entered. +func (s *BaseStarRocksSQLListener) EnterSetUserVar(ctx *SetUserVarContext) {} + +// ExitSetUserVar is called when production setUserVar is exited. +func (s *BaseStarRocksSQLListener) ExitSetUserVar(ctx *SetUserVarContext) {} + +// EnterSetSystemVar is called when production setSystemVar is entered. +func (s *BaseStarRocksSQLListener) EnterSetSystemVar(ctx *SetSystemVarContext) {} + +// ExitSetSystemVar is called when production setSystemVar is exited. +func (s *BaseStarRocksSQLListener) ExitSetSystemVar(ctx *SetSystemVarContext) {} + +// EnterSetTransaction is called when production setTransaction is entered. +func (s *BaseStarRocksSQLListener) EnterSetTransaction(ctx *SetTransactionContext) {} + +// ExitSetTransaction is called when production setTransaction is exited. +func (s *BaseStarRocksSQLListener) ExitSetTransaction(ctx *SetTransactionContext) {} + +// EnterTransaction_characteristics is called when production transaction_characteristics is entered. +func (s *BaseStarRocksSQLListener) EnterTransaction_characteristics(ctx *Transaction_characteristicsContext) { +} + +// ExitTransaction_characteristics is called when production transaction_characteristics is exited. +func (s *BaseStarRocksSQLListener) ExitTransaction_characteristics(ctx *Transaction_characteristicsContext) { +} + +// EnterTransaction_access_mode is called when production transaction_access_mode is entered. +func (s *BaseStarRocksSQLListener) EnterTransaction_access_mode(ctx *Transaction_access_modeContext) { +} + +// ExitTransaction_access_mode is called when production transaction_access_mode is exited. +func (s *BaseStarRocksSQLListener) ExitTransaction_access_mode(ctx *Transaction_access_modeContext) {} + +// EnterIsolation_level is called when production isolation_level is entered. +func (s *BaseStarRocksSQLListener) EnterIsolation_level(ctx *Isolation_levelContext) {} + +// ExitIsolation_level is called when production isolation_level is exited. +func (s *BaseStarRocksSQLListener) ExitIsolation_level(ctx *Isolation_levelContext) {} + +// EnterIsolation_types is called when production isolation_types is entered. +func (s *BaseStarRocksSQLListener) EnterIsolation_types(ctx *Isolation_typesContext) {} + +// ExitIsolation_types is called when production isolation_types is exited. +func (s *BaseStarRocksSQLListener) ExitIsolation_types(ctx *Isolation_typesContext) {} + +// EnterSetExprOrDefault is called when production setExprOrDefault is entered. +func (s *BaseStarRocksSQLListener) EnterSetExprOrDefault(ctx *SetExprOrDefaultContext) {} + +// ExitSetExprOrDefault is called when production setExprOrDefault is exited. +func (s *BaseStarRocksSQLListener) ExitSetExprOrDefault(ctx *SetExprOrDefaultContext) {} + +// EnterSetUserPropertyStatement is called when production setUserPropertyStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) { +} + +// ExitSetUserPropertyStatement is called when production setUserPropertyStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) { +} + +// EnterRoleList is called when production roleList is entered. +func (s *BaseStarRocksSQLListener) EnterRoleList(ctx *RoleListContext) {} + +// ExitRoleList is called when production roleList is exited. +func (s *BaseStarRocksSQLListener) ExitRoleList(ctx *RoleListContext) {} + +// EnterExecuteScriptStatement is called when production executeScriptStatement is entered. +func (s *BaseStarRocksSQLListener) EnterExecuteScriptStatement(ctx *ExecuteScriptStatementContext) {} + +// ExitExecuteScriptStatement is called when production executeScriptStatement is exited. +func (s *BaseStarRocksSQLListener) ExitExecuteScriptStatement(ctx *ExecuteScriptStatementContext) {} + +// EnterUnsupportedStatement is called when production unsupportedStatement is entered. +func (s *BaseStarRocksSQLListener) EnterUnsupportedStatement(ctx *UnsupportedStatementContext) {} + +// ExitUnsupportedStatement is called when production unsupportedStatement is exited. +func (s *BaseStarRocksSQLListener) ExitUnsupportedStatement(ctx *UnsupportedStatementContext) {} + +// EnterLock_item is called when production lock_item is entered. +func (s *BaseStarRocksSQLListener) EnterLock_item(ctx *Lock_itemContext) {} + +// ExitLock_item is called when production lock_item is exited. +func (s *BaseStarRocksSQLListener) ExitLock_item(ctx *Lock_itemContext) {} + +// EnterLock_type is called when production lock_type is entered. +func (s *BaseStarRocksSQLListener) EnterLock_type(ctx *Lock_typeContext) {} + +// ExitLock_type is called when production lock_type is exited. +func (s *BaseStarRocksSQLListener) ExitLock_type(ctx *Lock_typeContext) {} + +// EnterAlterPlanAdvisorAddStatement is called when production alterPlanAdvisorAddStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) { +} + +// ExitAlterPlanAdvisorAddStatement is called when production alterPlanAdvisorAddStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) { +} + +// EnterTruncatePlanAdvisorStatement is called when production truncatePlanAdvisorStatement is entered. +func (s *BaseStarRocksSQLListener) EnterTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) { +} + +// ExitTruncatePlanAdvisorStatement is called when production truncatePlanAdvisorStatement is exited. +func (s *BaseStarRocksSQLListener) ExitTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) { +} + +// EnterAlterPlanAdvisorDropStatement is called when production alterPlanAdvisorDropStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) { +} + +// ExitAlterPlanAdvisorDropStatement is called when production alterPlanAdvisorDropStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) { +} + +// EnterShowPlanAdvisorStatement is called when production showPlanAdvisorStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) { +} + +// ExitShowPlanAdvisorStatement is called when production showPlanAdvisorStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) { +} + +// EnterCreateWarehouseStatement is called when production createWarehouseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) { +} + +// ExitCreateWarehouseStatement is called when production createWarehouseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) { +} + +// EnterDropWarehouseStatement is called when production dropWarehouseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropWarehouseStatement(ctx *DropWarehouseStatementContext) {} + +// ExitDropWarehouseStatement is called when production dropWarehouseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropWarehouseStatement(ctx *DropWarehouseStatementContext) {} + +// EnterSuspendWarehouseStatement is called when production suspendWarehouseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) { +} + +// ExitSuspendWarehouseStatement is called when production suspendWarehouseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) { +} + +// EnterResumeWarehouseStatement is called when production resumeWarehouseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) { +} + +// ExitResumeWarehouseStatement is called when production resumeWarehouseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) { +} + +// EnterSetWarehouseStatement is called when production setWarehouseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterSetWarehouseStatement(ctx *SetWarehouseStatementContext) {} + +// ExitSetWarehouseStatement is called when production setWarehouseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitSetWarehouseStatement(ctx *SetWarehouseStatementContext) {} + +// EnterShowWarehousesStatement is called when production showWarehousesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowWarehousesStatement(ctx *ShowWarehousesStatementContext) { +} + +// ExitShowWarehousesStatement is called when production showWarehousesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowWarehousesStatement(ctx *ShowWarehousesStatementContext) {} + +// EnterShowClustersStatement is called when production showClustersStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowClustersStatement(ctx *ShowClustersStatementContext) {} + +// ExitShowClustersStatement is called when production showClustersStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowClustersStatement(ctx *ShowClustersStatementContext) {} + +// EnterShowNodesStatement is called when production showNodesStatement is entered. +func (s *BaseStarRocksSQLListener) EnterShowNodesStatement(ctx *ShowNodesStatementContext) {} + +// ExitShowNodesStatement is called when production showNodesStatement is exited. +func (s *BaseStarRocksSQLListener) ExitShowNodesStatement(ctx *ShowNodesStatementContext) {} + +// EnterAlterWarehouseStatement is called when production alterWarehouseStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) { +} + +// ExitAlterWarehouseStatement is called when production alterWarehouseStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) {} + +// EnterCreateCNGroupStatement is called when production createCNGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) {} + +// ExitCreateCNGroupStatement is called when production createCNGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) {} + +// EnterDropCNGroupStatement is called when production dropCNGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDropCNGroupStatement(ctx *DropCNGroupStatementContext) {} + +// ExitDropCNGroupStatement is called when production dropCNGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDropCNGroupStatement(ctx *DropCNGroupStatementContext) {} + +// EnterEnableCNGroupStatement is called when production enableCNGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) {} + +// ExitEnableCNGroupStatement is called when production enableCNGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) {} + +// EnterDisableCNGroupStatement is called when production disableCNGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) { +} + +// ExitDisableCNGroupStatement is called when production disableCNGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) {} + +// EnterAlterCNGroupStatement is called when production alterCNGroupStatement is entered. +func (s *BaseStarRocksSQLListener) EnterAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) {} + +// ExitAlterCNGroupStatement is called when production alterCNGroupStatement is exited. +func (s *BaseStarRocksSQLListener) ExitAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) {} + +// EnterBeginStatement is called when production beginStatement is entered. +func (s *BaseStarRocksSQLListener) EnterBeginStatement(ctx *BeginStatementContext) {} + +// ExitBeginStatement is called when production beginStatement is exited. +func (s *BaseStarRocksSQLListener) ExitBeginStatement(ctx *BeginStatementContext) {} + +// EnterCommitStatement is called when production commitStatement is entered. +func (s *BaseStarRocksSQLListener) EnterCommitStatement(ctx *CommitStatementContext) {} + +// ExitCommitStatement is called when production commitStatement is exited. +func (s *BaseStarRocksSQLListener) ExitCommitStatement(ctx *CommitStatementContext) {} + +// EnterRollbackStatement is called when production rollbackStatement is entered. +func (s *BaseStarRocksSQLListener) EnterRollbackStatement(ctx *RollbackStatementContext) {} + +// ExitRollbackStatement is called when production rollbackStatement is exited. +func (s *BaseStarRocksSQLListener) ExitRollbackStatement(ctx *RollbackStatementContext) {} + +// EnterTranslateStatement is called when production translateStatement is entered. +func (s *BaseStarRocksSQLListener) EnterTranslateStatement(ctx *TranslateStatementContext) {} + +// ExitTranslateStatement is called when production translateStatement is exited. +func (s *BaseStarRocksSQLListener) ExitTranslateStatement(ctx *TranslateStatementContext) {} + +// EnterDialect is called when production dialect is entered. +func (s *BaseStarRocksSQLListener) EnterDialect(ctx *DialectContext) {} + +// ExitDialect is called when production dialect is exited. +func (s *BaseStarRocksSQLListener) ExitDialect(ctx *DialectContext) {} + +// EnterTranslateSQL is called when production translateSQL is entered. +func (s *BaseStarRocksSQLListener) EnterTranslateSQL(ctx *TranslateSQLContext) {} + +// ExitTranslateSQL is called when production translateSQL is exited. +func (s *BaseStarRocksSQLListener) ExitTranslateSQL(ctx *TranslateSQLContext) {} + +// EnterQueryStatement is called when production queryStatement is entered. +func (s *BaseStarRocksSQLListener) EnterQueryStatement(ctx *QueryStatementContext) {} + +// ExitQueryStatement is called when production queryStatement is exited. +func (s *BaseStarRocksSQLListener) ExitQueryStatement(ctx *QueryStatementContext) {} + +// EnterQueryRelation is called when production queryRelation is entered. +func (s *BaseStarRocksSQLListener) EnterQueryRelation(ctx *QueryRelationContext) {} + +// ExitQueryRelation is called when production queryRelation is exited. +func (s *BaseStarRocksSQLListener) ExitQueryRelation(ctx *QueryRelationContext) {} + +// EnterWithClause is called when production withClause is entered. +func (s *BaseStarRocksSQLListener) EnterWithClause(ctx *WithClauseContext) {} + +// ExitWithClause is called when production withClause is exited. +func (s *BaseStarRocksSQLListener) ExitWithClause(ctx *WithClauseContext) {} + +// EnterQueryNoWith is called when production queryNoWith is entered. +func (s *BaseStarRocksSQLListener) EnterQueryNoWith(ctx *QueryNoWithContext) {} + +// ExitQueryNoWith is called when production queryNoWith is exited. +func (s *BaseStarRocksSQLListener) ExitQueryNoWith(ctx *QueryNoWithContext) {} + +// EnterQueryPeriod is called when production queryPeriod is entered. +func (s *BaseStarRocksSQLListener) EnterQueryPeriod(ctx *QueryPeriodContext) {} + +// ExitQueryPeriod is called when production queryPeriod is exited. +func (s *BaseStarRocksSQLListener) ExitQueryPeriod(ctx *QueryPeriodContext) {} + +// EnterPeriodType is called when production periodType is entered. +func (s *BaseStarRocksSQLListener) EnterPeriodType(ctx *PeriodTypeContext) {} + +// ExitPeriodType is called when production periodType is exited. +func (s *BaseStarRocksSQLListener) ExitPeriodType(ctx *PeriodTypeContext) {} + +// EnterQueryWithParentheses is called when production queryWithParentheses is entered. +func (s *BaseStarRocksSQLListener) EnterQueryWithParentheses(ctx *QueryWithParenthesesContext) {} + +// ExitQueryWithParentheses is called when production queryWithParentheses is exited. +func (s *BaseStarRocksSQLListener) ExitQueryWithParentheses(ctx *QueryWithParenthesesContext) {} + +// EnterSetOperation is called when production setOperation is entered. +func (s *BaseStarRocksSQLListener) EnterSetOperation(ctx *SetOperationContext) {} + +// ExitSetOperation is called when production setOperation is exited. +func (s *BaseStarRocksSQLListener) ExitSetOperation(ctx *SetOperationContext) {} + +// EnterQueryPrimaryDefault is called when production queryPrimaryDefault is entered. +func (s *BaseStarRocksSQLListener) EnterQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) {} + +// ExitQueryPrimaryDefault is called when production queryPrimaryDefault is exited. +func (s *BaseStarRocksSQLListener) ExitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) {} + +// EnterSubquery is called when production subquery is entered. +func (s *BaseStarRocksSQLListener) EnterSubquery(ctx *SubqueryContext) {} + +// ExitSubquery is called when production subquery is exited. +func (s *BaseStarRocksSQLListener) ExitSubquery(ctx *SubqueryContext) {} + +// EnterRowConstructor is called when production rowConstructor is entered. +func (s *BaseStarRocksSQLListener) EnterRowConstructor(ctx *RowConstructorContext) {} + +// ExitRowConstructor is called when production rowConstructor is exited. +func (s *BaseStarRocksSQLListener) ExitRowConstructor(ctx *RowConstructorContext) {} + +// EnterSortItem is called when production sortItem is entered. +func (s *BaseStarRocksSQLListener) EnterSortItem(ctx *SortItemContext) {} + +// ExitSortItem is called when production sortItem is exited. +func (s *BaseStarRocksSQLListener) ExitSortItem(ctx *SortItemContext) {} + +// EnterLimitConstExpr is called when production limitConstExpr is entered. +func (s *BaseStarRocksSQLListener) EnterLimitConstExpr(ctx *LimitConstExprContext) {} + +// ExitLimitConstExpr is called when production limitConstExpr is exited. +func (s *BaseStarRocksSQLListener) ExitLimitConstExpr(ctx *LimitConstExprContext) {} + +// EnterLimitElement is called when production limitElement is entered. +func (s *BaseStarRocksSQLListener) EnterLimitElement(ctx *LimitElementContext) {} + +// ExitLimitElement is called when production limitElement is exited. +func (s *BaseStarRocksSQLListener) ExitLimitElement(ctx *LimitElementContext) {} + +// EnterQuerySpecification is called when production querySpecification is entered. +func (s *BaseStarRocksSQLListener) EnterQuerySpecification(ctx *QuerySpecificationContext) {} + +// ExitQuerySpecification is called when production querySpecification is exited. +func (s *BaseStarRocksSQLListener) ExitQuerySpecification(ctx *QuerySpecificationContext) {} + +// EnterFrom is called when production from is entered. +func (s *BaseStarRocksSQLListener) EnterFrom(ctx *FromContext) {} + +// ExitFrom is called when production from is exited. +func (s *BaseStarRocksSQLListener) ExitFrom(ctx *FromContext) {} + +// EnterDual is called when production dual is entered. +func (s *BaseStarRocksSQLListener) EnterDual(ctx *DualContext) {} + +// ExitDual is called when production dual is exited. +func (s *BaseStarRocksSQLListener) ExitDual(ctx *DualContext) {} + +// EnterRollup is called when production rollup is entered. +func (s *BaseStarRocksSQLListener) EnterRollup(ctx *RollupContext) {} + +// ExitRollup is called when production rollup is exited. +func (s *BaseStarRocksSQLListener) ExitRollup(ctx *RollupContext) {} + +// EnterCube is called when production cube is entered. +func (s *BaseStarRocksSQLListener) EnterCube(ctx *CubeContext) {} + +// ExitCube is called when production cube is exited. +func (s *BaseStarRocksSQLListener) ExitCube(ctx *CubeContext) {} + +// EnterMultipleGroupingSets is called when production multipleGroupingSets is entered. +func (s *BaseStarRocksSQLListener) EnterMultipleGroupingSets(ctx *MultipleGroupingSetsContext) {} + +// ExitMultipleGroupingSets is called when production multipleGroupingSets is exited. +func (s *BaseStarRocksSQLListener) ExitMultipleGroupingSets(ctx *MultipleGroupingSetsContext) {} + +// EnterSingleGroupingSet is called when production singleGroupingSet is entered. +func (s *BaseStarRocksSQLListener) EnterSingleGroupingSet(ctx *SingleGroupingSetContext) {} + +// ExitSingleGroupingSet is called when production singleGroupingSet is exited. +func (s *BaseStarRocksSQLListener) ExitSingleGroupingSet(ctx *SingleGroupingSetContext) {} + +// EnterGroupingSet is called when production groupingSet is entered. +func (s *BaseStarRocksSQLListener) EnterGroupingSet(ctx *GroupingSetContext) {} + +// ExitGroupingSet is called when production groupingSet is exited. +func (s *BaseStarRocksSQLListener) ExitGroupingSet(ctx *GroupingSetContext) {} + +// EnterCommonTableExpression is called when production commonTableExpression is entered. +func (s *BaseStarRocksSQLListener) EnterCommonTableExpression(ctx *CommonTableExpressionContext) {} + +// ExitCommonTableExpression is called when production commonTableExpression is exited. +func (s *BaseStarRocksSQLListener) ExitCommonTableExpression(ctx *CommonTableExpressionContext) {} + +// EnterSetQuantifier is called when production setQuantifier is entered. +func (s *BaseStarRocksSQLListener) EnterSetQuantifier(ctx *SetQuantifierContext) {} + +// ExitSetQuantifier is called when production setQuantifier is exited. +func (s *BaseStarRocksSQLListener) ExitSetQuantifier(ctx *SetQuantifierContext) {} + +// EnterSelectSingle is called when production selectSingle is entered. +func (s *BaseStarRocksSQLListener) EnterSelectSingle(ctx *SelectSingleContext) {} + +// ExitSelectSingle is called when production selectSingle is exited. +func (s *BaseStarRocksSQLListener) ExitSelectSingle(ctx *SelectSingleContext) {} + +// EnterSelectAll is called when production selectAll is entered. +func (s *BaseStarRocksSQLListener) EnterSelectAll(ctx *SelectAllContext) {} + +// ExitSelectAll is called when production selectAll is exited. +func (s *BaseStarRocksSQLListener) ExitSelectAll(ctx *SelectAllContext) {} + +// EnterExcludeClause is called when production excludeClause is entered. +func (s *BaseStarRocksSQLListener) EnterExcludeClause(ctx *ExcludeClauseContext) {} + +// ExitExcludeClause is called when production excludeClause is exited. +func (s *BaseStarRocksSQLListener) ExitExcludeClause(ctx *ExcludeClauseContext) {} + +// EnterRelations is called when production relations is entered. +func (s *BaseStarRocksSQLListener) EnterRelations(ctx *RelationsContext) {} + +// ExitRelations is called when production relations is exited. +func (s *BaseStarRocksSQLListener) ExitRelations(ctx *RelationsContext) {} + +// EnterRelationLateralView is called when production relationLateralView is entered. +func (s *BaseStarRocksSQLListener) EnterRelationLateralView(ctx *RelationLateralViewContext) {} + +// ExitRelationLateralView is called when production relationLateralView is exited. +func (s *BaseStarRocksSQLListener) ExitRelationLateralView(ctx *RelationLateralViewContext) {} + +// EnterLateralView is called when production lateralView is entered. +func (s *BaseStarRocksSQLListener) EnterLateralView(ctx *LateralViewContext) {} + +// ExitLateralView is called when production lateralView is exited. +func (s *BaseStarRocksSQLListener) ExitLateralView(ctx *LateralViewContext) {} + +// EnterGeneratorFunction is called when production generatorFunction is entered. +func (s *BaseStarRocksSQLListener) EnterGeneratorFunction(ctx *GeneratorFunctionContext) {} + +// ExitGeneratorFunction is called when production generatorFunction is exited. +func (s *BaseStarRocksSQLListener) ExitGeneratorFunction(ctx *GeneratorFunctionContext) {} + +// EnterRelation is called when production relation is entered. +func (s *BaseStarRocksSQLListener) EnterRelation(ctx *RelationContext) {} + +// ExitRelation is called when production relation is exited. +func (s *BaseStarRocksSQLListener) ExitRelation(ctx *RelationContext) {} + +// EnterTableAtom is called when production tableAtom is entered. +func (s *BaseStarRocksSQLListener) EnterTableAtom(ctx *TableAtomContext) {} + +// ExitTableAtom is called when production tableAtom is exited. +func (s *BaseStarRocksSQLListener) ExitTableAtom(ctx *TableAtomContext) {} + +// EnterInlineTable is called when production inlineTable is entered. +func (s *BaseStarRocksSQLListener) EnterInlineTable(ctx *InlineTableContext) {} + +// ExitInlineTable is called when production inlineTable is exited. +func (s *BaseStarRocksSQLListener) ExitInlineTable(ctx *InlineTableContext) {} + +// EnterSubqueryWithAlias is called when production subqueryWithAlias is entered. +func (s *BaseStarRocksSQLListener) EnterSubqueryWithAlias(ctx *SubqueryWithAliasContext) {} + +// ExitSubqueryWithAlias is called when production subqueryWithAlias is exited. +func (s *BaseStarRocksSQLListener) ExitSubqueryWithAlias(ctx *SubqueryWithAliasContext) {} + +// EnterTableFunction is called when production tableFunction is entered. +func (s *BaseStarRocksSQLListener) EnterTableFunction(ctx *TableFunctionContext) {} + +// ExitTableFunction is called when production tableFunction is exited. +func (s *BaseStarRocksSQLListener) ExitTableFunction(ctx *TableFunctionContext) {} + +// EnterNormalizedTableFunction is called when production normalizedTableFunction is entered. +func (s *BaseStarRocksSQLListener) EnterNormalizedTableFunction(ctx *NormalizedTableFunctionContext) { +} + +// ExitNormalizedTableFunction is called when production normalizedTableFunction is exited. +func (s *BaseStarRocksSQLListener) ExitNormalizedTableFunction(ctx *NormalizedTableFunctionContext) {} + +// EnterFileTableFunction is called when production fileTableFunction is entered. +func (s *BaseStarRocksSQLListener) EnterFileTableFunction(ctx *FileTableFunctionContext) {} + +// ExitFileTableFunction is called when production fileTableFunction is exited. +func (s *BaseStarRocksSQLListener) ExitFileTableFunction(ctx *FileTableFunctionContext) {} + +// EnterParenthesizedRelation is called when production parenthesizedRelation is entered. +func (s *BaseStarRocksSQLListener) EnterParenthesizedRelation(ctx *ParenthesizedRelationContext) {} + +// ExitParenthesizedRelation is called when production parenthesizedRelation is exited. +func (s *BaseStarRocksSQLListener) ExitParenthesizedRelation(ctx *ParenthesizedRelationContext) {} + +// EnterPivotClause is called when production pivotClause is entered. +func (s *BaseStarRocksSQLListener) EnterPivotClause(ctx *PivotClauseContext) {} + +// ExitPivotClause is called when production pivotClause is exited. +func (s *BaseStarRocksSQLListener) ExitPivotClause(ctx *PivotClauseContext) {} + +// EnterPivotAggregationExpression is called when production pivotAggregationExpression is entered. +func (s *BaseStarRocksSQLListener) EnterPivotAggregationExpression(ctx *PivotAggregationExpressionContext) { +} + +// ExitPivotAggregationExpression is called when production pivotAggregationExpression is exited. +func (s *BaseStarRocksSQLListener) ExitPivotAggregationExpression(ctx *PivotAggregationExpressionContext) { +} + +// EnterPivotValue is called when production pivotValue is entered. +func (s *BaseStarRocksSQLListener) EnterPivotValue(ctx *PivotValueContext) {} + +// ExitPivotValue is called when production pivotValue is exited. +func (s *BaseStarRocksSQLListener) ExitPivotValue(ctx *PivotValueContext) {} + +// EnterSampleClause is called when production sampleClause is entered. +func (s *BaseStarRocksSQLListener) EnterSampleClause(ctx *SampleClauseContext) {} + +// ExitSampleClause is called when production sampleClause is exited. +func (s *BaseStarRocksSQLListener) ExitSampleClause(ctx *SampleClauseContext) {} + +// EnterArgumentList is called when production argumentList is entered. +func (s *BaseStarRocksSQLListener) EnterArgumentList(ctx *ArgumentListContext) {} + +// ExitArgumentList is called when production argumentList is exited. +func (s *BaseStarRocksSQLListener) ExitArgumentList(ctx *ArgumentListContext) {} + +// EnterNamedArgumentList is called when production namedArgumentList is entered. +func (s *BaseStarRocksSQLListener) EnterNamedArgumentList(ctx *NamedArgumentListContext) {} + +// ExitNamedArgumentList is called when production namedArgumentList is exited. +func (s *BaseStarRocksSQLListener) ExitNamedArgumentList(ctx *NamedArgumentListContext) {} + +// EnterNamedArguments is called when production namedArguments is entered. +func (s *BaseStarRocksSQLListener) EnterNamedArguments(ctx *NamedArgumentsContext) {} + +// ExitNamedArguments is called when production namedArguments is exited. +func (s *BaseStarRocksSQLListener) ExitNamedArguments(ctx *NamedArgumentsContext) {} + +// EnterJoinRelation is called when production joinRelation is entered. +func (s *BaseStarRocksSQLListener) EnterJoinRelation(ctx *JoinRelationContext) {} + +// ExitJoinRelation is called when production joinRelation is exited. +func (s *BaseStarRocksSQLListener) ExitJoinRelation(ctx *JoinRelationContext) {} + +// EnterCrossOrInnerJoinType is called when production crossOrInnerJoinType is entered. +func (s *BaseStarRocksSQLListener) EnterCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) {} + +// ExitCrossOrInnerJoinType is called when production crossOrInnerJoinType is exited. +func (s *BaseStarRocksSQLListener) ExitCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) {} + +// EnterOuterAndSemiJoinType is called when production outerAndSemiJoinType is entered. +func (s *BaseStarRocksSQLListener) EnterOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) {} + +// ExitOuterAndSemiJoinType is called when production outerAndSemiJoinType is exited. +func (s *BaseStarRocksSQLListener) ExitOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) {} + +// EnterBracketHint is called when production bracketHint is entered. +func (s *BaseStarRocksSQLListener) EnterBracketHint(ctx *BracketHintContext) {} + +// ExitBracketHint is called when production bracketHint is exited. +func (s *BaseStarRocksSQLListener) ExitBracketHint(ctx *BracketHintContext) {} + +// EnterHintMap is called when production hintMap is entered. +func (s *BaseStarRocksSQLListener) EnterHintMap(ctx *HintMapContext) {} + +// ExitHintMap is called when production hintMap is exited. +func (s *BaseStarRocksSQLListener) ExitHintMap(ctx *HintMapContext) {} + +// EnterJoinCriteria is called when production joinCriteria is entered. +func (s *BaseStarRocksSQLListener) EnterJoinCriteria(ctx *JoinCriteriaContext) {} + +// ExitJoinCriteria is called when production joinCriteria is exited. +func (s *BaseStarRocksSQLListener) ExitJoinCriteria(ctx *JoinCriteriaContext) {} + +// EnterColumnAliases is called when production columnAliases is entered. +func (s *BaseStarRocksSQLListener) EnterColumnAliases(ctx *ColumnAliasesContext) {} + +// ExitColumnAliases is called when production columnAliases is exited. +func (s *BaseStarRocksSQLListener) ExitColumnAliases(ctx *ColumnAliasesContext) {} + +// EnterColumnAliasesWithoutParentheses is called when production columnAliasesWithoutParentheses is entered. +func (s *BaseStarRocksSQLListener) EnterColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) { +} + +// ExitColumnAliasesWithoutParentheses is called when production columnAliasesWithoutParentheses is exited. +func (s *BaseStarRocksSQLListener) ExitColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) { +} + +// EnterPartitionNames is called when production partitionNames is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionNames(ctx *PartitionNamesContext) {} + +// ExitPartitionNames is called when production partitionNames is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionNames(ctx *PartitionNamesContext) {} + +// EnterKeyPartitionList is called when production keyPartitionList is entered. +func (s *BaseStarRocksSQLListener) EnterKeyPartitionList(ctx *KeyPartitionListContext) {} + +// ExitKeyPartitionList is called when production keyPartitionList is exited. +func (s *BaseStarRocksSQLListener) ExitKeyPartitionList(ctx *KeyPartitionListContext) {} + +// EnterTabletList is called when production tabletList is entered. +func (s *BaseStarRocksSQLListener) EnterTabletList(ctx *TabletListContext) {} + +// ExitTabletList is called when production tabletList is exited. +func (s *BaseStarRocksSQLListener) ExitTabletList(ctx *TabletListContext) {} + +// EnterPrepareStatement is called when production prepareStatement is entered. +func (s *BaseStarRocksSQLListener) EnterPrepareStatement(ctx *PrepareStatementContext) {} + +// ExitPrepareStatement is called when production prepareStatement is exited. +func (s *BaseStarRocksSQLListener) ExitPrepareStatement(ctx *PrepareStatementContext) {} + +// EnterPrepareSql is called when production prepareSql is entered. +func (s *BaseStarRocksSQLListener) EnterPrepareSql(ctx *PrepareSqlContext) {} + +// ExitPrepareSql is called when production prepareSql is exited. +func (s *BaseStarRocksSQLListener) ExitPrepareSql(ctx *PrepareSqlContext) {} + +// EnterExecuteStatement is called when production executeStatement is entered. +func (s *BaseStarRocksSQLListener) EnterExecuteStatement(ctx *ExecuteStatementContext) {} + +// ExitExecuteStatement is called when production executeStatement is exited. +func (s *BaseStarRocksSQLListener) ExitExecuteStatement(ctx *ExecuteStatementContext) {} + +// EnterDeallocateStatement is called when production deallocateStatement is entered. +func (s *BaseStarRocksSQLListener) EnterDeallocateStatement(ctx *DeallocateStatementContext) {} + +// ExitDeallocateStatement is called when production deallocateStatement is exited. +func (s *BaseStarRocksSQLListener) ExitDeallocateStatement(ctx *DeallocateStatementContext) {} + +// EnterReplicaList is called when production replicaList is entered. +func (s *BaseStarRocksSQLListener) EnterReplicaList(ctx *ReplicaListContext) {} + +// ExitReplicaList is called when production replicaList is exited. +func (s *BaseStarRocksSQLListener) ExitReplicaList(ctx *ReplicaListContext) {} + +// EnterExpressionsWithDefault is called when production expressionsWithDefault is entered. +func (s *BaseStarRocksSQLListener) EnterExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) {} + +// ExitExpressionsWithDefault is called when production expressionsWithDefault is exited. +func (s *BaseStarRocksSQLListener) ExitExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) {} + +// EnterExpressionOrDefault is called when production expressionOrDefault is entered. +func (s *BaseStarRocksSQLListener) EnterExpressionOrDefault(ctx *ExpressionOrDefaultContext) {} + +// ExitExpressionOrDefault is called when production expressionOrDefault is exited. +func (s *BaseStarRocksSQLListener) ExitExpressionOrDefault(ctx *ExpressionOrDefaultContext) {} + +// EnterMapExpressionList is called when production mapExpressionList is entered. +func (s *BaseStarRocksSQLListener) EnterMapExpressionList(ctx *MapExpressionListContext) {} + +// ExitMapExpressionList is called when production mapExpressionList is exited. +func (s *BaseStarRocksSQLListener) ExitMapExpressionList(ctx *MapExpressionListContext) {} + +// EnterMapExpression is called when production mapExpression is entered. +func (s *BaseStarRocksSQLListener) EnterMapExpression(ctx *MapExpressionContext) {} + +// ExitMapExpression is called when production mapExpression is exited. +func (s *BaseStarRocksSQLListener) ExitMapExpression(ctx *MapExpressionContext) {} + +// EnterExpressionSingleton is called when production expressionSingleton is entered. +func (s *BaseStarRocksSQLListener) EnterExpressionSingleton(ctx *ExpressionSingletonContext) {} + +// ExitExpressionSingleton is called when production expressionSingleton is exited. +func (s *BaseStarRocksSQLListener) ExitExpressionSingleton(ctx *ExpressionSingletonContext) {} + +// EnterExpressionDefault is called when production expressionDefault is entered. +func (s *BaseStarRocksSQLListener) EnterExpressionDefault(ctx *ExpressionDefaultContext) {} + +// ExitExpressionDefault is called when production expressionDefault is exited. +func (s *BaseStarRocksSQLListener) ExitExpressionDefault(ctx *ExpressionDefaultContext) {} + +// EnterLogicalNot is called when production logicalNot is entered. +func (s *BaseStarRocksSQLListener) EnterLogicalNot(ctx *LogicalNotContext) {} + +// ExitLogicalNot is called when production logicalNot is exited. +func (s *BaseStarRocksSQLListener) ExitLogicalNot(ctx *LogicalNotContext) {} + +// EnterLogicalBinary is called when production logicalBinary is entered. +func (s *BaseStarRocksSQLListener) EnterLogicalBinary(ctx *LogicalBinaryContext) {} + +// ExitLogicalBinary is called when production logicalBinary is exited. +func (s *BaseStarRocksSQLListener) ExitLogicalBinary(ctx *LogicalBinaryContext) {} + +// EnterExpressionList is called when production expressionList is entered. +func (s *BaseStarRocksSQLListener) EnterExpressionList(ctx *ExpressionListContext) {} + +// ExitExpressionList is called when production expressionList is exited. +func (s *BaseStarRocksSQLListener) ExitExpressionList(ctx *ExpressionListContext) {} + +// EnterComparison is called when production comparison is entered. +func (s *BaseStarRocksSQLListener) EnterComparison(ctx *ComparisonContext) {} + +// ExitComparison is called when production comparison is exited. +func (s *BaseStarRocksSQLListener) ExitComparison(ctx *ComparisonContext) {} + +// EnterBooleanExpressionDefault is called when production booleanExpressionDefault is entered. +func (s *BaseStarRocksSQLListener) EnterBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) { +} + +// ExitBooleanExpressionDefault is called when production booleanExpressionDefault is exited. +func (s *BaseStarRocksSQLListener) ExitBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) { +} + +// EnterIsNull is called when production isNull is entered. +func (s *BaseStarRocksSQLListener) EnterIsNull(ctx *IsNullContext) {} + +// ExitIsNull is called when production isNull is exited. +func (s *BaseStarRocksSQLListener) ExitIsNull(ctx *IsNullContext) {} + +// EnterScalarSubquery is called when production scalarSubquery is entered. +func (s *BaseStarRocksSQLListener) EnterScalarSubquery(ctx *ScalarSubqueryContext) {} + +// ExitScalarSubquery is called when production scalarSubquery is exited. +func (s *BaseStarRocksSQLListener) ExitScalarSubquery(ctx *ScalarSubqueryContext) {} + +// EnterPredicate is called when production predicate is entered. +func (s *BaseStarRocksSQLListener) EnterPredicate(ctx *PredicateContext) {} + +// ExitPredicate is called when production predicate is exited. +func (s *BaseStarRocksSQLListener) ExitPredicate(ctx *PredicateContext) {} + +// EnterTupleInSubquery is called when production tupleInSubquery is entered. +func (s *BaseStarRocksSQLListener) EnterTupleInSubquery(ctx *TupleInSubqueryContext) {} + +// ExitTupleInSubquery is called when production tupleInSubquery is exited. +func (s *BaseStarRocksSQLListener) ExitTupleInSubquery(ctx *TupleInSubqueryContext) {} + +// EnterInSubquery is called when production inSubquery is entered. +func (s *BaseStarRocksSQLListener) EnterInSubquery(ctx *InSubqueryContext) {} + +// ExitInSubquery is called when production inSubquery is exited. +func (s *BaseStarRocksSQLListener) ExitInSubquery(ctx *InSubqueryContext) {} + +// EnterInList is called when production inList is entered. +func (s *BaseStarRocksSQLListener) EnterInList(ctx *InListContext) {} + +// ExitInList is called when production inList is exited. +func (s *BaseStarRocksSQLListener) ExitInList(ctx *InListContext) {} + +// EnterBetween is called when production between is entered. +func (s *BaseStarRocksSQLListener) EnterBetween(ctx *BetweenContext) {} + +// ExitBetween is called when production between is exited. +func (s *BaseStarRocksSQLListener) ExitBetween(ctx *BetweenContext) {} + +// EnterLike is called when production like is entered. +func (s *BaseStarRocksSQLListener) EnterLike(ctx *LikeContext) {} + +// ExitLike is called when production like is exited. +func (s *BaseStarRocksSQLListener) ExitLike(ctx *LikeContext) {} + +// EnterValueExpressionDefault is called when production valueExpressionDefault is entered. +func (s *BaseStarRocksSQLListener) EnterValueExpressionDefault(ctx *ValueExpressionDefaultContext) {} + +// ExitValueExpressionDefault is called when production valueExpressionDefault is exited. +func (s *BaseStarRocksSQLListener) ExitValueExpressionDefault(ctx *ValueExpressionDefaultContext) {} + +// EnterArithmeticBinary is called when production arithmeticBinary is entered. +func (s *BaseStarRocksSQLListener) EnterArithmeticBinary(ctx *ArithmeticBinaryContext) {} + +// ExitArithmeticBinary is called when production arithmeticBinary is exited. +func (s *BaseStarRocksSQLListener) ExitArithmeticBinary(ctx *ArithmeticBinaryContext) {} + +// EnterDereference is called when production dereference is entered. +func (s *BaseStarRocksSQLListener) EnterDereference(ctx *DereferenceContext) {} + +// ExitDereference is called when production dereference is exited. +func (s *BaseStarRocksSQLListener) ExitDereference(ctx *DereferenceContext) {} + +// EnterOdbcFunctionCallExpression is called when production odbcFunctionCallExpression is entered. +func (s *BaseStarRocksSQLListener) EnterOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) { +} + +// ExitOdbcFunctionCallExpression is called when production odbcFunctionCallExpression is exited. +func (s *BaseStarRocksSQLListener) ExitOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) { +} + +// EnterMatchExpr is called when production matchExpr is entered. +func (s *BaseStarRocksSQLListener) EnterMatchExpr(ctx *MatchExprContext) {} + +// ExitMatchExpr is called when production matchExpr is exited. +func (s *BaseStarRocksSQLListener) ExitMatchExpr(ctx *MatchExprContext) {} + +// EnterColumnRef is called when production columnRef is entered. +func (s *BaseStarRocksSQLListener) EnterColumnRef(ctx *ColumnRefContext) {} + +// ExitColumnRef is called when production columnRef is exited. +func (s *BaseStarRocksSQLListener) ExitColumnRef(ctx *ColumnRefContext) {} + +// EnterConvert is called when production convert is entered. +func (s *BaseStarRocksSQLListener) EnterConvert(ctx *ConvertContext) {} + +// ExitConvert is called when production convert is exited. +func (s *BaseStarRocksSQLListener) ExitConvert(ctx *ConvertContext) {} + +// EnterCollectionSubscript is called when production collectionSubscript is entered. +func (s *BaseStarRocksSQLListener) EnterCollectionSubscript(ctx *CollectionSubscriptContext) {} + +// ExitCollectionSubscript is called when production collectionSubscript is exited. +func (s *BaseStarRocksSQLListener) ExitCollectionSubscript(ctx *CollectionSubscriptContext) {} + +// EnterLiteral is called when production literal is entered. +func (s *BaseStarRocksSQLListener) EnterLiteral(ctx *LiteralContext) {} + +// ExitLiteral is called when production literal is exited. +func (s *BaseStarRocksSQLListener) ExitLiteral(ctx *LiteralContext) {} + +// EnterCast is called when production cast is entered. +func (s *BaseStarRocksSQLListener) EnterCast(ctx *CastContext) {} + +// ExitCast is called when production cast is exited. +func (s *BaseStarRocksSQLListener) ExitCast(ctx *CastContext) {} + +// EnterParenthesizedExpression is called when production parenthesizedExpression is entered. +func (s *BaseStarRocksSQLListener) EnterParenthesizedExpression(ctx *ParenthesizedExpressionContext) { +} + +// ExitParenthesizedExpression is called when production parenthesizedExpression is exited. +func (s *BaseStarRocksSQLListener) ExitParenthesizedExpression(ctx *ParenthesizedExpressionContext) {} + +// EnterUserVariableExpression is called when production userVariableExpression is entered. +func (s *BaseStarRocksSQLListener) EnterUserVariableExpression(ctx *UserVariableExpressionContext) {} + +// ExitUserVariableExpression is called when production userVariableExpression is exited. +func (s *BaseStarRocksSQLListener) ExitUserVariableExpression(ctx *UserVariableExpressionContext) {} + +// EnterFunctionCallExpression is called when production functionCallExpression is entered. +func (s *BaseStarRocksSQLListener) EnterFunctionCallExpression(ctx *FunctionCallExpressionContext) {} + +// ExitFunctionCallExpression is called when production functionCallExpression is exited. +func (s *BaseStarRocksSQLListener) ExitFunctionCallExpression(ctx *FunctionCallExpressionContext) {} + +// EnterSimpleCase is called when production simpleCase is entered. +func (s *BaseStarRocksSQLListener) EnterSimpleCase(ctx *SimpleCaseContext) {} + +// ExitSimpleCase is called when production simpleCase is exited. +func (s *BaseStarRocksSQLListener) ExitSimpleCase(ctx *SimpleCaseContext) {} + +// EnterArrowExpression is called when production arrowExpression is entered. +func (s *BaseStarRocksSQLListener) EnterArrowExpression(ctx *ArrowExpressionContext) {} + +// ExitArrowExpression is called when production arrowExpression is exited. +func (s *BaseStarRocksSQLListener) ExitArrowExpression(ctx *ArrowExpressionContext) {} + +// EnterArrayExpr is called when production arrayExpr is entered. +func (s *BaseStarRocksSQLListener) EnterArrayExpr(ctx *ArrayExprContext) {} + +// ExitArrayExpr is called when production arrayExpr is exited. +func (s *BaseStarRocksSQLListener) ExitArrayExpr(ctx *ArrayExprContext) {} + +// EnterSystemVariableExpression is called when production systemVariableExpression is entered. +func (s *BaseStarRocksSQLListener) EnterSystemVariableExpression(ctx *SystemVariableExpressionContext) { +} + +// ExitSystemVariableExpression is called when production systemVariableExpression is exited. +func (s *BaseStarRocksSQLListener) ExitSystemVariableExpression(ctx *SystemVariableExpressionContext) { +} + +// EnterConcat is called when production concat is entered. +func (s *BaseStarRocksSQLListener) EnterConcat(ctx *ConcatContext) {} + +// ExitConcat is called when production concat is exited. +func (s *BaseStarRocksSQLListener) ExitConcat(ctx *ConcatContext) {} + +// EnterSubqueryExpression is called when production subqueryExpression is entered. +func (s *BaseStarRocksSQLListener) EnterSubqueryExpression(ctx *SubqueryExpressionContext) {} + +// ExitSubqueryExpression is called when production subqueryExpression is exited. +func (s *BaseStarRocksSQLListener) ExitSubqueryExpression(ctx *SubqueryExpressionContext) {} + +// EnterLambdaFunctionExpr is called when production lambdaFunctionExpr is entered. +func (s *BaseStarRocksSQLListener) EnterLambdaFunctionExpr(ctx *LambdaFunctionExprContext) {} + +// ExitLambdaFunctionExpr is called when production lambdaFunctionExpr is exited. +func (s *BaseStarRocksSQLListener) ExitLambdaFunctionExpr(ctx *LambdaFunctionExprContext) {} + +// EnterDictionaryGetExpr is called when production dictionaryGetExpr is entered. +func (s *BaseStarRocksSQLListener) EnterDictionaryGetExpr(ctx *DictionaryGetExprContext) {} + +// ExitDictionaryGetExpr is called when production dictionaryGetExpr is exited. +func (s *BaseStarRocksSQLListener) ExitDictionaryGetExpr(ctx *DictionaryGetExprContext) {} + +// EnterCollate is called when production collate is entered. +func (s *BaseStarRocksSQLListener) EnterCollate(ctx *CollateContext) {} + +// ExitCollate is called when production collate is exited. +func (s *BaseStarRocksSQLListener) ExitCollate(ctx *CollateContext) {} + +// EnterArrayConstructor is called when production arrayConstructor is entered. +func (s *BaseStarRocksSQLListener) EnterArrayConstructor(ctx *ArrayConstructorContext) {} + +// ExitArrayConstructor is called when production arrayConstructor is exited. +func (s *BaseStarRocksSQLListener) ExitArrayConstructor(ctx *ArrayConstructorContext) {} + +// EnterMapConstructor is called when production mapConstructor is entered. +func (s *BaseStarRocksSQLListener) EnterMapConstructor(ctx *MapConstructorContext) {} + +// ExitMapConstructor is called when production mapConstructor is exited. +func (s *BaseStarRocksSQLListener) ExitMapConstructor(ctx *MapConstructorContext) {} + +// EnterArraySlice is called when production arraySlice is entered. +func (s *BaseStarRocksSQLListener) EnterArraySlice(ctx *ArraySliceContext) {} + +// ExitArraySlice is called when production arraySlice is exited. +func (s *BaseStarRocksSQLListener) ExitArraySlice(ctx *ArraySliceContext) {} + +// EnterExists is called when production exists is entered. +func (s *BaseStarRocksSQLListener) EnterExists(ctx *ExistsContext) {} + +// ExitExists is called when production exists is exited. +func (s *BaseStarRocksSQLListener) ExitExists(ctx *ExistsContext) {} + +// EnterSearchedCase is called when production searchedCase is entered. +func (s *BaseStarRocksSQLListener) EnterSearchedCase(ctx *SearchedCaseContext) {} + +// ExitSearchedCase is called when production searchedCase is exited. +func (s *BaseStarRocksSQLListener) ExitSearchedCase(ctx *SearchedCaseContext) {} + +// EnterArithmeticUnary is called when production arithmeticUnary is entered. +func (s *BaseStarRocksSQLListener) EnterArithmeticUnary(ctx *ArithmeticUnaryContext) {} + +// ExitArithmeticUnary is called when production arithmeticUnary is exited. +func (s *BaseStarRocksSQLListener) ExitArithmeticUnary(ctx *ArithmeticUnaryContext) {} + +// EnterNullLiteral is called when production nullLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterNullLiteral(ctx *NullLiteralContext) {} + +// ExitNullLiteral is called when production nullLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitNullLiteral(ctx *NullLiteralContext) {} + +// EnterBooleanLiteral is called when production booleanLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterBooleanLiteral(ctx *BooleanLiteralContext) {} + +// ExitBooleanLiteral is called when production booleanLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitBooleanLiteral(ctx *BooleanLiteralContext) {} + +// EnterNumericLiteral is called when production numericLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterNumericLiteral(ctx *NumericLiteralContext) {} + +// ExitNumericLiteral is called when production numericLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitNumericLiteral(ctx *NumericLiteralContext) {} + +// EnterDateLiteral is called when production dateLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterDateLiteral(ctx *DateLiteralContext) {} + +// ExitDateLiteral is called when production dateLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitDateLiteral(ctx *DateLiteralContext) {} + +// EnterStringLiteral is called when production stringLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterStringLiteral(ctx *StringLiteralContext) {} + +// ExitStringLiteral is called when production stringLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitStringLiteral(ctx *StringLiteralContext) {} + +// EnterIntervalLiteral is called when production intervalLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterIntervalLiteral(ctx *IntervalLiteralContext) {} + +// ExitIntervalLiteral is called when production intervalLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitIntervalLiteral(ctx *IntervalLiteralContext) {} + +// EnterUnitBoundaryLiteral is called when production unitBoundaryLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) {} + +// ExitUnitBoundaryLiteral is called when production unitBoundaryLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) {} + +// EnterBinaryLiteral is called when production binaryLiteral is entered. +func (s *BaseStarRocksSQLListener) EnterBinaryLiteral(ctx *BinaryLiteralContext) {} + +// ExitBinaryLiteral is called when production binaryLiteral is exited. +func (s *BaseStarRocksSQLListener) ExitBinaryLiteral(ctx *BinaryLiteralContext) {} + +// EnterParameter is called when production Parameter is entered. +func (s *BaseStarRocksSQLListener) EnterParameter(ctx *ParameterContext) {} + +// ExitParameter is called when production Parameter is exited. +func (s *BaseStarRocksSQLListener) ExitParameter(ctx *ParameterContext) {} + +// EnterExtract is called when production extract is entered. +func (s *BaseStarRocksSQLListener) EnterExtract(ctx *ExtractContext) {} + +// ExitExtract is called when production extract is exited. +func (s *BaseStarRocksSQLListener) ExitExtract(ctx *ExtractContext) {} + +// EnterGroupingOperation is called when production groupingOperation is entered. +func (s *BaseStarRocksSQLListener) EnterGroupingOperation(ctx *GroupingOperationContext) {} + +// ExitGroupingOperation is called when production groupingOperation is exited. +func (s *BaseStarRocksSQLListener) ExitGroupingOperation(ctx *GroupingOperationContext) {} + +// EnterInformationFunction is called when production informationFunction is entered. +func (s *BaseStarRocksSQLListener) EnterInformationFunction(ctx *InformationFunctionContext) {} + +// ExitInformationFunction is called when production informationFunction is exited. +func (s *BaseStarRocksSQLListener) ExitInformationFunction(ctx *InformationFunctionContext) {} + +// EnterSpecialDateTime is called when production specialDateTime is entered. +func (s *BaseStarRocksSQLListener) EnterSpecialDateTime(ctx *SpecialDateTimeContext) {} + +// ExitSpecialDateTime is called when production specialDateTime is exited. +func (s *BaseStarRocksSQLListener) ExitSpecialDateTime(ctx *SpecialDateTimeContext) {} + +// EnterSpecialFunction is called when production specialFunction is entered. +func (s *BaseStarRocksSQLListener) EnterSpecialFunction(ctx *SpecialFunctionContext) {} + +// ExitSpecialFunction is called when production specialFunction is exited. +func (s *BaseStarRocksSQLListener) ExitSpecialFunction(ctx *SpecialFunctionContext) {} + +// EnterAggregationFunctionCall is called when production aggregationFunctionCall is entered. +func (s *BaseStarRocksSQLListener) EnterAggregationFunctionCall(ctx *AggregationFunctionCallContext) { +} + +// ExitAggregationFunctionCall is called when production aggregationFunctionCall is exited. +func (s *BaseStarRocksSQLListener) ExitAggregationFunctionCall(ctx *AggregationFunctionCallContext) {} + +// EnterWindowFunctionCall is called when production windowFunctionCall is entered. +func (s *BaseStarRocksSQLListener) EnterWindowFunctionCall(ctx *WindowFunctionCallContext) {} + +// ExitWindowFunctionCall is called when production windowFunctionCall is exited. +func (s *BaseStarRocksSQLListener) ExitWindowFunctionCall(ctx *WindowFunctionCallContext) {} + +// EnterTranslateFunctionCall is called when production translateFunctionCall is entered. +func (s *BaseStarRocksSQLListener) EnterTranslateFunctionCall(ctx *TranslateFunctionCallContext) {} + +// ExitTranslateFunctionCall is called when production translateFunctionCall is exited. +func (s *BaseStarRocksSQLListener) ExitTranslateFunctionCall(ctx *TranslateFunctionCallContext) {} + +// EnterSimpleFunctionCall is called when production simpleFunctionCall is entered. +func (s *BaseStarRocksSQLListener) EnterSimpleFunctionCall(ctx *SimpleFunctionCallContext) {} + +// ExitSimpleFunctionCall is called when production simpleFunctionCall is exited. +func (s *BaseStarRocksSQLListener) ExitSimpleFunctionCall(ctx *SimpleFunctionCallContext) {} + +// EnterAggregationFunction is called when production aggregationFunction is entered. +func (s *BaseStarRocksSQLListener) EnterAggregationFunction(ctx *AggregationFunctionContext) {} + +// ExitAggregationFunction is called when production aggregationFunction is exited. +func (s *BaseStarRocksSQLListener) ExitAggregationFunction(ctx *AggregationFunctionContext) {} + +// EnterUserVariable is called when production userVariable is entered. +func (s *BaseStarRocksSQLListener) EnterUserVariable(ctx *UserVariableContext) {} + +// ExitUserVariable is called when production userVariable is exited. +func (s *BaseStarRocksSQLListener) ExitUserVariable(ctx *UserVariableContext) {} + +// EnterSystemVariable is called when production systemVariable is entered. +func (s *BaseStarRocksSQLListener) EnterSystemVariable(ctx *SystemVariableContext) {} + +// ExitSystemVariable is called when production systemVariable is exited. +func (s *BaseStarRocksSQLListener) ExitSystemVariable(ctx *SystemVariableContext) {} + +// EnterColumnReference is called when production columnReference is entered. +func (s *BaseStarRocksSQLListener) EnterColumnReference(ctx *ColumnReferenceContext) {} + +// ExitColumnReference is called when production columnReference is exited. +func (s *BaseStarRocksSQLListener) ExitColumnReference(ctx *ColumnReferenceContext) {} + +// EnterInformationFunctionExpression is called when production informationFunctionExpression is entered. +func (s *BaseStarRocksSQLListener) EnterInformationFunctionExpression(ctx *InformationFunctionExpressionContext) { +} + +// ExitInformationFunctionExpression is called when production informationFunctionExpression is exited. +func (s *BaseStarRocksSQLListener) ExitInformationFunctionExpression(ctx *InformationFunctionExpressionContext) { +} + +// EnterSpecialDateTimeExpression is called when production specialDateTimeExpression is entered. +func (s *BaseStarRocksSQLListener) EnterSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) { +} + +// ExitSpecialDateTimeExpression is called when production specialDateTimeExpression is exited. +func (s *BaseStarRocksSQLListener) ExitSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) { +} + +// EnterSpecialFunctionExpression is called when production specialFunctionExpression is entered. +func (s *BaseStarRocksSQLListener) EnterSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) { +} + +// ExitSpecialFunctionExpression is called when production specialFunctionExpression is exited. +func (s *BaseStarRocksSQLListener) ExitSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) { +} + +// EnterWindowFunction is called when production windowFunction is entered. +func (s *BaseStarRocksSQLListener) EnterWindowFunction(ctx *WindowFunctionContext) {} + +// ExitWindowFunction is called when production windowFunction is exited. +func (s *BaseStarRocksSQLListener) ExitWindowFunction(ctx *WindowFunctionContext) {} + +// EnterWhenClause is called when production whenClause is entered. +func (s *BaseStarRocksSQLListener) EnterWhenClause(ctx *WhenClauseContext) {} + +// ExitWhenClause is called when production whenClause is exited. +func (s *BaseStarRocksSQLListener) ExitWhenClause(ctx *WhenClauseContext) {} + +// EnterOver is called when production over is entered. +func (s *BaseStarRocksSQLListener) EnterOver(ctx *OverContext) {} + +// ExitOver is called when production over is exited. +func (s *BaseStarRocksSQLListener) ExitOver(ctx *OverContext) {} + +// EnterIgnoreNulls is called when production ignoreNulls is entered. +func (s *BaseStarRocksSQLListener) EnterIgnoreNulls(ctx *IgnoreNullsContext) {} + +// ExitIgnoreNulls is called when production ignoreNulls is exited. +func (s *BaseStarRocksSQLListener) ExitIgnoreNulls(ctx *IgnoreNullsContext) {} + +// EnterWindowFrame is called when production windowFrame is entered. +func (s *BaseStarRocksSQLListener) EnterWindowFrame(ctx *WindowFrameContext) {} + +// ExitWindowFrame is called when production windowFrame is exited. +func (s *BaseStarRocksSQLListener) ExitWindowFrame(ctx *WindowFrameContext) {} + +// EnterUnboundedFrame is called when production unboundedFrame is entered. +func (s *BaseStarRocksSQLListener) EnterUnboundedFrame(ctx *UnboundedFrameContext) {} + +// ExitUnboundedFrame is called when production unboundedFrame is exited. +func (s *BaseStarRocksSQLListener) ExitUnboundedFrame(ctx *UnboundedFrameContext) {} + +// EnterCurrentRowBound is called when production currentRowBound is entered. +func (s *BaseStarRocksSQLListener) EnterCurrentRowBound(ctx *CurrentRowBoundContext) {} + +// ExitCurrentRowBound is called when production currentRowBound is exited. +func (s *BaseStarRocksSQLListener) ExitCurrentRowBound(ctx *CurrentRowBoundContext) {} + +// EnterBoundedFrame is called when production boundedFrame is entered. +func (s *BaseStarRocksSQLListener) EnterBoundedFrame(ctx *BoundedFrameContext) {} + +// ExitBoundedFrame is called when production boundedFrame is exited. +func (s *BaseStarRocksSQLListener) ExitBoundedFrame(ctx *BoundedFrameContext) {} + +// EnterBackupRestoreObjectDesc is called when production backupRestoreObjectDesc is entered. +func (s *BaseStarRocksSQLListener) EnterBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) { +} + +// ExitBackupRestoreObjectDesc is called when production backupRestoreObjectDesc is exited. +func (s *BaseStarRocksSQLListener) ExitBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) {} + +// EnterTableDesc is called when production tableDesc is entered. +func (s *BaseStarRocksSQLListener) EnterTableDesc(ctx *TableDescContext) {} + +// ExitTableDesc is called when production tableDesc is exited. +func (s *BaseStarRocksSQLListener) ExitTableDesc(ctx *TableDescContext) {} + +// EnterBackupRestoreTableDesc is called when production backupRestoreTableDesc is entered. +func (s *BaseStarRocksSQLListener) EnterBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) {} + +// ExitBackupRestoreTableDesc is called when production backupRestoreTableDesc is exited. +func (s *BaseStarRocksSQLListener) ExitBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) {} + +// EnterExplainDesc is called when production explainDesc is entered. +func (s *BaseStarRocksSQLListener) EnterExplainDesc(ctx *ExplainDescContext) {} + +// ExitExplainDesc is called when production explainDesc is exited. +func (s *BaseStarRocksSQLListener) ExitExplainDesc(ctx *ExplainDescContext) {} + +// EnterOptimizerTrace is called when production optimizerTrace is entered. +func (s *BaseStarRocksSQLListener) EnterOptimizerTrace(ctx *OptimizerTraceContext) {} + +// ExitOptimizerTrace is called when production optimizerTrace is exited. +func (s *BaseStarRocksSQLListener) ExitOptimizerTrace(ctx *OptimizerTraceContext) {} + +// EnterPartitionExpr is called when production partitionExpr is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionExpr(ctx *PartitionExprContext) {} + +// ExitPartitionExpr is called when production partitionExpr is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionExpr(ctx *PartitionExprContext) {} + +// EnterPartitionDesc is called when production partitionDesc is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionDesc(ctx *PartitionDescContext) {} + +// ExitPartitionDesc is called when production partitionDesc is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionDesc(ctx *PartitionDescContext) {} + +// EnterListPartitionDesc is called when production listPartitionDesc is entered. +func (s *BaseStarRocksSQLListener) EnterListPartitionDesc(ctx *ListPartitionDescContext) {} + +// ExitListPartitionDesc is called when production listPartitionDesc is exited. +func (s *BaseStarRocksSQLListener) ExitListPartitionDesc(ctx *ListPartitionDescContext) {} + +// EnterSingleItemListPartitionDesc is called when production singleItemListPartitionDesc is entered. +func (s *BaseStarRocksSQLListener) EnterSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) { +} + +// ExitSingleItemListPartitionDesc is called when production singleItemListPartitionDesc is exited. +func (s *BaseStarRocksSQLListener) ExitSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) { +} + +// EnterMultiItemListPartitionDesc is called when production multiItemListPartitionDesc is entered. +func (s *BaseStarRocksSQLListener) EnterMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) { +} + +// ExitMultiItemListPartitionDesc is called when production multiItemListPartitionDesc is exited. +func (s *BaseStarRocksSQLListener) ExitMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) { +} + +// EnterMultiListPartitionValues is called when production multiListPartitionValues is entered. +func (s *BaseStarRocksSQLListener) EnterMultiListPartitionValues(ctx *MultiListPartitionValuesContext) { +} + +// ExitMultiListPartitionValues is called when production multiListPartitionValues is exited. +func (s *BaseStarRocksSQLListener) ExitMultiListPartitionValues(ctx *MultiListPartitionValuesContext) { +} + +// EnterSingleListPartitionValues is called when production singleListPartitionValues is entered. +func (s *BaseStarRocksSQLListener) EnterSingleListPartitionValues(ctx *SingleListPartitionValuesContext) { +} + +// ExitSingleListPartitionValues is called when production singleListPartitionValues is exited. +func (s *BaseStarRocksSQLListener) ExitSingleListPartitionValues(ctx *SingleListPartitionValuesContext) { +} + +// EnterListPartitionValues is called when production listPartitionValues is entered. +func (s *BaseStarRocksSQLListener) EnterListPartitionValues(ctx *ListPartitionValuesContext) {} + +// ExitListPartitionValues is called when production listPartitionValues is exited. +func (s *BaseStarRocksSQLListener) ExitListPartitionValues(ctx *ListPartitionValuesContext) {} + +// EnterListPartitionValue is called when production listPartitionValue is entered. +func (s *BaseStarRocksSQLListener) EnterListPartitionValue(ctx *ListPartitionValueContext) {} + +// ExitListPartitionValue is called when production listPartitionValue is exited. +func (s *BaseStarRocksSQLListener) ExitListPartitionValue(ctx *ListPartitionValueContext) {} + +// EnterStringList is called when production stringList is entered. +func (s *BaseStarRocksSQLListener) EnterStringList(ctx *StringListContext) {} + +// ExitStringList is called when production stringList is exited. +func (s *BaseStarRocksSQLListener) ExitStringList(ctx *StringListContext) {} + +// EnterLiteralExpressionList is called when production literalExpressionList is entered. +func (s *BaseStarRocksSQLListener) EnterLiteralExpressionList(ctx *LiteralExpressionListContext) {} + +// ExitLiteralExpressionList is called when production literalExpressionList is exited. +func (s *BaseStarRocksSQLListener) ExitLiteralExpressionList(ctx *LiteralExpressionListContext) {} + +// EnterRangePartitionDesc is called when production rangePartitionDesc is entered. +func (s *BaseStarRocksSQLListener) EnterRangePartitionDesc(ctx *RangePartitionDescContext) {} + +// ExitRangePartitionDesc is called when production rangePartitionDesc is exited. +func (s *BaseStarRocksSQLListener) ExitRangePartitionDesc(ctx *RangePartitionDescContext) {} + +// EnterSingleRangePartition is called when production singleRangePartition is entered. +func (s *BaseStarRocksSQLListener) EnterSingleRangePartition(ctx *SingleRangePartitionContext) {} + +// ExitSingleRangePartition is called when production singleRangePartition is exited. +func (s *BaseStarRocksSQLListener) ExitSingleRangePartition(ctx *SingleRangePartitionContext) {} + +// EnterMultiRangePartition is called when production multiRangePartition is entered. +func (s *BaseStarRocksSQLListener) EnterMultiRangePartition(ctx *MultiRangePartitionContext) {} + +// ExitMultiRangePartition is called when production multiRangePartition is exited. +func (s *BaseStarRocksSQLListener) ExitMultiRangePartition(ctx *MultiRangePartitionContext) {} + +// EnterPartitionRangeDesc is called when production partitionRangeDesc is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionRangeDesc(ctx *PartitionRangeDescContext) {} + +// ExitPartitionRangeDesc is called when production partitionRangeDesc is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionRangeDesc(ctx *PartitionRangeDescContext) {} + +// EnterPartitionKeyDesc is called when production partitionKeyDesc is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionKeyDesc(ctx *PartitionKeyDescContext) {} + +// ExitPartitionKeyDesc is called when production partitionKeyDesc is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionKeyDesc(ctx *PartitionKeyDescContext) {} + +// EnterPartitionValueList is called when production partitionValueList is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionValueList(ctx *PartitionValueListContext) {} + +// ExitPartitionValueList is called when production partitionValueList is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionValueList(ctx *PartitionValueListContext) {} + +// EnterKeyPartition is called when production keyPartition is entered. +func (s *BaseStarRocksSQLListener) EnterKeyPartition(ctx *KeyPartitionContext) {} + +// ExitKeyPartition is called when production keyPartition is exited. +func (s *BaseStarRocksSQLListener) ExitKeyPartition(ctx *KeyPartitionContext) {} + +// EnterPartitionValue is called when production partitionValue is entered. +func (s *BaseStarRocksSQLListener) EnterPartitionValue(ctx *PartitionValueContext) {} + +// ExitPartitionValue is called when production partitionValue is exited. +func (s *BaseStarRocksSQLListener) ExitPartitionValue(ctx *PartitionValueContext) {} + +// EnterDistributionClause is called when production distributionClause is entered. +func (s *BaseStarRocksSQLListener) EnterDistributionClause(ctx *DistributionClauseContext) {} + +// ExitDistributionClause is called when production distributionClause is exited. +func (s *BaseStarRocksSQLListener) ExitDistributionClause(ctx *DistributionClauseContext) {} + +// EnterDistributionDesc is called when production distributionDesc is entered. +func (s *BaseStarRocksSQLListener) EnterDistributionDesc(ctx *DistributionDescContext) {} + +// ExitDistributionDesc is called when production distributionDesc is exited. +func (s *BaseStarRocksSQLListener) ExitDistributionDesc(ctx *DistributionDescContext) {} + +// EnterRefreshSchemeDesc is called when production refreshSchemeDesc is entered. +func (s *BaseStarRocksSQLListener) EnterRefreshSchemeDesc(ctx *RefreshSchemeDescContext) {} + +// ExitRefreshSchemeDesc is called when production refreshSchemeDesc is exited. +func (s *BaseStarRocksSQLListener) ExitRefreshSchemeDesc(ctx *RefreshSchemeDescContext) {} + +// EnterStatusDesc is called when production statusDesc is entered. +func (s *BaseStarRocksSQLListener) EnterStatusDesc(ctx *StatusDescContext) {} + +// ExitStatusDesc is called when production statusDesc is exited. +func (s *BaseStarRocksSQLListener) ExitStatusDesc(ctx *StatusDescContext) {} + +// EnterProperties is called when production properties is entered. +func (s *BaseStarRocksSQLListener) EnterProperties(ctx *PropertiesContext) {} + +// ExitProperties is called when production properties is exited. +func (s *BaseStarRocksSQLListener) ExitProperties(ctx *PropertiesContext) {} + +// EnterExtProperties is called when production extProperties is entered. +func (s *BaseStarRocksSQLListener) EnterExtProperties(ctx *ExtPropertiesContext) {} + +// ExitExtProperties is called when production extProperties is exited. +func (s *BaseStarRocksSQLListener) ExitExtProperties(ctx *ExtPropertiesContext) {} + +// EnterPropertyList is called when production propertyList is entered. +func (s *BaseStarRocksSQLListener) EnterPropertyList(ctx *PropertyListContext) {} + +// ExitPropertyList is called when production propertyList is exited. +func (s *BaseStarRocksSQLListener) ExitPropertyList(ctx *PropertyListContext) {} + +// EnterUserPropertyList is called when production userPropertyList is entered. +func (s *BaseStarRocksSQLListener) EnterUserPropertyList(ctx *UserPropertyListContext) {} + +// ExitUserPropertyList is called when production userPropertyList is exited. +func (s *BaseStarRocksSQLListener) ExitUserPropertyList(ctx *UserPropertyListContext) {} + +// EnterProperty is called when production property is entered. +func (s *BaseStarRocksSQLListener) EnterProperty(ctx *PropertyContext) {} + +// ExitProperty is called when production property is exited. +func (s *BaseStarRocksSQLListener) ExitProperty(ctx *PropertyContext) {} + +// EnterInlineProperties is called when production inlineProperties is entered. +func (s *BaseStarRocksSQLListener) EnterInlineProperties(ctx *InlinePropertiesContext) {} + +// ExitInlineProperties is called when production inlineProperties is exited. +func (s *BaseStarRocksSQLListener) ExitInlineProperties(ctx *InlinePropertiesContext) {} + +// EnterInlineProperty is called when production inlineProperty is entered. +func (s *BaseStarRocksSQLListener) EnterInlineProperty(ctx *InlinePropertyContext) {} + +// ExitInlineProperty is called when production inlineProperty is exited. +func (s *BaseStarRocksSQLListener) ExitInlineProperty(ctx *InlinePropertyContext) {} + +// EnterVarType is called when production varType is entered. +func (s *BaseStarRocksSQLListener) EnterVarType(ctx *VarTypeContext) {} + +// ExitVarType is called when production varType is exited. +func (s *BaseStarRocksSQLListener) ExitVarType(ctx *VarTypeContext) {} + +// EnterComment is called when production comment is entered. +func (s *BaseStarRocksSQLListener) EnterComment(ctx *CommentContext) {} + +// ExitComment is called when production comment is exited. +func (s *BaseStarRocksSQLListener) ExitComment(ctx *CommentContext) {} + +// EnterOutfile is called when production outfile is entered. +func (s *BaseStarRocksSQLListener) EnterOutfile(ctx *OutfileContext) {} + +// ExitOutfile is called when production outfile is exited. +func (s *BaseStarRocksSQLListener) ExitOutfile(ctx *OutfileContext) {} + +// EnterFileFormat is called when production fileFormat is entered. +func (s *BaseStarRocksSQLListener) EnterFileFormat(ctx *FileFormatContext) {} + +// ExitFileFormat is called when production fileFormat is exited. +func (s *BaseStarRocksSQLListener) ExitFileFormat(ctx *FileFormatContext) {} + +// EnterString is called when production string is entered. +func (s *BaseStarRocksSQLListener) EnterString(ctx *StringContext) {} + +// ExitString is called when production string is exited. +func (s *BaseStarRocksSQLListener) ExitString(ctx *StringContext) {} + +// EnterBinary is called when production binary is entered. +func (s *BaseStarRocksSQLListener) EnterBinary(ctx *BinaryContext) {} + +// ExitBinary is called when production binary is exited. +func (s *BaseStarRocksSQLListener) ExitBinary(ctx *BinaryContext) {} + +// EnterComparisonOperator is called when production comparisonOperator is entered. +func (s *BaseStarRocksSQLListener) EnterComparisonOperator(ctx *ComparisonOperatorContext) {} + +// ExitComparisonOperator is called when production comparisonOperator is exited. +func (s *BaseStarRocksSQLListener) ExitComparisonOperator(ctx *ComparisonOperatorContext) {} + +// EnterBooleanValue is called when production booleanValue is entered. +func (s *BaseStarRocksSQLListener) EnterBooleanValue(ctx *BooleanValueContext) {} + +// ExitBooleanValue is called when production booleanValue is exited. +func (s *BaseStarRocksSQLListener) ExitBooleanValue(ctx *BooleanValueContext) {} + +// EnterInterval is called when production interval is entered. +func (s *BaseStarRocksSQLListener) EnterInterval(ctx *IntervalContext) {} + +// ExitInterval is called when production interval is exited. +func (s *BaseStarRocksSQLListener) ExitInterval(ctx *IntervalContext) {} + +// EnterTaskInterval is called when production taskInterval is entered. +func (s *BaseStarRocksSQLListener) EnterTaskInterval(ctx *TaskIntervalContext) {} + +// ExitTaskInterval is called when production taskInterval is exited. +func (s *BaseStarRocksSQLListener) ExitTaskInterval(ctx *TaskIntervalContext) {} + +// EnterTaskUnitIdentifier is called when production taskUnitIdentifier is entered. +func (s *BaseStarRocksSQLListener) EnterTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) {} + +// ExitTaskUnitIdentifier is called when production taskUnitIdentifier is exited. +func (s *BaseStarRocksSQLListener) ExitTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) {} + +// EnterUnitIdentifier is called when production unitIdentifier is entered. +func (s *BaseStarRocksSQLListener) EnterUnitIdentifier(ctx *UnitIdentifierContext) {} + +// ExitUnitIdentifier is called when production unitIdentifier is exited. +func (s *BaseStarRocksSQLListener) ExitUnitIdentifier(ctx *UnitIdentifierContext) {} + +// EnterUnitBoundary is called when production unitBoundary is entered. +func (s *BaseStarRocksSQLListener) EnterUnitBoundary(ctx *UnitBoundaryContext) {} + +// ExitUnitBoundary is called when production unitBoundary is exited. +func (s *BaseStarRocksSQLListener) ExitUnitBoundary(ctx *UnitBoundaryContext) {} + +// EnterType is called when production type is entered. +func (s *BaseStarRocksSQLListener) EnterType(ctx *TypeContext) {} + +// ExitType is called when production type is exited. +func (s *BaseStarRocksSQLListener) ExitType(ctx *TypeContext) {} + +// EnterArrayType is called when production arrayType is entered. +func (s *BaseStarRocksSQLListener) EnterArrayType(ctx *ArrayTypeContext) {} + +// ExitArrayType is called when production arrayType is exited. +func (s *BaseStarRocksSQLListener) ExitArrayType(ctx *ArrayTypeContext) {} + +// EnterMapType is called when production mapType is entered. +func (s *BaseStarRocksSQLListener) EnterMapType(ctx *MapTypeContext) {} + +// ExitMapType is called when production mapType is exited. +func (s *BaseStarRocksSQLListener) ExitMapType(ctx *MapTypeContext) {} + +// EnterSubfieldDesc is called when production subfieldDesc is entered. +func (s *BaseStarRocksSQLListener) EnterSubfieldDesc(ctx *SubfieldDescContext) {} + +// ExitSubfieldDesc is called when production subfieldDesc is exited. +func (s *BaseStarRocksSQLListener) ExitSubfieldDesc(ctx *SubfieldDescContext) {} + +// EnterSubfieldDescs is called when production subfieldDescs is entered. +func (s *BaseStarRocksSQLListener) EnterSubfieldDescs(ctx *SubfieldDescsContext) {} + +// ExitSubfieldDescs is called when production subfieldDescs is exited. +func (s *BaseStarRocksSQLListener) ExitSubfieldDescs(ctx *SubfieldDescsContext) {} + +// EnterStructType is called when production structType is entered. +func (s *BaseStarRocksSQLListener) EnterStructType(ctx *StructTypeContext) {} + +// ExitStructType is called when production structType is exited. +func (s *BaseStarRocksSQLListener) ExitStructType(ctx *StructTypeContext) {} + +// EnterTypeParameter is called when production typeParameter is entered. +func (s *BaseStarRocksSQLListener) EnterTypeParameter(ctx *TypeParameterContext) {} + +// ExitTypeParameter is called when production typeParameter is exited. +func (s *BaseStarRocksSQLListener) ExitTypeParameter(ctx *TypeParameterContext) {} + +// EnterBaseType is called when production baseType is entered. +func (s *BaseStarRocksSQLListener) EnterBaseType(ctx *BaseTypeContext) {} + +// ExitBaseType is called when production baseType is exited. +func (s *BaseStarRocksSQLListener) ExitBaseType(ctx *BaseTypeContext) {} + +// EnterDecimalType is called when production decimalType is entered. +func (s *BaseStarRocksSQLListener) EnterDecimalType(ctx *DecimalTypeContext) {} + +// ExitDecimalType is called when production decimalType is exited. +func (s *BaseStarRocksSQLListener) ExitDecimalType(ctx *DecimalTypeContext) {} + +// EnterQualifiedName is called when production qualifiedName is entered. +func (s *BaseStarRocksSQLListener) EnterQualifiedName(ctx *QualifiedNameContext) {} + +// ExitQualifiedName is called when production qualifiedName is exited. +func (s *BaseStarRocksSQLListener) ExitQualifiedName(ctx *QualifiedNameContext) {} + +// EnterTableName is called when production tableName is entered. +func (s *BaseStarRocksSQLListener) EnterTableName(ctx *TableNameContext) {} + +// ExitTableName is called when production tableName is exited. +func (s *BaseStarRocksSQLListener) ExitTableName(ctx *TableNameContext) {} + +// EnterWriteBranch is called when production writeBranch is entered. +func (s *BaseStarRocksSQLListener) EnterWriteBranch(ctx *WriteBranchContext) {} + +// ExitWriteBranch is called when production writeBranch is exited. +func (s *BaseStarRocksSQLListener) ExitWriteBranch(ctx *WriteBranchContext) {} + +// EnterUnquotedIdentifier is called when production unquotedIdentifier is entered. +func (s *BaseStarRocksSQLListener) EnterUnquotedIdentifier(ctx *UnquotedIdentifierContext) {} + +// ExitUnquotedIdentifier is called when production unquotedIdentifier is exited. +func (s *BaseStarRocksSQLListener) ExitUnquotedIdentifier(ctx *UnquotedIdentifierContext) {} + +// EnterDigitIdentifier is called when production digitIdentifier is entered. +func (s *BaseStarRocksSQLListener) EnterDigitIdentifier(ctx *DigitIdentifierContext) {} + +// ExitDigitIdentifier is called when production digitIdentifier is exited. +func (s *BaseStarRocksSQLListener) ExitDigitIdentifier(ctx *DigitIdentifierContext) {} + +// EnterBackQuotedIdentifier is called when production backQuotedIdentifier is entered. +func (s *BaseStarRocksSQLListener) EnterBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) {} + +// ExitBackQuotedIdentifier is called when production backQuotedIdentifier is exited. +func (s *BaseStarRocksSQLListener) ExitBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) {} + +// EnterIdentifierWithAlias is called when production identifierWithAlias is entered. +func (s *BaseStarRocksSQLListener) EnterIdentifierWithAlias(ctx *IdentifierWithAliasContext) {} + +// ExitIdentifierWithAlias is called when production identifierWithAlias is exited. +func (s *BaseStarRocksSQLListener) ExitIdentifierWithAlias(ctx *IdentifierWithAliasContext) {} + +// EnterIdentifierWithAliasList is called when production identifierWithAliasList is entered. +func (s *BaseStarRocksSQLListener) EnterIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) { +} + +// ExitIdentifierWithAliasList is called when production identifierWithAliasList is exited. +func (s *BaseStarRocksSQLListener) ExitIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) {} + +// EnterIdentifierList is called when production identifierList is entered. +func (s *BaseStarRocksSQLListener) EnterIdentifierList(ctx *IdentifierListContext) {} + +// ExitIdentifierList is called when production identifierList is exited. +func (s *BaseStarRocksSQLListener) ExitIdentifierList(ctx *IdentifierListContext) {} + +// EnterIdentifierOrString is called when production identifierOrString is entered. +func (s *BaseStarRocksSQLListener) EnterIdentifierOrString(ctx *IdentifierOrStringContext) {} + +// ExitIdentifierOrString is called when production identifierOrString is exited. +func (s *BaseStarRocksSQLListener) ExitIdentifierOrString(ctx *IdentifierOrStringContext) {} + +// EnterIdentifierOrStringList is called when production identifierOrStringList is entered. +func (s *BaseStarRocksSQLListener) EnterIdentifierOrStringList(ctx *IdentifierOrStringListContext) {} + +// ExitIdentifierOrStringList is called when production identifierOrStringList is exited. +func (s *BaseStarRocksSQLListener) ExitIdentifierOrStringList(ctx *IdentifierOrStringListContext) {} + +// EnterIdentifierOrStringOrStar is called when production identifierOrStringOrStar is entered. +func (s *BaseStarRocksSQLListener) EnterIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) { +} + +// ExitIdentifierOrStringOrStar is called when production identifierOrStringOrStar is exited. +func (s *BaseStarRocksSQLListener) ExitIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) { +} + +// EnterUserWithoutHost is called when production userWithoutHost is entered. +func (s *BaseStarRocksSQLListener) EnterUserWithoutHost(ctx *UserWithoutHostContext) {} + +// ExitUserWithoutHost is called when production userWithoutHost is exited. +func (s *BaseStarRocksSQLListener) ExitUserWithoutHost(ctx *UserWithoutHostContext) {} + +// EnterUserWithHost is called when production userWithHost is entered. +func (s *BaseStarRocksSQLListener) EnterUserWithHost(ctx *UserWithHostContext) {} + +// ExitUserWithHost is called when production userWithHost is exited. +func (s *BaseStarRocksSQLListener) ExitUserWithHost(ctx *UserWithHostContext) {} + +// EnterUserWithHostAndBlanket is called when production userWithHostAndBlanket is entered. +func (s *BaseStarRocksSQLListener) EnterUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) {} + +// ExitUserWithHostAndBlanket is called when production userWithHostAndBlanket is exited. +func (s *BaseStarRocksSQLListener) ExitUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) {} + +// EnterAssignment is called when production assignment is entered. +func (s *BaseStarRocksSQLListener) EnterAssignment(ctx *AssignmentContext) {} + +// ExitAssignment is called when production assignment is exited. +func (s *BaseStarRocksSQLListener) ExitAssignment(ctx *AssignmentContext) {} + +// EnterAssignmentList is called when production assignmentList is entered. +func (s *BaseStarRocksSQLListener) EnterAssignmentList(ctx *AssignmentListContext) {} + +// ExitAssignmentList is called when production assignmentList is exited. +func (s *BaseStarRocksSQLListener) ExitAssignmentList(ctx *AssignmentListContext) {} + +// EnterDecimalValue is called when production decimalValue is entered. +func (s *BaseStarRocksSQLListener) EnterDecimalValue(ctx *DecimalValueContext) {} + +// ExitDecimalValue is called when production decimalValue is exited. +func (s *BaseStarRocksSQLListener) ExitDecimalValue(ctx *DecimalValueContext) {} + +// EnterDoubleValue is called when production doubleValue is entered. +func (s *BaseStarRocksSQLListener) EnterDoubleValue(ctx *DoubleValueContext) {} + +// ExitDoubleValue is called when production doubleValue is exited. +func (s *BaseStarRocksSQLListener) ExitDoubleValue(ctx *DoubleValueContext) {} + +// EnterIntegerValue is called when production integerValue is entered. +func (s *BaseStarRocksSQLListener) EnterIntegerValue(ctx *IntegerValueContext) {} + +// ExitIntegerValue is called when production integerValue is exited. +func (s *BaseStarRocksSQLListener) ExitIntegerValue(ctx *IntegerValueContext) {} + +// EnterNonReserved is called when production nonReserved is entered. +func (s *BaseStarRocksSQLListener) EnterNonReserved(ctx *NonReservedContext) {} + +// ExitNonReserved is called when production nonReserved is exited. +func (s *BaseStarRocksSQLListener) ExitNonReserved(ctx *NonReservedContext) {} diff --git a/starrocks/starrockssql_base_visitor.go b/starrocks/starrockssql_base_visitor.go new file mode 100644 index 0000000..067a606 --- /dev/null +++ b/starrocks/starrockssql_base_visitor.go @@ -0,0 +1,2568 @@ +// Code generated from StarRocksSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package starrocks // StarRocksSQL +import "github.com/antlr4-go/antlr/v4" + +type BaseStarRocksSQLVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseStarRocksSQLVisitor) VisitSqlStatements(ctx *SqlStatementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSingleStatement(ctx *SingleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitStatement(ctx *StatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUseDatabaseStatement(ctx *UseDatabaseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUseCatalogStatement(ctx *UseCatalogStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetCatalogStatement(ctx *SetCatalogStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateDbStatement(ctx *CreateDbStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropDbStatement(ctx *DropDbStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateDbStatement(ctx *ShowCreateDbStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRecoverDbStmt(ctx *RecoverDbStmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDataStmt(ctx *ShowDataStmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateTableStatement(ctx *CreateTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnDesc(ctx *ColumnDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCharsetName(ctx *CharsetNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDefaultDesc(ctx *DefaultDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGeneratedColumnDesc(ctx *GeneratedColumnDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIndexDesc(ctx *IndexDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitEngineDesc(ctx *EngineDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCharsetDesc(ctx *CharsetDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCollateDesc(ctx *CollateDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitKeyDesc(ctx *KeyDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOrderByDesc(ctx *OrderByDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnNullable(ctx *ColumnNullableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTypeWithNullable(ctx *TypeWithNullableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAggStateDesc(ctx *AggStateDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAggDesc(ctx *AggDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRollupDesc(ctx *RollupDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRollupItem(ctx *RollupItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDupKeys(ctx *DupKeysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitFromRollup(ctx *FromRollupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOrReplace(ctx *OrReplaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIfNotExists(ctx *IfNotExistsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropTableStatement(ctx *DropTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterTableStatement(ctx *AlterTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateIndexStatement(ctx *CreateIndexStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropIndexStatement(ctx *DropIndexStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIndexType(ctx *IndexTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTableStatement(ctx *ShowTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateTableStatement(ctx *ShowCreateTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowColumnStatement(ctx *ShowColumnStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTableStatusStatement(ctx *ShowTableStatusStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRefreshTableStatement(ctx *RefreshTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowAlterStatement(ctx *ShowAlterStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDescTableStatement(ctx *DescTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowIndexStatement(ctx *ShowIndexStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRecoverTableStatement(ctx *RecoverTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTruncateTableStatement(ctx *TruncateTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPartitionsStatement(ctx *ShowPartitionsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateViewStatement(ctx *CreateViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterViewStatement(ctx *AlterViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropViewStatement(ctx *DropViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnNameWithComment(ctx *ColumnNameWithCommentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubmitTaskStatement(ctx *SubmitTaskStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTaskClause(ctx *TaskClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropTaskStatement(ctx *DropTaskStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTaskScheduleDesc(ctx *TaskScheduleDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMvPartitionExprs(ctx *MvPartitionExprsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMaterializedViewDesc(ctx *MaterializedViewDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitKillStatement(ctx *KillStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSyncStatement(ctx *SyncStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterSystemStatement(ctx *AlterSystemStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCatalogsStatement(ctx *ShowCatalogsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterCatalogStatement(ctx *AlterCatalogStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTypeDesc(ctx *TypeDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLocationsDesc(ctx *LocationsDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowFailPointStatement(ctx *ShowFailPointStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropDictionaryStatement(ctx *DropDictionaryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDictionaryStatement(ctx *ShowDictionaryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDictionaryColumnDesc(ctx *DictionaryColumnDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDictionaryName(ctx *DictionaryNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterClause(ctx *AlterClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddFrontendClause(ctx *AddFrontendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropFrontendClause(ctx *DropFrontendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddBackendClause(ctx *AddBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropBackendClause(ctx *DropBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyBackendClause(ctx *ModifyBackendClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddComputeNodeClause(ctx *AddComputeNodeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropComputeNodeClause(ctx *DropComputeNodeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyBrokerClause(ctx *ModifyBrokerClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateImageClause(ctx *CreateImageClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDecommissionDiskClause(ctx *DecommissionDiskClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDisableDiskClause(ctx *DisableDiskClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateIndexClause(ctx *CreateIndexClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropIndexClause(ctx *DropIndexClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTableRenameClause(ctx *TableRenameClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSwapTableClause(ctx *SwapTableClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyCommentClause(ctx *ModifyCommentClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOptimizeRange(ctx *OptimizeRangeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOptimizeClause(ctx *OptimizeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddColumnClause(ctx *AddColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddColumnsClause(ctx *AddColumnsClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropColumnClause(ctx *DropColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyColumnClause(ctx *ModifyColumnClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnRenameClause(ctx *ColumnRenameClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitReorderColumnsClause(ctx *ReorderColumnsClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRollupRenameClause(ctx *RollupRenameClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCompactionClause(ctx *CompactionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubfieldName(ctx *SubfieldNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNestedFieldName(ctx *NestedFieldNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddFieldClause(ctx *AddFieldClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropFieldClause(ctx *DropFieldClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropBranchClause(ctx *DropBranchClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropTagClause(ctx *DropTagClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTableOperationClause(ctx *TableOperationClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTagOptions(ctx *TagOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBranchOptions(ctx *BranchOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSnapshotRetention(ctx *SnapshotRetentionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRefRetain(ctx *RefRetainContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMaxSnapshotAge(ctx *MaxSnapshotAgeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSnapshotId(ctx *SnapshotIdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTimeUnit(ctx *TimeUnitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInteger_list(ctx *Integer_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddPartitionClause(ctx *AddPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropPartitionClause(ctx *DropPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTruncatePartitionClause(ctx *TruncatePartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitModifyPartitionClause(ctx *ModifyPartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitReplacePartitionClause(ctx *ReplacePartitionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionRenameClause(ctx *PartitionRenameClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInsertStatement(ctx *InsertStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUpdateStatement(ctx *UpdateStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDeleteStatement(ctx *DeleteStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDataSource(ctx *DataSourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLoadProperties(ctx *LoadPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColSeparatorProperty(ctx *ColSeparatorPropertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRowDelimiterProperty(ctx *RowDelimiterPropertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitImportColumns(ctx *ImportColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnProperties(ctx *ColumnPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitJobProperties(ctx *JobPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDataSourceProperties(ctx *DataSourcePropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAnalyzeStatement(ctx *AnalyzeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRegularColumns(ctx *RegularColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAllColumns(ctx *AllColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPredicateColumns(ctx *PredicateColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMultiColumnSet(ctx *MultiColumnSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropStatsStatement(ctx *DropStatsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitHistogramStatement(ctx *HistogramStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropHistogramStatement(ctx *DropHistogramStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateResourceStatement(ctx *CreateResourceStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterResourceStatement(ctx *AlterResourceStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropResourceStatement(ctx *DropResourceStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowResourceStatement(ctx *ShowResourceStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitClassifier(ctx *ClassifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowFunctionsStatement(ctx *ShowFunctionsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropFunctionStatement(ctx *DropFunctionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateFunctionStatement(ctx *CreateFunctionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInlineFunction(ctx *InlineFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTypeList(ctx *TypeListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLoadStatement(ctx *LoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLabelName(ctx *LabelNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDataDescList(ctx *DataDescListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDataDesc(ctx *DataDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitFormatProps(ctx *FormatPropsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBrokerDesc(ctx *BrokerDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitResourceDesc(ctx *ResourceDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowLoadStatement(ctx *ShowLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelLoadStatement(ctx *CancelLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterLoadStatement(ctx *AlterLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelCompactionStatement(ctx *CancelCompactionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowAuthorStatement(ctx *ShowAuthorStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowBackendsStatement(ctx *ShowBackendsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowBrokerStatement(ctx *ShowBrokerStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCharsetStatement(ctx *ShowCharsetStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCollationStatement(ctx *ShowCollationStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDeleteStatement(ctx *ShowDeleteStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowEventsStatement(ctx *ShowEventsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowEnginesStatement(ctx *ShowEnginesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowFrontendsStatement(ctx *ShowFrontendsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPluginsStatement(ctx *ShowPluginsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowOpenTableStatement(ctx *ShowOpenTableStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowProcedureStatement(ctx *ShowProcedureStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowProcStatement(ctx *ShowProcStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowProcesslistStatement(ctx *ShowProcesslistStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowProfilelistStatement(ctx *ShowProfilelistStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowStatusStatement(ctx *ShowStatusStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTabletStatement(ctx *ShowTabletStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTransactionStatement(ctx *ShowTransactionStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTriggersStatement(ctx *ShowTriggersStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowVariablesStatement(ctx *ShowVariablesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowWarningStatement(ctx *ShowWarningStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitHelpStatement(ctx *HelpStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDataSkewStatement(ctx *ShowDataSkewStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDataTypesStatement(ctx *ShowDataTypesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowSyncJobStatement(ctx *ShowSyncJobStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPolicyStatement(ctx *ShowPolicyStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowLastInsertStatement(ctx *ShowLastInsertStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTableIdStatement(ctx *ShowTableIdStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTableStatsStatement(ctx *ShowTableStatsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowTrashStatement(ctx *ShowTrashStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowMigrationsStatement(ctx *ShowMigrationsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowJobTaskStatement(ctx *ShowJobTaskStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateUserStatement(ctx *CreateUserStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropUserStatement(ctx *DropUserStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterUserStatement(ctx *AlterUserStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowUserStatement(ctx *ShowUserStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowAllAuthentication(ctx *ShowAllAuthenticationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExecuteAsStatement(ctx *ExecuteAsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateRoleStatement(ctx *CreateRoleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterRoleStatement(ctx *AlterRoleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropRoleStatement(ctx *DropRoleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowRolesStatement(ctx *ShowRolesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantRoleToUser(ctx *GrantRoleToUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantRoleToRole(ctx *GrantRoleToRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetRoleStatement(ctx *SetRoleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantRevokeClause(ctx *GrantRevokeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantOnUser(ctx *GrantOnUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantOnTableBrief(ctx *GrantOnTableBriefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantOnFunc(ctx *GrantOnFuncContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantOnSystem(ctx *GrantOnSystemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGrantOnAll(ctx *GrantOnAllContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeOnUser(ctx *RevokeOnUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeOnFunc(ctx *RevokeOnFuncContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeOnSystem(ctx *RevokeOnSystemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRevokeOnAll(ctx *RevokeOnAllContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowGrantsStatement(ctx *ShowGrantsStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAuthWithoutPlugin(ctx *AuthWithoutPluginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAuthWithPlugin(ctx *AuthWithPluginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivObjectName(ctx *PrivObjectNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivObjectNameList(ctx *PrivObjectNameListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivilegeTypeList(ctx *PrivilegeTypeListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivilegeType(ctx *PrivilegeTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivObjectType(ctx *PrivObjectTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBackupStatement(ctx *BackupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelBackupStatement(ctx *CancelBackupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowBackupStatement(ctx *ShowBackupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRestoreStatement(ctx *RestoreStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelRestoreStatement(ctx *CancelRestoreStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowRestoreStatement(ctx *ShowRestoreStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowSnapshotStatement(ctx *ShowSnapshotStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropRepositoryStatement(ctx *DropRepositoryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowWhiteListStatement(ctx *ShowWhiteListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDataCacheTarget(ctx *DataCacheTargetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExportStatement(ctx *ExportStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCancelExportStatement(ctx *CancelExportStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowExportStatement(ctx *ShowExportStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInstallPluginStatement(ctx *InstallPluginStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUninstallPluginStatement(ctx *UninstallPluginStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateFileStatement(ctx *CreateFileStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropFileStatement(ctx *DropFileStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreatePipeStatement(ctx *CreatePipeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropPipeStatement(ctx *DropPipeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterPipeClause(ctx *AlterPipeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterPipeStatement(ctx *AlterPipeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDescPipeStatement(ctx *DescPipeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPipeStatement(ctx *ShowPipeStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetStatement(ctx *SetStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetNames(ctx *SetNamesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetPassword(ctx *SetPasswordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetUserVar(ctx *SetUserVarContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetSystemVar(ctx *SetSystemVarContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetTransaction(ctx *SetTransactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTransaction_characteristics(ctx *Transaction_characteristicsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTransaction_access_mode(ctx *Transaction_access_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIsolation_level(ctx *Isolation_levelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIsolation_types(ctx *Isolation_typesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetExprOrDefault(ctx *SetExprOrDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRoleList(ctx *RoleListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExecuteScriptStatement(ctx *ExecuteScriptStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUnsupportedStatement(ctx *UnsupportedStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLock_item(ctx *Lock_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLock_type(ctx *Lock_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropWarehouseStatement(ctx *DropWarehouseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetWarehouseStatement(ctx *SetWarehouseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowWarehousesStatement(ctx *ShowWarehousesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowClustersStatement(ctx *ShowClustersStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitShowNodesStatement(ctx *ShowNodesStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDropCNGroupStatement(ctx *DropCNGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBeginStatement(ctx *BeginStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCommitStatement(ctx *CommitStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRollbackStatement(ctx *RollbackStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTranslateStatement(ctx *TranslateStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDialect(ctx *DialectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTranslateSQL(ctx *TranslateSQLContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQueryStatement(ctx *QueryStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQueryRelation(ctx *QueryRelationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitWithClause(ctx *WithClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQueryNoWith(ctx *QueryNoWithContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQueryPeriod(ctx *QueryPeriodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPeriodType(ctx *PeriodTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQueryWithParentheses(ctx *QueryWithParenthesesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetOperation(ctx *SetOperationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubquery(ctx *SubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRowConstructor(ctx *RowConstructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSortItem(ctx *SortItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLimitConstExpr(ctx *LimitConstExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLimitElement(ctx *LimitElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQuerySpecification(ctx *QuerySpecificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitFrom(ctx *FromContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDual(ctx *DualContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRollup(ctx *RollupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCube(ctx *CubeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMultipleGroupingSets(ctx *MultipleGroupingSetsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSingleGroupingSet(ctx *SingleGroupingSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGroupingSet(ctx *GroupingSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCommonTableExpression(ctx *CommonTableExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSetQuantifier(ctx *SetQuantifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSelectSingle(ctx *SelectSingleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSelectAll(ctx *SelectAllContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExcludeClause(ctx *ExcludeClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRelations(ctx *RelationsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRelationLateralView(ctx *RelationLateralViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLateralView(ctx *LateralViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGeneratorFunction(ctx *GeneratorFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRelation(ctx *RelationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTableAtom(ctx *TableAtomContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInlineTable(ctx *InlineTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubqueryWithAlias(ctx *SubqueryWithAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTableFunction(ctx *TableFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNormalizedTableFunction(ctx *NormalizedTableFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitFileTableFunction(ctx *FileTableFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitParenthesizedRelation(ctx *ParenthesizedRelationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPivotClause(ctx *PivotClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPivotAggregationExpression(ctx *PivotAggregationExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPivotValue(ctx *PivotValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSampleClause(ctx *SampleClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArgumentList(ctx *ArgumentListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNamedArgumentList(ctx *NamedArgumentListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNamedArguments(ctx *NamedArgumentsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitJoinRelation(ctx *JoinRelationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBracketHint(ctx *BracketHintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitHintMap(ctx *HintMapContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitJoinCriteria(ctx *JoinCriteriaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnAliases(ctx *ColumnAliasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionNames(ctx *PartitionNamesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitKeyPartitionList(ctx *KeyPartitionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTabletList(ctx *TabletListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrepareStatement(ctx *PrepareStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPrepareSql(ctx *PrepareSqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExecuteStatement(ctx *ExecuteStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDeallocateStatement(ctx *DeallocateStatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitReplicaList(ctx *ReplicaListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExpressionOrDefault(ctx *ExpressionOrDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMapExpressionList(ctx *MapExpressionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMapExpression(ctx *MapExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExpressionSingleton(ctx *ExpressionSingletonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExpressionDefault(ctx *ExpressionDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLogicalNot(ctx *LogicalNotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLogicalBinary(ctx *LogicalBinaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExpressionList(ctx *ExpressionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitComparison(ctx *ComparisonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIsNull(ctx *IsNullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitScalarSubquery(ctx *ScalarSubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPredicate(ctx *PredicateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTupleInSubquery(ctx *TupleInSubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInSubquery(ctx *InSubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInList(ctx *InListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBetween(ctx *BetweenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLike(ctx *LikeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitValueExpressionDefault(ctx *ValueExpressionDefaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArithmeticBinary(ctx *ArithmeticBinaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDereference(ctx *DereferenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMatchExpr(ctx *MatchExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnRef(ctx *ColumnRefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitConvert(ctx *ConvertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCollectionSubscript(ctx *CollectionSubscriptContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLiteral(ctx *LiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCast(ctx *CastContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUserVariableExpression(ctx *UserVariableExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSimpleCase(ctx *SimpleCaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArrowExpression(ctx *ArrowExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArrayExpr(ctx *ArrayExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSystemVariableExpression(ctx *SystemVariableExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitConcat(ctx *ConcatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubqueryExpression(ctx *SubqueryExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLambdaFunctionExpr(ctx *LambdaFunctionExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDictionaryGetExpr(ctx *DictionaryGetExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCollate(ctx *CollateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArrayConstructor(ctx *ArrayConstructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMapConstructor(ctx *MapConstructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArraySlice(ctx *ArraySliceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExists(ctx *ExistsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSearchedCase(ctx *SearchedCaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArithmeticUnary(ctx *ArithmeticUnaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNullLiteral(ctx *NullLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNumericLiteral(ctx *NumericLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDateLiteral(ctx *DateLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIntervalLiteral(ctx *IntervalLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBinaryLiteral(ctx *BinaryLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitParameter(ctx *ParameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExtract(ctx *ExtractContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitGroupingOperation(ctx *GroupingOperationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInformationFunction(ctx *InformationFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSpecialDateTime(ctx *SpecialDateTimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSpecialFunction(ctx *SpecialFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAggregationFunctionCall(ctx *AggregationFunctionCallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitWindowFunctionCall(ctx *WindowFunctionCallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTranslateFunctionCall(ctx *TranslateFunctionCallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSimpleFunctionCall(ctx *SimpleFunctionCallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAggregationFunction(ctx *AggregationFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUserVariable(ctx *UserVariableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSystemVariable(ctx *SystemVariableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitColumnReference(ctx *ColumnReferenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInformationFunctionExpression(ctx *InformationFunctionExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitWindowFunction(ctx *WindowFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitWhenClause(ctx *WhenClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOver(ctx *OverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIgnoreNulls(ctx *IgnoreNullsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitWindowFrame(ctx *WindowFrameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUnboundedFrame(ctx *UnboundedFrameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitCurrentRowBound(ctx *CurrentRowBoundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBoundedFrame(ctx *BoundedFrameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTableDesc(ctx *TableDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExplainDesc(ctx *ExplainDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOptimizerTrace(ctx *OptimizerTraceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionExpr(ctx *PartitionExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionDesc(ctx *PartitionDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitListPartitionDesc(ctx *ListPartitionDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMultiListPartitionValues(ctx *MultiListPartitionValuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSingleListPartitionValues(ctx *SingleListPartitionValuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitListPartitionValues(ctx *ListPartitionValuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitListPartitionValue(ctx *ListPartitionValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitStringList(ctx *StringListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitLiteralExpressionList(ctx *LiteralExpressionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRangePartitionDesc(ctx *RangePartitionDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSingleRangePartition(ctx *SingleRangePartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMultiRangePartition(ctx *MultiRangePartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionRangeDesc(ctx *PartitionRangeDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionKeyDesc(ctx *PartitionKeyDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionValueList(ctx *PartitionValueListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitKeyPartition(ctx *KeyPartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPartitionValue(ctx *PartitionValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDistributionClause(ctx *DistributionClauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDistributionDesc(ctx *DistributionDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitRefreshSchemeDesc(ctx *RefreshSchemeDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitStatusDesc(ctx *StatusDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitProperties(ctx *PropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitExtProperties(ctx *ExtPropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitPropertyList(ctx *PropertyListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUserPropertyList(ctx *UserPropertyListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitProperty(ctx *PropertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInlineProperties(ctx *InlinePropertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInlineProperty(ctx *InlinePropertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitVarType(ctx *VarTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitComment(ctx *CommentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitOutfile(ctx *OutfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitFileFormat(ctx *FileFormatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitString(ctx *StringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBinary(ctx *BinaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBooleanValue(ctx *BooleanValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitInterval(ctx *IntervalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTaskInterval(ctx *TaskIntervalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUnitIdentifier(ctx *UnitIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUnitBoundary(ctx *UnitBoundaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitType(ctx *TypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitArrayType(ctx *ArrayTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitMapType(ctx *MapTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubfieldDesc(ctx *SubfieldDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitSubfieldDescs(ctx *SubfieldDescsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitStructType(ctx *StructTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTypeParameter(ctx *TypeParameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBaseType(ctx *BaseTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDecimalType(ctx *DecimalTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitQualifiedName(ctx *QualifiedNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitTableName(ctx *TableNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitWriteBranch(ctx *WriteBranchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUnquotedIdentifier(ctx *UnquotedIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDigitIdentifier(ctx *DigitIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIdentifierWithAlias(ctx *IdentifierWithAliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIdentifierList(ctx *IdentifierListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIdentifierOrString(ctx *IdentifierOrStringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIdentifierOrStringList(ctx *IdentifierOrStringListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUserWithoutHost(ctx *UserWithoutHostContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUserWithHost(ctx *UserWithHostContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAssignment(ctx *AssignmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitAssignmentList(ctx *AssignmentListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDecimalValue(ctx *DecimalValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitDoubleValue(ctx *DoubleValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitIntegerValue(ctx *IntegerValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseStarRocksSQLVisitor) VisitNonReserved(ctx *NonReservedContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/doris/dorissql_lexer.go b/starrocks/starrockssql_lexer.go similarity index 87% rename from doris/dorissql_lexer.go rename to starrocks/starrockssql_lexer.go index 85f9c14..bce18d0 100644 --- a/doris/dorissql_lexer.go +++ b/starrocks/starrockssql_lexer.go @@ -1,6 +1,6 @@ -// Code generated from DorisSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from StarRocksSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. -package doris +package starrocks import ( "fmt" @@ -14,14 +14,14 @@ var _ = fmt.Printf var _ = sync.Once{} var _ = unicode.IsLetter -type DorisSQLLexer struct { +type StarRocksSQLLexer struct { *antlr.BaseLexer channelNames []string modeNames []string // TODO: EOF string } -var DorisSQLLexerLexerStaticData struct { +var StarRocksSQLLexerLexerStaticData struct { once sync.Once serializedATN []int32 ChannelNames []string @@ -34,8 +34,8 @@ var DorisSQLLexerLexerStaticData struct { decisionToDFA []*antlr.DFA } -func dorissqllexerLexerInit() { - staticData := &DorisSQLLexerLexerStaticData +func starrockssqllexerLexerInit() { + staticData := &StarRocksSQLLexerLexerStaticData staticData.ChannelNames = []string{ "DEFAULT_TOKEN_CHANNEL", "HIDDEN", } @@ -2760,585 +2760,585 @@ func dorissqllexerLexerInit() { } } -// DorisSQLLexerInit initializes any static state used to implement DorisSQLLexer. By default the +// StarRocksSQLLexerInit initializes any static state used to implement StarRocksSQLLexer. By default the // static state used to implement the lexer is lazily initialized during the first call to -// NewDorisSQLLexer(). You can call this function if you wish to initialize the static state ahead +// NewStarRocksSQLLexer(). You can call this function if you wish to initialize the static state ahead // of time. -func DorisSQLLexerInit() { - staticData := &DorisSQLLexerLexerStaticData - staticData.once.Do(dorissqllexerLexerInit) +func StarRocksSQLLexerInit() { + staticData := &StarRocksSQLLexerLexerStaticData + staticData.once.Do(starrockssqllexerLexerInit) } -// NewDorisSQLLexer produces a new lexer instance for the optional input antlr.CharStream. -func NewDorisSQLLexer(input antlr.CharStream) *DorisSQLLexer { - DorisSQLLexerInit() - l := new(DorisSQLLexer) +// NewStarRocksSQLLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewStarRocksSQLLexer(input antlr.CharStream) *StarRocksSQLLexer { + StarRocksSQLLexerInit() + l := new(StarRocksSQLLexer) l.BaseLexer = antlr.NewBaseLexer(input) - staticData := &DorisSQLLexerLexerStaticData + staticData := &StarRocksSQLLexerLexerStaticData l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) l.channelNames = staticData.ChannelNames l.modeNames = staticData.ModeNames l.RuleNames = staticData.RuleNames l.LiteralNames = staticData.LiteralNames l.SymbolicNames = staticData.SymbolicNames - l.GrammarFileName = "DorisSQL.g4" + l.GrammarFileName = "StarRocksSQL.g4" // TODO: l.EOF = antlr.TokenEOF return l } -// DorisSQLLexer tokens. +// StarRocksSQLLexer tokens. const ( - DorisSQLLexerT__0 = 1 - DorisSQLLexerT__1 = 2 - DorisSQLLexerT__2 = 3 - DorisSQLLexerT__3 = 4 - DorisSQLLexerT__4 = 5 - DorisSQLLexerT__5 = 6 - DorisSQLLexerT__6 = 7 - DorisSQLLexerT__7 = 8 - DorisSQLLexerT__8 = 9 - DorisSQLLexerT__9 = 10 - DorisSQLLexerACCESS = 11 - DorisSQLLexerACTIVE = 12 - DorisSQLLexerADD = 13 - DorisSQLLexerADMIN = 14 - DorisSQLLexerADVISOR = 15 - DorisSQLLexerAFTER = 16 - DorisSQLLexerAGGREGATE = 17 - DorisSQLLexerALL = 18 - DorisSQLLexerALTER = 19 - DorisSQLLexerANALYZE = 20 - DorisSQLLexerAND = 21 - DorisSQLLexerANTI = 22 - DorisSQLLexerAPPLY = 23 - DorisSQLLexerARRAY = 24 - DorisSQLLexerARRAY_AGG = 25 - DorisSQLLexerARRAY_AGG_DISTINCT = 26 - DorisSQLLexerAS = 27 - DorisSQLLexerASC = 28 - DorisSQLLexerASYNC = 29 - DorisSQLLexerAUTHORS = 30 - DorisSQLLexerAUTHENTICATION = 31 - DorisSQLLexerAUTOMATED = 32 - DorisSQLLexerAUTO_INCREMENT = 33 - DorisSQLLexerAVG = 34 - DorisSQLLexerBACKEND = 35 - DorisSQLLexerBACKENDS = 36 - DorisSQLLexerBACKUP = 37 - DorisSQLLexerBASE = 38 - DorisSQLLexerBASELINE = 39 - DorisSQLLexerBEGIN = 40 - DorisSQLLexerBETWEEN = 41 - DorisSQLLexerBIGINT = 42 - DorisSQLLexerBINARY = 43 - DorisSQLLexerBITMAP = 44 - DorisSQLLexerBITMAP_UNION = 45 - DorisSQLLexerBLACKHOLE = 46 - DorisSQLLexerBLACKLIST = 47 - DorisSQLLexerBODY = 48 - DorisSQLLexerBOOLEAN = 49 - DorisSQLLexerBOTH = 50 - DorisSQLLexerBRANCH = 51 - DorisSQLLexerBROKER = 52 - DorisSQLLexerBUCKETS = 53 - DorisSQLLexerBUILTIN = 54 - DorisSQLLexerBY = 55 - DorisSQLLexerCACHE = 56 - DorisSQLLexerCANCEL = 57 - DorisSQLLexerCASE = 58 - DorisSQLLexerCAST = 59 - DorisSQLLexerCATALOG = 60 - DorisSQLLexerCATALOGS = 61 - DorisSQLLexerCEIL = 62 - DorisSQLLexerCHAIN = 63 - DorisSQLLexerCHAR = 64 - DorisSQLLexerCHARACTER = 65 - DorisSQLLexerCHARSET = 66 - DorisSQLLexerCHECK = 67 - DorisSQLLexerCLEAN = 68 - DorisSQLLexerCLEAR = 69 - DorisSQLLexerCLUSTER = 70 - DorisSQLLexerCLUSTERS = 71 - DorisSQLLexerCNGROUP = 72 - DorisSQLLexerCNGROUPS = 73 - DorisSQLLexerCOLLATE = 74 - DorisSQLLexerCOLLATION = 75 - DorisSQLLexerCOLUMN = 76 - DorisSQLLexerCOLUMNS = 77 - DorisSQLLexerCOMMENT = 78 - DorisSQLLexerCOMMIT = 79 - DorisSQLLexerCOMMITTED = 80 - DorisSQLLexerCOMPACT = 81 - DorisSQLLexerCOMPACTION = 82 - DorisSQLLexerCOMPUTE = 83 - DorisSQLLexerCONFIG = 84 - DorisSQLLexerCONNECTION = 85 - DorisSQLLexerCONSISTENT = 86 - DorisSQLLexerCONVERT = 87 - DorisSQLLexerCOSTS = 88 - DorisSQLLexerCOUNT = 89 - DorisSQLLexerCREATE = 90 - DorisSQLLexerCROSS = 91 - DorisSQLLexerCUBE = 92 - DorisSQLLexerCUME_DIST = 93 - DorisSQLLexerCUMULATIVE = 94 - DorisSQLLexerCURRENT = 95 - DorisSQLLexerCURRENT_DATE = 96 - DorisSQLLexerCURRENT_GROUP = 97 - DorisSQLLexerCURRENT_ROLE = 98 - DorisSQLLexerCURRENT_TIME = 99 - DorisSQLLexerCURRENT_TIMESTAMP = 100 - DorisSQLLexerCURRENT_USER = 101 - DorisSQLLexerDATA = 102 - DorisSQLLexerDATACACHE = 103 - DorisSQLLexerDATABASE = 104 - DorisSQLLexerDATABASES = 105 - DorisSQLLexerDATE = 106 - DorisSQLLexerDATETIME = 107 - DorisSQLLexerDAY = 108 - DorisSQLLexerDAYS = 109 - DorisSQLLexerDEALLOCATE = 110 - DorisSQLLexerDECIMAL = 111 - DorisSQLLexerDECIMALV2 = 112 - DorisSQLLexerDECIMAL32 = 113 - DorisSQLLexerDECIMAL64 = 114 - DorisSQLLexerDECIMAL128 = 115 - DorisSQLLexerDECOMMISSION = 116 - DorisSQLLexerDEFAULT = 117 - DorisSQLLexerDELETE = 118 - DorisSQLLexerDENSE_RANK = 119 - DorisSQLLexerDEFERRED = 120 - DorisSQLLexerDIALECT = 121 - DorisSQLLexerDICTIONARY = 122 - DorisSQLLexerDICTIONARY_GET = 123 - DorisSQLLexerNTILE = 124 - DorisSQLLexerDESC = 125 - DorisSQLLexerDESCRIBE = 126 - DorisSQLLexerDISABLE = 127 - DorisSQLLexerDISTINCT = 128 - DorisSQLLexerDISTRIBUTED = 129 - DorisSQLLexerDISTRIBUTION = 130 - DorisSQLLexerDOUBLE = 131 - DorisSQLLexerDROP = 132 - DorisSQLLexerDUAL = 133 - DorisSQLLexerDUPLICATE = 134 - DorisSQLLexerDYNAMIC = 135 - DorisSQLLexerELSE = 136 - DorisSQLLexerENABLE = 137 - DorisSQLLexerENCLOSE = 138 - DorisSQLLexerEND = 139 - DorisSQLLexerENGINE = 140 - DorisSQLLexerENGINES = 141 - DorisSQLLexerERRORS = 142 - DorisSQLLexerESCAPE = 143 - DorisSQLLexerEVENTS = 144 - DorisSQLLexerEXCEPT = 145 - DorisSQLLexerEXCLUDE = 146 - DorisSQLLexerEXECUTE = 147 - DorisSQLLexerEXISTS = 148 - DorisSQLLexerEXPLAIN = 149 - DorisSQLLexerEXPLODE = 150 - DorisSQLLexerEXPLODE_SPLIT = 151 - DorisSQLLexerEXPORT = 152 - DorisSQLLexerEXTERNAL = 153 - DorisSQLLexerEXTRACT = 154 - DorisSQLLexerEVERY = 155 - DorisSQLLexerFAILPOINT = 156 - DorisSQLLexerFAILPOINTS = 157 - DorisSQLLexerFALSE = 158 - DorisSQLLexerFIELDS = 159 - DorisSQLLexerFILE = 160 - DorisSQLLexerFILES = 161 - DorisSQLLexerFILTER = 162 - DorisSQLLexerFIRST = 163 - DorisSQLLexerFIRST_VALUE = 164 - DorisSQLLexerFLOAT = 165 - DorisSQLLexerFLOOR = 166 - DorisSQLLexerFN = 167 - DorisSQLLexerFOLLOWING = 168 - DorisSQLLexerFOLLOWER = 169 - DorisSQLLexerFOR = 170 - DorisSQLLexerFORCE = 171 - DorisSQLLexerFORMAT = 172 - DorisSQLLexerFREE = 173 - DorisSQLLexerFROM = 174 - DorisSQLLexerFRONTEND = 175 - DorisSQLLexerFRONTENDS = 176 - DorisSQLLexerFULL = 177 - DorisSQLLexerFUNCTION = 178 - DorisSQLLexerFUNCTIONS = 179 - DorisSQLLexerGLOBAL = 180 - DorisSQLLexerGRANT = 181 - DorisSQLLexerGRANTS = 182 - DorisSQLLexerGROUP = 183 - DorisSQLLexerGROUPS = 184 - DorisSQLLexerGROUPING = 185 - DorisSQLLexerGROUPING_ID = 186 - DorisSQLLexerGROUP_CONCAT = 187 - DorisSQLLexerHASH = 188 - DorisSQLLexerHAVING = 189 - DorisSQLLexerHELP = 190 - DorisSQLLexerHISTOGRAM = 191 - DorisSQLLexerHLL = 192 - DorisSQLLexerHLL_UNION = 193 - DorisSQLLexerHOST = 194 - DorisSQLLexerHOUR = 195 - DorisSQLLexerHOURS = 196 - DorisSQLLexerHUB = 197 - DorisSQLLexerIDENTIFIED = 198 - DorisSQLLexerIF = 199 - DorisSQLLexerIMPERSONATE = 200 - DorisSQLLexerIMMEDIATE = 201 - DorisSQLLexerIGNORE = 202 - DorisSQLLexerIMAGE = 203 - DorisSQLLexerIN = 204 - DorisSQLLexerINACTIVE = 205 - DorisSQLLexerINCREMENTAL = 206 - DorisSQLLexerINDEX = 207 - DorisSQLLexerINDEXES = 208 - DorisSQLLexerINFILE = 209 - DorisSQLLexerINNER = 210 - DorisSQLLexerINSTALL = 211 - DorisSQLLexerINSERT = 212 - DorisSQLLexerINT = 213 - DorisSQLLexerINTEGER = 214 - DorisSQLLexerINTEGRATION = 215 - DorisSQLLexerINTEGRATIONS = 216 - DorisSQLLexerINTERMEDIATE = 217 - DorisSQLLexerINTERSECT = 218 - DorisSQLLexerINTERVAL = 219 - DorisSQLLexerINTO = 220 - DorisSQLLexerINVOKER = 221 - DorisSQLLexerGIN = 222 - DorisSQLLexerOVERWRITE = 223 - DorisSQLLexerIS = 224 - DorisSQLLexerISOLATION = 225 - DorisSQLLexerJOB = 226 - DorisSQLLexerJOIN = 227 - DorisSQLLexerJSON = 228 - DorisSQLLexerKEY = 229 - DorisSQLLexerKEYS = 230 - DorisSQLLexerKILL = 231 - DorisSQLLexerLABEL = 232 - DorisSQLLexerLAG = 233 - DorisSQLLexerLARGEINT = 234 - DorisSQLLexerLAST = 235 - DorisSQLLexerLAST_VALUE = 236 - DorisSQLLexerLATERAL = 237 - DorisSQLLexerLEAD = 238 - DorisSQLLexerLEFT = 239 - DorisSQLLexerLESS = 240 - DorisSQLLexerLEVEL = 241 - DorisSQLLexerLIKE = 242 - DorisSQLLexerLIMIT = 243 - DorisSQLLexerLIST = 244 - DorisSQLLexerLOAD = 245 - DorisSQLLexerLOCAL = 246 - DorisSQLLexerLOCALTIME = 247 - DorisSQLLexerLOCALTIMESTAMP = 248 - DorisSQLLexerLOCATION = 249 - DorisSQLLexerLOCATIONS = 250 - DorisSQLLexerLOGS = 251 - DorisSQLLexerLOGICAL = 252 - DorisSQLLexerMANUAL = 253 - DorisSQLLexerMAP = 254 - DorisSQLLexerMAPPING = 255 - DorisSQLLexerMAPPINGS = 256 - DorisSQLLexerMASKING = 257 - DorisSQLLexerMATCH = 258 - DorisSQLLexerMATERIALIZED = 259 - DorisSQLLexerMAX = 260 - DorisSQLLexerMAXVALUE = 261 - DorisSQLLexerMERGE = 262 - DorisSQLLexerMICROSECOND = 263 - DorisSQLLexerMILLISECOND = 264 - DorisSQLLexerMIN = 265 - DorisSQLLexerMINUTE = 266 - DorisSQLLexerMINUTES = 267 - DorisSQLLexerMINUS = 268 - DorisSQLLexerMETA = 269 - DorisSQLLexerMOD = 270 - DorisSQLLexerMODE = 271 - DorisSQLLexerMODIFY = 272 - DorisSQLLexerMONTH = 273 - DorisSQLLexerMULTIPLE = 274 - DorisSQLLexerNAME = 275 - DorisSQLLexerNAMES = 276 - DorisSQLLexerNEGATIVE = 277 - DorisSQLLexerNGRAMBF = 278 - DorisSQLLexerNO = 279 - DorisSQLLexerNODE = 280 - DorisSQLLexerNODES = 281 - DorisSQLLexerNONE = 282 - DorisSQLLexerNOT = 283 - DorisSQLLexerNULL = 284 - DorisSQLLexerNULLS = 285 - DorisSQLLexerNUMBER = 286 - DorisSQLLexerNUMERIC = 287 - DorisSQLLexerOBSERVER = 288 - DorisSQLLexerOF = 289 - DorisSQLLexerOFF = 290 - DorisSQLLexerOFFSET = 291 - DorisSQLLexerON = 292 - DorisSQLLexerONLY = 293 - DorisSQLLexerOPEN = 294 - DorisSQLLexerOPERATE = 295 - DorisSQLLexerOPTIMIZE = 296 - DorisSQLLexerOPTIMIZER = 297 - DorisSQLLexerOPTION = 298 - DorisSQLLexerOR = 299 - DorisSQLLexerORDER = 300 - DorisSQLLexerOUTER = 301 - DorisSQLLexerOUTFILE = 302 - DorisSQLLexerOVER = 303 - DorisSQLLexerPARAMETER = 304 - DorisSQLLexerPARTITION = 305 - DorisSQLLexerPARTITIONS = 306 - DorisSQLLexerPASSWORD = 307 - DorisSQLLexerPATH = 308 - DorisSQLLexerPAUSE = 309 - DorisSQLLexerPENDING = 310 - DorisSQLLexerPERCENT_RANK = 311 - DorisSQLLexerPERCENTILE = 312 - DorisSQLLexerPERCENTILE_UNION = 313 - DorisSQLLexerPLAN = 314 - DorisSQLLexerPLUGIN = 315 - DorisSQLLexerPLUGINS = 316 - DorisSQLLexerPIPE = 317 - DorisSQLLexerPIPES = 318 - DorisSQLLexerPIVOT = 319 - DorisSQLLexerPOLICY = 320 - DorisSQLLexerPOLICIES = 321 - DorisSQLLexerPRECEDING = 322 - DorisSQLLexerPREDICATE = 323 - DorisSQLLexerPREPARE = 324 - DorisSQLLexerPRIMARY = 325 - DorisSQLLexerPRIORITY = 326 - DorisSQLLexerPRIVILEGES = 327 - DorisSQLLexerPROBABILITY = 328 - DorisSQLLexerPROC = 329 - DorisSQLLexerPROCEDURE = 330 - DorisSQLLexerPROCESSLIST = 331 - DorisSQLLexerPROFILE = 332 - DorisSQLLexerPROFILELIST = 333 - DorisSQLLexerPROPERTIES = 334 - DorisSQLLexerPROPERTY = 335 - DorisSQLLexerPROVIDER = 336 - DorisSQLLexerPROVIDERS = 337 - DorisSQLLexerQUALIFY = 338 - DorisSQLLexerQUARTER = 339 - DorisSQLLexerQUERY = 340 - DorisSQLLexerQUERIES = 341 - DorisSQLLexerQUEUE = 342 - DorisSQLLexerQUOTA = 343 - DorisSQLLexerRANDOM = 344 - DorisSQLLexerRANGE = 345 - DorisSQLLexerRANK = 346 - DorisSQLLexerREAD = 347 - DorisSQLLexerREASON = 348 - DorisSQLLexerRECOVER = 349 - DorisSQLLexerREFRESH = 350 - DorisSQLLexerREWRITE = 351 - DorisSQLLexerREGEXP = 352 - DorisSQLLexerRELEASE = 353 - DorisSQLLexerREMOVE = 354 - DorisSQLLexerRENAME = 355 - DorisSQLLexerREPAIR = 356 - DorisSQLLexerREPEATABLE = 357 - DorisSQLLexerREPLACE = 358 - DorisSQLLexerREPLACE_IF_NOT_NULL = 359 - DorisSQLLexerREPLICA = 360 - DorisSQLLexerREPOSITORY = 361 - DorisSQLLexerREPOSITORIES = 362 - DorisSQLLexerRESOURCE = 363 - DorisSQLLexerRESOURCES = 364 - DorisSQLLexerRESTORE = 365 - DorisSQLLexerRESUME = 366 - DorisSQLLexerRETAIN = 367 - DorisSQLLexerRETENTION = 368 - DorisSQLLexerRETURNS = 369 - DorisSQLLexerRETRY = 370 - DorisSQLLexerREVOKE = 371 - DorisSQLLexerREVERT = 372 - DorisSQLLexerRIGHT = 373 - DorisSQLLexerRLIKE = 374 - DorisSQLLexerROLE = 375 - DorisSQLLexerROLES = 376 - DorisSQLLexerROLLBACK = 377 - DorisSQLLexerROLLUP = 378 - DorisSQLLexerROUTINE = 379 - DorisSQLLexerROW = 380 - DorisSQLLexerROWS = 381 - DorisSQLLexerROW_NUMBER = 382 - DorisSQLLexerRULE = 383 - DorisSQLLexerRULES = 384 - DorisSQLLexerRUNNING = 385 - DorisSQLLexerSAMPLE = 386 - DorisSQLLexerSCHEDULE = 387 - DorisSQLLexerSCHEDULER = 388 - DorisSQLLexerSCHEMA = 389 - DorisSQLLexerSCHEMAS = 390 - DorisSQLLexerSECOND = 391 - DorisSQLLexerSECURITY = 392 - DorisSQLLexerSELECT = 393 - DorisSQLLexerSEMI = 394 - DorisSQLLexerSEPARATOR = 395 - DorisSQLLexerSERIALIZABLE = 396 - DorisSQLLexerSESSION = 397 - DorisSQLLexerSET = 398 - DorisSQLLexerSETS = 399 - DorisSQLLexerSET_VAR = 400 - DorisSQLLexerSIGNED = 401 - DorisSQLLexerSKIP_HEADER = 402 - DorisSQLLexerSHOW = 403 - DorisSQLLexerSMALLINT = 404 - DorisSQLLexerSNAPSHOT = 405 - DorisSQLLexerSNAPSHOTS = 406 - DorisSQLLexerSQLBLACKLIST = 407 - DorisSQLLexerSTART = 408 - DorisSQLLexerSTATS = 409 - DorisSQLLexerSTATUS = 410 - DorisSQLLexerSTOP = 411 - DorisSQLLexerSTORAGE = 412 - DorisSQLLexerSTREAM = 413 - DorisSQLLexerSTRING = 414 - DorisSQLLexerTEXT = 415 - DorisSQLLexerSUBMIT = 416 - DorisSQLLexerSUM = 417 - DorisSQLLexerSUSPEND = 418 - DorisSQLLexerSYNC = 419 - DorisSQLLexerSYSTEM = 420 - DorisSQLLexerSYSTEM_TIME = 421 - DorisSQLLexerSWAP = 422 - DorisSQLLexerSTRUCT = 423 - DorisSQLLexerTABLE = 424 - DorisSQLLexerTABLES = 425 - DorisSQLLexerTABLET = 426 - DorisSQLLexerTABLETS = 427 - DorisSQLLexerTAG = 428 - DorisSQLLexerTASK = 429 - DorisSQLLexerTEMPORARY = 430 - DorisSQLLexerTERMINATED = 431 - DorisSQLLexerTHAN = 432 - DorisSQLLexerTHEN = 433 - DorisSQLLexerTIME = 434 - DorisSQLLexerTIMES = 435 - DorisSQLLexerTIMESTAMP = 436 - DorisSQLLexerTIMESTAMPADD = 437 - DorisSQLLexerTIMESTAMPDIFF = 438 - DorisSQLLexerTINYINT = 439 - DorisSQLLexerTRANSACTION = 440 - DorisSQLLexerTRANSLATE = 441 - DorisSQLLexerTO = 442 - DorisSQLLexerTRACE = 443 - DorisSQLLexerTRIGGERS = 444 - DorisSQLLexerTRIM_SPACE = 445 - DorisSQLLexerTRUE = 446 - DorisSQLLexerTRUNCATE = 447 - DorisSQLLexerTYPE = 448 - DorisSQLLexerTYPES = 449 - DorisSQLLexerUNBOUNDED = 450 - DorisSQLLexerUNCOMMITTED = 451 - DorisSQLLexerUNION = 452 - DorisSQLLexerUNIQUE = 453 - DorisSQLLexerUNINSTALL = 454 - DorisSQLLexerUNSET = 455 - DorisSQLLexerUNSIGNED = 456 - DorisSQLLexerUPDATE = 457 - DorisSQLLexerUSAGE = 458 - DorisSQLLexerUSE = 459 - DorisSQLLexerUSER = 460 - DorisSQLLexerUSERS = 461 - DorisSQLLexerUSING = 462 - DorisSQLLexerVALUE = 463 - DorisSQLLexerVALUES = 464 - DorisSQLLexerVARBINARY = 465 - DorisSQLLexerVARCHAR = 466 - DorisSQLLexerVARIABLES = 467 - DorisSQLLexerVECTOR = 468 - DorisSQLLexerVERBOSE = 469 - DorisSQLLexerVERSION = 470 - DorisSQLLexerVIEW = 471 - DorisSQLLexerVIEWS = 472 - DorisSQLLexerVOLUME = 473 - DorisSQLLexerVOLUMES = 474 - DorisSQLLexerWAREHOUSE = 475 - DorisSQLLexerWAREHOUSES = 476 - DorisSQLLexerWARNINGS = 477 - DorisSQLLexerWEEK = 478 - DorisSQLLexerWHEN = 479 - DorisSQLLexerWHERE = 480 - DorisSQLLexerWHITELIST = 481 - DorisSQLLexerWITH = 482 - DorisSQLLexerWORK = 483 - DorisSQLLexerWRITE = 484 - DorisSQLLexerYEAR = 485 - DorisSQLLexerLOCK = 486 - DorisSQLLexerUNLOCK = 487 - DorisSQLLexerLOW_PRIORITY = 488 - DorisSQLLexerDISK = 489 - DorisSQLLexerDISKS = 490 - DorisSQLLexerBEFORE = 491 - DorisSQLLexerDOUBLE_DOLLAR = 492 - DorisSQLLexerFIELD = 493 - DorisSQLLexerPERSISTENT = 494 - DorisSQLLexerSKEW = 495 - DorisSQLLexerENCRYPT = 496 - DorisSQLLexerCACHED = 497 - DorisSQLLexerLIGHT = 498 - DorisSQLLexerRECYCLE = 499 - DorisSQLLexerBIN = 500 - DorisSQLLexerTRASH = 501 - DorisSQLLexerWORKLOAD = 502 - DorisSQLLexerSQL = 503 - DorisSQLLexerBLOCK = 504 - DorisSQLLexerTASKS = 505 - DorisSQLLexerCHANGE = 506 - DorisSQLLexerPROCESS = 507 - DorisSQLLexerMIGRATIONS = 508 - DorisSQLLexerEQ = 509 - DorisSQLLexerNEQ = 510 - DorisSQLLexerLT = 511 - DorisSQLLexerLTE = 512 - DorisSQLLexerGT = 513 - DorisSQLLexerGTE = 514 - DorisSQLLexerEQ_FOR_NULL = 515 - DorisSQLLexerARRAY_ELEMENT = 516 - DorisSQLLexerPLUS_SYMBOL = 517 - DorisSQLLexerMINUS_SYMBOL = 518 - DorisSQLLexerASTERISK_SYMBOL = 519 - DorisSQLLexerSLASH_SYMBOL = 520 - DorisSQLLexerPERCENT_SYMBOL = 521 - DorisSQLLexerLOGICAL_OR = 522 - DorisSQLLexerLOGICAL_AND = 523 - DorisSQLLexerLOGICAL_NOT = 524 - DorisSQLLexerINT_DIV = 525 - DorisSQLLexerBITAND = 526 - DorisSQLLexerBITOR = 527 - DorisSQLLexerBITXOR = 528 - DorisSQLLexerBITNOT = 529 - DorisSQLLexerBIT_SHIFT_LEFT = 530 - DorisSQLLexerBIT_SHIFT_RIGHT = 531 - DorisSQLLexerBIT_SHIFT_RIGHT_LOGICAL = 532 - DorisSQLLexerARROW = 533 - DorisSQLLexerAT = 534 - DorisSQLLexerINTEGER_VALUE = 535 - DorisSQLLexerDECIMAL_VALUE = 536 - DorisSQLLexerDOUBLE_VALUE = 537 - DorisSQLLexerSINGLE_QUOTED_TEXT = 538 - DorisSQLLexerDOUBLE_QUOTED_TEXT = 539 - DorisSQLLexerBINARY_SINGLE_QUOTED_TEXT = 540 - DorisSQLLexerBINARY_DOUBLE_QUOTED_TEXT = 541 - DorisSQLLexerLETTER_IDENTIFIER = 542 - DorisSQLLexerDIGIT_IDENTIFIER = 543 - DorisSQLLexerBACKQUOTED_IDENTIFIER = 544 - DorisSQLLexerDOT_IDENTIFIER = 545 - DorisSQLLexerSIMPLE_COMMENT = 546 - DorisSQLLexerBRACKETED_COMMENT = 547 - DorisSQLLexerOPTIMIZER_HINT = 548 - DorisSQLLexerSEMICOLON = 549 - DorisSQLLexerDOTDOTDOT = 550 - DorisSQLLexerWS = 551 - DorisSQLLexerATTACHMENT = 552 + StarRocksSQLLexerT__0 = 1 + StarRocksSQLLexerT__1 = 2 + StarRocksSQLLexerT__2 = 3 + StarRocksSQLLexerT__3 = 4 + StarRocksSQLLexerT__4 = 5 + StarRocksSQLLexerT__5 = 6 + StarRocksSQLLexerT__6 = 7 + StarRocksSQLLexerT__7 = 8 + StarRocksSQLLexerT__8 = 9 + StarRocksSQLLexerT__9 = 10 + StarRocksSQLLexerACCESS = 11 + StarRocksSQLLexerACTIVE = 12 + StarRocksSQLLexerADD = 13 + StarRocksSQLLexerADMIN = 14 + StarRocksSQLLexerADVISOR = 15 + StarRocksSQLLexerAFTER = 16 + StarRocksSQLLexerAGGREGATE = 17 + StarRocksSQLLexerALL = 18 + StarRocksSQLLexerALTER = 19 + StarRocksSQLLexerANALYZE = 20 + StarRocksSQLLexerAND = 21 + StarRocksSQLLexerANTI = 22 + StarRocksSQLLexerAPPLY = 23 + StarRocksSQLLexerARRAY = 24 + StarRocksSQLLexerARRAY_AGG = 25 + StarRocksSQLLexerARRAY_AGG_DISTINCT = 26 + StarRocksSQLLexerAS = 27 + StarRocksSQLLexerASC = 28 + StarRocksSQLLexerASYNC = 29 + StarRocksSQLLexerAUTHORS = 30 + StarRocksSQLLexerAUTHENTICATION = 31 + StarRocksSQLLexerAUTOMATED = 32 + StarRocksSQLLexerAUTO_INCREMENT = 33 + StarRocksSQLLexerAVG = 34 + StarRocksSQLLexerBACKEND = 35 + StarRocksSQLLexerBACKENDS = 36 + StarRocksSQLLexerBACKUP = 37 + StarRocksSQLLexerBASE = 38 + StarRocksSQLLexerBASELINE = 39 + StarRocksSQLLexerBEGIN = 40 + StarRocksSQLLexerBETWEEN = 41 + StarRocksSQLLexerBIGINT = 42 + StarRocksSQLLexerBINARY = 43 + StarRocksSQLLexerBITMAP = 44 + StarRocksSQLLexerBITMAP_UNION = 45 + StarRocksSQLLexerBLACKHOLE = 46 + StarRocksSQLLexerBLACKLIST = 47 + StarRocksSQLLexerBODY = 48 + StarRocksSQLLexerBOOLEAN = 49 + StarRocksSQLLexerBOTH = 50 + StarRocksSQLLexerBRANCH = 51 + StarRocksSQLLexerBROKER = 52 + StarRocksSQLLexerBUCKETS = 53 + StarRocksSQLLexerBUILTIN = 54 + StarRocksSQLLexerBY = 55 + StarRocksSQLLexerCACHE = 56 + StarRocksSQLLexerCANCEL = 57 + StarRocksSQLLexerCASE = 58 + StarRocksSQLLexerCAST = 59 + StarRocksSQLLexerCATALOG = 60 + StarRocksSQLLexerCATALOGS = 61 + StarRocksSQLLexerCEIL = 62 + StarRocksSQLLexerCHAIN = 63 + StarRocksSQLLexerCHAR = 64 + StarRocksSQLLexerCHARACTER = 65 + StarRocksSQLLexerCHARSET = 66 + StarRocksSQLLexerCHECK = 67 + StarRocksSQLLexerCLEAN = 68 + StarRocksSQLLexerCLEAR = 69 + StarRocksSQLLexerCLUSTER = 70 + StarRocksSQLLexerCLUSTERS = 71 + StarRocksSQLLexerCNGROUP = 72 + StarRocksSQLLexerCNGROUPS = 73 + StarRocksSQLLexerCOLLATE = 74 + StarRocksSQLLexerCOLLATION = 75 + StarRocksSQLLexerCOLUMN = 76 + StarRocksSQLLexerCOLUMNS = 77 + StarRocksSQLLexerCOMMENT = 78 + StarRocksSQLLexerCOMMIT = 79 + StarRocksSQLLexerCOMMITTED = 80 + StarRocksSQLLexerCOMPACT = 81 + StarRocksSQLLexerCOMPACTION = 82 + StarRocksSQLLexerCOMPUTE = 83 + StarRocksSQLLexerCONFIG = 84 + StarRocksSQLLexerCONNECTION = 85 + StarRocksSQLLexerCONSISTENT = 86 + StarRocksSQLLexerCONVERT = 87 + StarRocksSQLLexerCOSTS = 88 + StarRocksSQLLexerCOUNT = 89 + StarRocksSQLLexerCREATE = 90 + StarRocksSQLLexerCROSS = 91 + StarRocksSQLLexerCUBE = 92 + StarRocksSQLLexerCUME_DIST = 93 + StarRocksSQLLexerCUMULATIVE = 94 + StarRocksSQLLexerCURRENT = 95 + StarRocksSQLLexerCURRENT_DATE = 96 + StarRocksSQLLexerCURRENT_GROUP = 97 + StarRocksSQLLexerCURRENT_ROLE = 98 + StarRocksSQLLexerCURRENT_TIME = 99 + StarRocksSQLLexerCURRENT_TIMESTAMP = 100 + StarRocksSQLLexerCURRENT_USER = 101 + StarRocksSQLLexerDATA = 102 + StarRocksSQLLexerDATACACHE = 103 + StarRocksSQLLexerDATABASE = 104 + StarRocksSQLLexerDATABASES = 105 + StarRocksSQLLexerDATE = 106 + StarRocksSQLLexerDATETIME = 107 + StarRocksSQLLexerDAY = 108 + StarRocksSQLLexerDAYS = 109 + StarRocksSQLLexerDEALLOCATE = 110 + StarRocksSQLLexerDECIMAL = 111 + StarRocksSQLLexerDECIMALV2 = 112 + StarRocksSQLLexerDECIMAL32 = 113 + StarRocksSQLLexerDECIMAL64 = 114 + StarRocksSQLLexerDECIMAL128 = 115 + StarRocksSQLLexerDECOMMISSION = 116 + StarRocksSQLLexerDEFAULT = 117 + StarRocksSQLLexerDELETE = 118 + StarRocksSQLLexerDENSE_RANK = 119 + StarRocksSQLLexerDEFERRED = 120 + StarRocksSQLLexerDIALECT = 121 + StarRocksSQLLexerDICTIONARY = 122 + StarRocksSQLLexerDICTIONARY_GET = 123 + StarRocksSQLLexerNTILE = 124 + StarRocksSQLLexerDESC = 125 + StarRocksSQLLexerDESCRIBE = 126 + StarRocksSQLLexerDISABLE = 127 + StarRocksSQLLexerDISTINCT = 128 + StarRocksSQLLexerDISTRIBUTED = 129 + StarRocksSQLLexerDISTRIBUTION = 130 + StarRocksSQLLexerDOUBLE = 131 + StarRocksSQLLexerDROP = 132 + StarRocksSQLLexerDUAL = 133 + StarRocksSQLLexerDUPLICATE = 134 + StarRocksSQLLexerDYNAMIC = 135 + StarRocksSQLLexerELSE = 136 + StarRocksSQLLexerENABLE = 137 + StarRocksSQLLexerENCLOSE = 138 + StarRocksSQLLexerEND = 139 + StarRocksSQLLexerENGINE = 140 + StarRocksSQLLexerENGINES = 141 + StarRocksSQLLexerERRORS = 142 + StarRocksSQLLexerESCAPE = 143 + StarRocksSQLLexerEVENTS = 144 + StarRocksSQLLexerEXCEPT = 145 + StarRocksSQLLexerEXCLUDE = 146 + StarRocksSQLLexerEXECUTE = 147 + StarRocksSQLLexerEXISTS = 148 + StarRocksSQLLexerEXPLAIN = 149 + StarRocksSQLLexerEXPLODE = 150 + StarRocksSQLLexerEXPLODE_SPLIT = 151 + StarRocksSQLLexerEXPORT = 152 + StarRocksSQLLexerEXTERNAL = 153 + StarRocksSQLLexerEXTRACT = 154 + StarRocksSQLLexerEVERY = 155 + StarRocksSQLLexerFAILPOINT = 156 + StarRocksSQLLexerFAILPOINTS = 157 + StarRocksSQLLexerFALSE = 158 + StarRocksSQLLexerFIELDS = 159 + StarRocksSQLLexerFILE = 160 + StarRocksSQLLexerFILES = 161 + StarRocksSQLLexerFILTER = 162 + StarRocksSQLLexerFIRST = 163 + StarRocksSQLLexerFIRST_VALUE = 164 + StarRocksSQLLexerFLOAT = 165 + StarRocksSQLLexerFLOOR = 166 + StarRocksSQLLexerFN = 167 + StarRocksSQLLexerFOLLOWING = 168 + StarRocksSQLLexerFOLLOWER = 169 + StarRocksSQLLexerFOR = 170 + StarRocksSQLLexerFORCE = 171 + StarRocksSQLLexerFORMAT = 172 + StarRocksSQLLexerFREE = 173 + StarRocksSQLLexerFROM = 174 + StarRocksSQLLexerFRONTEND = 175 + StarRocksSQLLexerFRONTENDS = 176 + StarRocksSQLLexerFULL = 177 + StarRocksSQLLexerFUNCTION = 178 + StarRocksSQLLexerFUNCTIONS = 179 + StarRocksSQLLexerGLOBAL = 180 + StarRocksSQLLexerGRANT = 181 + StarRocksSQLLexerGRANTS = 182 + StarRocksSQLLexerGROUP = 183 + StarRocksSQLLexerGROUPS = 184 + StarRocksSQLLexerGROUPING = 185 + StarRocksSQLLexerGROUPING_ID = 186 + StarRocksSQLLexerGROUP_CONCAT = 187 + StarRocksSQLLexerHASH = 188 + StarRocksSQLLexerHAVING = 189 + StarRocksSQLLexerHELP = 190 + StarRocksSQLLexerHISTOGRAM = 191 + StarRocksSQLLexerHLL = 192 + StarRocksSQLLexerHLL_UNION = 193 + StarRocksSQLLexerHOST = 194 + StarRocksSQLLexerHOUR = 195 + StarRocksSQLLexerHOURS = 196 + StarRocksSQLLexerHUB = 197 + StarRocksSQLLexerIDENTIFIED = 198 + StarRocksSQLLexerIF = 199 + StarRocksSQLLexerIMPERSONATE = 200 + StarRocksSQLLexerIMMEDIATE = 201 + StarRocksSQLLexerIGNORE = 202 + StarRocksSQLLexerIMAGE = 203 + StarRocksSQLLexerIN = 204 + StarRocksSQLLexerINACTIVE = 205 + StarRocksSQLLexerINCREMENTAL = 206 + StarRocksSQLLexerINDEX = 207 + StarRocksSQLLexerINDEXES = 208 + StarRocksSQLLexerINFILE = 209 + StarRocksSQLLexerINNER = 210 + StarRocksSQLLexerINSTALL = 211 + StarRocksSQLLexerINSERT = 212 + StarRocksSQLLexerINT = 213 + StarRocksSQLLexerINTEGER = 214 + StarRocksSQLLexerINTEGRATION = 215 + StarRocksSQLLexerINTEGRATIONS = 216 + StarRocksSQLLexerINTERMEDIATE = 217 + StarRocksSQLLexerINTERSECT = 218 + StarRocksSQLLexerINTERVAL = 219 + StarRocksSQLLexerINTO = 220 + StarRocksSQLLexerINVOKER = 221 + StarRocksSQLLexerGIN = 222 + StarRocksSQLLexerOVERWRITE = 223 + StarRocksSQLLexerIS = 224 + StarRocksSQLLexerISOLATION = 225 + StarRocksSQLLexerJOB = 226 + StarRocksSQLLexerJOIN = 227 + StarRocksSQLLexerJSON = 228 + StarRocksSQLLexerKEY = 229 + StarRocksSQLLexerKEYS = 230 + StarRocksSQLLexerKILL = 231 + StarRocksSQLLexerLABEL = 232 + StarRocksSQLLexerLAG = 233 + StarRocksSQLLexerLARGEINT = 234 + StarRocksSQLLexerLAST = 235 + StarRocksSQLLexerLAST_VALUE = 236 + StarRocksSQLLexerLATERAL = 237 + StarRocksSQLLexerLEAD = 238 + StarRocksSQLLexerLEFT = 239 + StarRocksSQLLexerLESS = 240 + StarRocksSQLLexerLEVEL = 241 + StarRocksSQLLexerLIKE = 242 + StarRocksSQLLexerLIMIT = 243 + StarRocksSQLLexerLIST = 244 + StarRocksSQLLexerLOAD = 245 + StarRocksSQLLexerLOCAL = 246 + StarRocksSQLLexerLOCALTIME = 247 + StarRocksSQLLexerLOCALTIMESTAMP = 248 + StarRocksSQLLexerLOCATION = 249 + StarRocksSQLLexerLOCATIONS = 250 + StarRocksSQLLexerLOGS = 251 + StarRocksSQLLexerLOGICAL = 252 + StarRocksSQLLexerMANUAL = 253 + StarRocksSQLLexerMAP = 254 + StarRocksSQLLexerMAPPING = 255 + StarRocksSQLLexerMAPPINGS = 256 + StarRocksSQLLexerMASKING = 257 + StarRocksSQLLexerMATCH = 258 + StarRocksSQLLexerMATERIALIZED = 259 + StarRocksSQLLexerMAX = 260 + StarRocksSQLLexerMAXVALUE = 261 + StarRocksSQLLexerMERGE = 262 + StarRocksSQLLexerMICROSECOND = 263 + StarRocksSQLLexerMILLISECOND = 264 + StarRocksSQLLexerMIN = 265 + StarRocksSQLLexerMINUTE = 266 + StarRocksSQLLexerMINUTES = 267 + StarRocksSQLLexerMINUS = 268 + StarRocksSQLLexerMETA = 269 + StarRocksSQLLexerMOD = 270 + StarRocksSQLLexerMODE = 271 + StarRocksSQLLexerMODIFY = 272 + StarRocksSQLLexerMONTH = 273 + StarRocksSQLLexerMULTIPLE = 274 + StarRocksSQLLexerNAME = 275 + StarRocksSQLLexerNAMES = 276 + StarRocksSQLLexerNEGATIVE = 277 + StarRocksSQLLexerNGRAMBF = 278 + StarRocksSQLLexerNO = 279 + StarRocksSQLLexerNODE = 280 + StarRocksSQLLexerNODES = 281 + StarRocksSQLLexerNONE = 282 + StarRocksSQLLexerNOT = 283 + StarRocksSQLLexerNULL = 284 + StarRocksSQLLexerNULLS = 285 + StarRocksSQLLexerNUMBER = 286 + StarRocksSQLLexerNUMERIC = 287 + StarRocksSQLLexerOBSERVER = 288 + StarRocksSQLLexerOF = 289 + StarRocksSQLLexerOFF = 290 + StarRocksSQLLexerOFFSET = 291 + StarRocksSQLLexerON = 292 + StarRocksSQLLexerONLY = 293 + StarRocksSQLLexerOPEN = 294 + StarRocksSQLLexerOPERATE = 295 + StarRocksSQLLexerOPTIMIZE = 296 + StarRocksSQLLexerOPTIMIZER = 297 + StarRocksSQLLexerOPTION = 298 + StarRocksSQLLexerOR = 299 + StarRocksSQLLexerORDER = 300 + StarRocksSQLLexerOUTER = 301 + StarRocksSQLLexerOUTFILE = 302 + StarRocksSQLLexerOVER = 303 + StarRocksSQLLexerPARAMETER = 304 + StarRocksSQLLexerPARTITION = 305 + StarRocksSQLLexerPARTITIONS = 306 + StarRocksSQLLexerPASSWORD = 307 + StarRocksSQLLexerPATH = 308 + StarRocksSQLLexerPAUSE = 309 + StarRocksSQLLexerPENDING = 310 + StarRocksSQLLexerPERCENT_RANK = 311 + StarRocksSQLLexerPERCENTILE = 312 + StarRocksSQLLexerPERCENTILE_UNION = 313 + StarRocksSQLLexerPLAN = 314 + StarRocksSQLLexerPLUGIN = 315 + StarRocksSQLLexerPLUGINS = 316 + StarRocksSQLLexerPIPE = 317 + StarRocksSQLLexerPIPES = 318 + StarRocksSQLLexerPIVOT = 319 + StarRocksSQLLexerPOLICY = 320 + StarRocksSQLLexerPOLICIES = 321 + StarRocksSQLLexerPRECEDING = 322 + StarRocksSQLLexerPREDICATE = 323 + StarRocksSQLLexerPREPARE = 324 + StarRocksSQLLexerPRIMARY = 325 + StarRocksSQLLexerPRIORITY = 326 + StarRocksSQLLexerPRIVILEGES = 327 + StarRocksSQLLexerPROBABILITY = 328 + StarRocksSQLLexerPROC = 329 + StarRocksSQLLexerPROCEDURE = 330 + StarRocksSQLLexerPROCESSLIST = 331 + StarRocksSQLLexerPROFILE = 332 + StarRocksSQLLexerPROFILELIST = 333 + StarRocksSQLLexerPROPERTIES = 334 + StarRocksSQLLexerPROPERTY = 335 + StarRocksSQLLexerPROVIDER = 336 + StarRocksSQLLexerPROVIDERS = 337 + StarRocksSQLLexerQUALIFY = 338 + StarRocksSQLLexerQUARTER = 339 + StarRocksSQLLexerQUERY = 340 + StarRocksSQLLexerQUERIES = 341 + StarRocksSQLLexerQUEUE = 342 + StarRocksSQLLexerQUOTA = 343 + StarRocksSQLLexerRANDOM = 344 + StarRocksSQLLexerRANGE = 345 + StarRocksSQLLexerRANK = 346 + StarRocksSQLLexerREAD = 347 + StarRocksSQLLexerREASON = 348 + StarRocksSQLLexerRECOVER = 349 + StarRocksSQLLexerREFRESH = 350 + StarRocksSQLLexerREWRITE = 351 + StarRocksSQLLexerREGEXP = 352 + StarRocksSQLLexerRELEASE = 353 + StarRocksSQLLexerREMOVE = 354 + StarRocksSQLLexerRENAME = 355 + StarRocksSQLLexerREPAIR = 356 + StarRocksSQLLexerREPEATABLE = 357 + StarRocksSQLLexerREPLACE = 358 + StarRocksSQLLexerREPLACE_IF_NOT_NULL = 359 + StarRocksSQLLexerREPLICA = 360 + StarRocksSQLLexerREPOSITORY = 361 + StarRocksSQLLexerREPOSITORIES = 362 + StarRocksSQLLexerRESOURCE = 363 + StarRocksSQLLexerRESOURCES = 364 + StarRocksSQLLexerRESTORE = 365 + StarRocksSQLLexerRESUME = 366 + StarRocksSQLLexerRETAIN = 367 + StarRocksSQLLexerRETENTION = 368 + StarRocksSQLLexerRETURNS = 369 + StarRocksSQLLexerRETRY = 370 + StarRocksSQLLexerREVOKE = 371 + StarRocksSQLLexerREVERT = 372 + StarRocksSQLLexerRIGHT = 373 + StarRocksSQLLexerRLIKE = 374 + StarRocksSQLLexerROLE = 375 + StarRocksSQLLexerROLES = 376 + StarRocksSQLLexerROLLBACK = 377 + StarRocksSQLLexerROLLUP = 378 + StarRocksSQLLexerROUTINE = 379 + StarRocksSQLLexerROW = 380 + StarRocksSQLLexerROWS = 381 + StarRocksSQLLexerROW_NUMBER = 382 + StarRocksSQLLexerRULE = 383 + StarRocksSQLLexerRULES = 384 + StarRocksSQLLexerRUNNING = 385 + StarRocksSQLLexerSAMPLE = 386 + StarRocksSQLLexerSCHEDULE = 387 + StarRocksSQLLexerSCHEDULER = 388 + StarRocksSQLLexerSCHEMA = 389 + StarRocksSQLLexerSCHEMAS = 390 + StarRocksSQLLexerSECOND = 391 + StarRocksSQLLexerSECURITY = 392 + StarRocksSQLLexerSELECT = 393 + StarRocksSQLLexerSEMI = 394 + StarRocksSQLLexerSEPARATOR = 395 + StarRocksSQLLexerSERIALIZABLE = 396 + StarRocksSQLLexerSESSION = 397 + StarRocksSQLLexerSET = 398 + StarRocksSQLLexerSETS = 399 + StarRocksSQLLexerSET_VAR = 400 + StarRocksSQLLexerSIGNED = 401 + StarRocksSQLLexerSKIP_HEADER = 402 + StarRocksSQLLexerSHOW = 403 + StarRocksSQLLexerSMALLINT = 404 + StarRocksSQLLexerSNAPSHOT = 405 + StarRocksSQLLexerSNAPSHOTS = 406 + StarRocksSQLLexerSQLBLACKLIST = 407 + StarRocksSQLLexerSTART = 408 + StarRocksSQLLexerSTATS = 409 + StarRocksSQLLexerSTATUS = 410 + StarRocksSQLLexerSTOP = 411 + StarRocksSQLLexerSTORAGE = 412 + StarRocksSQLLexerSTREAM = 413 + StarRocksSQLLexerSTRING = 414 + StarRocksSQLLexerTEXT = 415 + StarRocksSQLLexerSUBMIT = 416 + StarRocksSQLLexerSUM = 417 + StarRocksSQLLexerSUSPEND = 418 + StarRocksSQLLexerSYNC = 419 + StarRocksSQLLexerSYSTEM = 420 + StarRocksSQLLexerSYSTEM_TIME = 421 + StarRocksSQLLexerSWAP = 422 + StarRocksSQLLexerSTRUCT = 423 + StarRocksSQLLexerTABLE = 424 + StarRocksSQLLexerTABLES = 425 + StarRocksSQLLexerTABLET = 426 + StarRocksSQLLexerTABLETS = 427 + StarRocksSQLLexerTAG = 428 + StarRocksSQLLexerTASK = 429 + StarRocksSQLLexerTEMPORARY = 430 + StarRocksSQLLexerTERMINATED = 431 + StarRocksSQLLexerTHAN = 432 + StarRocksSQLLexerTHEN = 433 + StarRocksSQLLexerTIME = 434 + StarRocksSQLLexerTIMES = 435 + StarRocksSQLLexerTIMESTAMP = 436 + StarRocksSQLLexerTIMESTAMPADD = 437 + StarRocksSQLLexerTIMESTAMPDIFF = 438 + StarRocksSQLLexerTINYINT = 439 + StarRocksSQLLexerTRANSACTION = 440 + StarRocksSQLLexerTRANSLATE = 441 + StarRocksSQLLexerTO = 442 + StarRocksSQLLexerTRACE = 443 + StarRocksSQLLexerTRIGGERS = 444 + StarRocksSQLLexerTRIM_SPACE = 445 + StarRocksSQLLexerTRUE = 446 + StarRocksSQLLexerTRUNCATE = 447 + StarRocksSQLLexerTYPE = 448 + StarRocksSQLLexerTYPES = 449 + StarRocksSQLLexerUNBOUNDED = 450 + StarRocksSQLLexerUNCOMMITTED = 451 + StarRocksSQLLexerUNION = 452 + StarRocksSQLLexerUNIQUE = 453 + StarRocksSQLLexerUNINSTALL = 454 + StarRocksSQLLexerUNSET = 455 + StarRocksSQLLexerUNSIGNED = 456 + StarRocksSQLLexerUPDATE = 457 + StarRocksSQLLexerUSAGE = 458 + StarRocksSQLLexerUSE = 459 + StarRocksSQLLexerUSER = 460 + StarRocksSQLLexerUSERS = 461 + StarRocksSQLLexerUSING = 462 + StarRocksSQLLexerVALUE = 463 + StarRocksSQLLexerVALUES = 464 + StarRocksSQLLexerVARBINARY = 465 + StarRocksSQLLexerVARCHAR = 466 + StarRocksSQLLexerVARIABLES = 467 + StarRocksSQLLexerVECTOR = 468 + StarRocksSQLLexerVERBOSE = 469 + StarRocksSQLLexerVERSION = 470 + StarRocksSQLLexerVIEW = 471 + StarRocksSQLLexerVIEWS = 472 + StarRocksSQLLexerVOLUME = 473 + StarRocksSQLLexerVOLUMES = 474 + StarRocksSQLLexerWAREHOUSE = 475 + StarRocksSQLLexerWAREHOUSES = 476 + StarRocksSQLLexerWARNINGS = 477 + StarRocksSQLLexerWEEK = 478 + StarRocksSQLLexerWHEN = 479 + StarRocksSQLLexerWHERE = 480 + StarRocksSQLLexerWHITELIST = 481 + StarRocksSQLLexerWITH = 482 + StarRocksSQLLexerWORK = 483 + StarRocksSQLLexerWRITE = 484 + StarRocksSQLLexerYEAR = 485 + StarRocksSQLLexerLOCK = 486 + StarRocksSQLLexerUNLOCK = 487 + StarRocksSQLLexerLOW_PRIORITY = 488 + StarRocksSQLLexerDISK = 489 + StarRocksSQLLexerDISKS = 490 + StarRocksSQLLexerBEFORE = 491 + StarRocksSQLLexerDOUBLE_DOLLAR = 492 + StarRocksSQLLexerFIELD = 493 + StarRocksSQLLexerPERSISTENT = 494 + StarRocksSQLLexerSKEW = 495 + StarRocksSQLLexerENCRYPT = 496 + StarRocksSQLLexerCACHED = 497 + StarRocksSQLLexerLIGHT = 498 + StarRocksSQLLexerRECYCLE = 499 + StarRocksSQLLexerBIN = 500 + StarRocksSQLLexerTRASH = 501 + StarRocksSQLLexerWORKLOAD = 502 + StarRocksSQLLexerSQL = 503 + StarRocksSQLLexerBLOCK = 504 + StarRocksSQLLexerTASKS = 505 + StarRocksSQLLexerCHANGE = 506 + StarRocksSQLLexerPROCESS = 507 + StarRocksSQLLexerMIGRATIONS = 508 + StarRocksSQLLexerEQ = 509 + StarRocksSQLLexerNEQ = 510 + StarRocksSQLLexerLT = 511 + StarRocksSQLLexerLTE = 512 + StarRocksSQLLexerGT = 513 + StarRocksSQLLexerGTE = 514 + StarRocksSQLLexerEQ_FOR_NULL = 515 + StarRocksSQLLexerARRAY_ELEMENT = 516 + StarRocksSQLLexerPLUS_SYMBOL = 517 + StarRocksSQLLexerMINUS_SYMBOL = 518 + StarRocksSQLLexerASTERISK_SYMBOL = 519 + StarRocksSQLLexerSLASH_SYMBOL = 520 + StarRocksSQLLexerPERCENT_SYMBOL = 521 + StarRocksSQLLexerLOGICAL_OR = 522 + StarRocksSQLLexerLOGICAL_AND = 523 + StarRocksSQLLexerLOGICAL_NOT = 524 + StarRocksSQLLexerINT_DIV = 525 + StarRocksSQLLexerBITAND = 526 + StarRocksSQLLexerBITOR = 527 + StarRocksSQLLexerBITXOR = 528 + StarRocksSQLLexerBITNOT = 529 + StarRocksSQLLexerBIT_SHIFT_LEFT = 530 + StarRocksSQLLexerBIT_SHIFT_RIGHT = 531 + StarRocksSQLLexerBIT_SHIFT_RIGHT_LOGICAL = 532 + StarRocksSQLLexerARROW = 533 + StarRocksSQLLexerAT = 534 + StarRocksSQLLexerINTEGER_VALUE = 535 + StarRocksSQLLexerDECIMAL_VALUE = 536 + StarRocksSQLLexerDOUBLE_VALUE = 537 + StarRocksSQLLexerSINGLE_QUOTED_TEXT = 538 + StarRocksSQLLexerDOUBLE_QUOTED_TEXT = 539 + StarRocksSQLLexerBINARY_SINGLE_QUOTED_TEXT = 540 + StarRocksSQLLexerBINARY_DOUBLE_QUOTED_TEXT = 541 + StarRocksSQLLexerLETTER_IDENTIFIER = 542 + StarRocksSQLLexerDIGIT_IDENTIFIER = 543 + StarRocksSQLLexerBACKQUOTED_IDENTIFIER = 544 + StarRocksSQLLexerDOT_IDENTIFIER = 545 + StarRocksSQLLexerSIMPLE_COMMENT = 546 + StarRocksSQLLexerBRACKETED_COMMENT = 547 + StarRocksSQLLexerOPTIMIZER_HINT = 548 + StarRocksSQLLexerSEMICOLON = 549 + StarRocksSQLLexerDOTDOTDOT = 550 + StarRocksSQLLexerWS = 551 + StarRocksSQLLexerATTACHMENT = 552 ) diff --git a/doris/dorissql_listener.go b/starrocks/starrockssql_listener.go similarity index 99% rename from doris/dorissql_listener.go rename to starrocks/starrockssql_listener.go index c0bb38f..8e99675 100644 --- a/doris/dorissql_listener.go +++ b/starrocks/starrockssql_listener.go @@ -1,10 +1,10 @@ -// Code generated from DorisSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from StarRocksSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. -package doris // DorisSQL +package starrocks // StarRocksSQL import "github.com/antlr4-go/antlr/v4" -// DorisSQLListener is a complete listener for a parse tree produced by DorisSQLParser. -type DorisSQLListener interface { +// StarRocksSQLListener is a complete listener for a parse tree produced by StarRocksSQLParser. +type StarRocksSQLListener interface { antlr.ParseTreeListener // EnterSqlStatements is called when entering the sqlStatements production. diff --git a/doris/dorissql_parser.go b/starrocks/starrockssql_parser.go similarity index 80% rename from doris/dorissql_parser.go rename to starrocks/starrockssql_parser.go index e846e6f..c269700 100644 --- a/doris/dorissql_parser.go +++ b/starrocks/starrockssql_parser.go @@ -1,6 +1,6 @@ -// Code generated from DorisSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from StarRocksSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. -package doris // DorisSQL +package starrocks // StarRocksSQL import ( "fmt" "strconv" @@ -14,11 +14,11 @@ var _ = fmt.Printf var _ = strconv.Itoa var _ = sync.Once{} -type DorisSQLParser struct { +type StarRocksSQLParser struct { *antlr.BaseParser } -var DorisSQLParserStaticData struct { +var StarRocksSQLParserStaticData struct { once sync.Once serializedATN []int32 LiteralNames []string @@ -29,8 +29,8 @@ var DorisSQLParserStaticData struct { decisionToDFA []*antlr.DFA } -func dorissqlParserInit() { - staticData := &DorisSQLParserStaticData +func starrockssqlParserInit() { + staticData := &StarRocksSQLParserStaticData staticData.LiteralNames = []string{ "", "'.'", "'('", "','", "')'", "'=>'", "'['", "']'", "':'", "'{'", "'}'", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", @@ -4833,1138 +4833,1138 @@ func dorissqlParserInit() { } } -// DorisSQLParserInit initializes any static state used to implement DorisSQLParser. By default the +// StarRocksSQLParserInit initializes any static state used to implement StarRocksSQLParser. By default the // static state used to implement the parser is lazily initialized during the first call to -// NewDorisSQLParser(). You can call this function if you wish to initialize the static state ahead +// NewStarRocksSQLParser(). You can call this function if you wish to initialize the static state ahead // of time. -func DorisSQLParserInit() { - staticData := &DorisSQLParserStaticData - staticData.once.Do(dorissqlParserInit) +func StarRocksSQLParserInit() { + staticData := &StarRocksSQLParserStaticData + staticData.once.Do(starrockssqlParserInit) } -// NewDorisSQLParser produces a new parser instance for the optional input antlr.TokenStream. -func NewDorisSQLParser(input antlr.TokenStream) *DorisSQLParser { - DorisSQLParserInit() - this := new(DorisSQLParser) +// NewStarRocksSQLParser produces a new parser instance for the optional input antlr.TokenStream. +func NewStarRocksSQLParser(input antlr.TokenStream) *StarRocksSQLParser { + StarRocksSQLParserInit() + this := new(StarRocksSQLParser) this.BaseParser = antlr.NewBaseParser(input) - staticData := &DorisSQLParserStaticData + staticData := &StarRocksSQLParserStaticData this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) this.RuleNames = staticData.RuleNames this.LiteralNames = staticData.LiteralNames this.SymbolicNames = staticData.SymbolicNames - this.GrammarFileName = "DorisSQL.g4" + this.GrammarFileName = "StarRocksSQL.g4" return this } -// DorisSQLParser tokens. +// StarRocksSQLParser tokens. const ( - DorisSQLParserEOF = antlr.TokenEOF - DorisSQLParserT__0 = 1 - DorisSQLParserT__1 = 2 - DorisSQLParserT__2 = 3 - DorisSQLParserT__3 = 4 - DorisSQLParserT__4 = 5 - DorisSQLParserT__5 = 6 - DorisSQLParserT__6 = 7 - DorisSQLParserT__7 = 8 - DorisSQLParserT__8 = 9 - DorisSQLParserT__9 = 10 - DorisSQLParserACCESS = 11 - DorisSQLParserACTIVE = 12 - DorisSQLParserADD = 13 - DorisSQLParserADMIN = 14 - DorisSQLParserADVISOR = 15 - DorisSQLParserAFTER = 16 - DorisSQLParserAGGREGATE = 17 - DorisSQLParserALL = 18 - DorisSQLParserALTER = 19 - DorisSQLParserANALYZE = 20 - DorisSQLParserAND = 21 - DorisSQLParserANTI = 22 - DorisSQLParserAPPLY = 23 - DorisSQLParserARRAY = 24 - DorisSQLParserARRAY_AGG = 25 - DorisSQLParserARRAY_AGG_DISTINCT = 26 - DorisSQLParserAS = 27 - DorisSQLParserASC = 28 - DorisSQLParserASYNC = 29 - DorisSQLParserAUTHORS = 30 - DorisSQLParserAUTHENTICATION = 31 - DorisSQLParserAUTOMATED = 32 - DorisSQLParserAUTO_INCREMENT = 33 - DorisSQLParserAVG = 34 - DorisSQLParserBACKEND = 35 - DorisSQLParserBACKENDS = 36 - DorisSQLParserBACKUP = 37 - DorisSQLParserBASE = 38 - DorisSQLParserBASELINE = 39 - DorisSQLParserBEGIN = 40 - DorisSQLParserBETWEEN = 41 - DorisSQLParserBIGINT = 42 - DorisSQLParserBINARY = 43 - DorisSQLParserBITMAP = 44 - DorisSQLParserBITMAP_UNION = 45 - DorisSQLParserBLACKHOLE = 46 - DorisSQLParserBLACKLIST = 47 - DorisSQLParserBODY = 48 - DorisSQLParserBOOLEAN = 49 - DorisSQLParserBOTH = 50 - DorisSQLParserBRANCH = 51 - DorisSQLParserBROKER = 52 - DorisSQLParserBUCKETS = 53 - DorisSQLParserBUILTIN = 54 - DorisSQLParserBY = 55 - DorisSQLParserCACHE = 56 - DorisSQLParserCANCEL = 57 - DorisSQLParserCASE = 58 - DorisSQLParserCAST = 59 - DorisSQLParserCATALOG = 60 - DorisSQLParserCATALOGS = 61 - DorisSQLParserCEIL = 62 - DorisSQLParserCHAIN = 63 - DorisSQLParserCHAR = 64 - DorisSQLParserCHARACTER = 65 - DorisSQLParserCHARSET = 66 - DorisSQLParserCHECK = 67 - DorisSQLParserCLEAN = 68 - DorisSQLParserCLEAR = 69 - DorisSQLParserCLUSTER = 70 - DorisSQLParserCLUSTERS = 71 - DorisSQLParserCNGROUP = 72 - DorisSQLParserCNGROUPS = 73 - DorisSQLParserCOLLATE = 74 - DorisSQLParserCOLLATION = 75 - DorisSQLParserCOLUMN = 76 - DorisSQLParserCOLUMNS = 77 - DorisSQLParserCOMMENT = 78 - DorisSQLParserCOMMIT = 79 - DorisSQLParserCOMMITTED = 80 - DorisSQLParserCOMPACT = 81 - DorisSQLParserCOMPACTION = 82 - DorisSQLParserCOMPUTE = 83 - DorisSQLParserCONFIG = 84 - DorisSQLParserCONNECTION = 85 - DorisSQLParserCONSISTENT = 86 - DorisSQLParserCONVERT = 87 - DorisSQLParserCOSTS = 88 - DorisSQLParserCOUNT = 89 - DorisSQLParserCREATE = 90 - DorisSQLParserCROSS = 91 - DorisSQLParserCUBE = 92 - DorisSQLParserCUME_DIST = 93 - DorisSQLParserCUMULATIVE = 94 - DorisSQLParserCURRENT = 95 - DorisSQLParserCURRENT_DATE = 96 - DorisSQLParserCURRENT_GROUP = 97 - DorisSQLParserCURRENT_ROLE = 98 - DorisSQLParserCURRENT_TIME = 99 - DorisSQLParserCURRENT_TIMESTAMP = 100 - DorisSQLParserCURRENT_USER = 101 - DorisSQLParserDATA = 102 - DorisSQLParserDATACACHE = 103 - DorisSQLParserDATABASE = 104 - DorisSQLParserDATABASES = 105 - DorisSQLParserDATE = 106 - DorisSQLParserDATETIME = 107 - DorisSQLParserDAY = 108 - DorisSQLParserDAYS = 109 - DorisSQLParserDEALLOCATE = 110 - DorisSQLParserDECIMAL = 111 - DorisSQLParserDECIMALV2 = 112 - DorisSQLParserDECIMAL32 = 113 - DorisSQLParserDECIMAL64 = 114 - DorisSQLParserDECIMAL128 = 115 - DorisSQLParserDECOMMISSION = 116 - DorisSQLParserDEFAULT = 117 - DorisSQLParserDELETE = 118 - DorisSQLParserDENSE_RANK = 119 - DorisSQLParserDEFERRED = 120 - DorisSQLParserDIALECT = 121 - DorisSQLParserDICTIONARY = 122 - DorisSQLParserDICTIONARY_GET = 123 - DorisSQLParserNTILE = 124 - DorisSQLParserDESC = 125 - DorisSQLParserDESCRIBE = 126 - DorisSQLParserDISABLE = 127 - DorisSQLParserDISTINCT = 128 - DorisSQLParserDISTRIBUTED = 129 - DorisSQLParserDISTRIBUTION = 130 - DorisSQLParserDOUBLE = 131 - DorisSQLParserDROP = 132 - DorisSQLParserDUAL = 133 - DorisSQLParserDUPLICATE = 134 - DorisSQLParserDYNAMIC = 135 - DorisSQLParserELSE = 136 - DorisSQLParserENABLE = 137 - DorisSQLParserENCLOSE = 138 - DorisSQLParserEND = 139 - DorisSQLParserENGINE = 140 - DorisSQLParserENGINES = 141 - DorisSQLParserERRORS = 142 - DorisSQLParserESCAPE = 143 - DorisSQLParserEVENTS = 144 - DorisSQLParserEXCEPT = 145 - DorisSQLParserEXCLUDE = 146 - DorisSQLParserEXECUTE = 147 - DorisSQLParserEXISTS = 148 - DorisSQLParserEXPLAIN = 149 - DorisSQLParserEXPLODE = 150 - DorisSQLParserEXPLODE_SPLIT = 151 - DorisSQLParserEXPORT = 152 - DorisSQLParserEXTERNAL = 153 - DorisSQLParserEXTRACT = 154 - DorisSQLParserEVERY = 155 - DorisSQLParserFAILPOINT = 156 - DorisSQLParserFAILPOINTS = 157 - DorisSQLParserFALSE = 158 - DorisSQLParserFIELDS = 159 - DorisSQLParserFILE = 160 - DorisSQLParserFILES = 161 - DorisSQLParserFILTER = 162 - DorisSQLParserFIRST = 163 - DorisSQLParserFIRST_VALUE = 164 - DorisSQLParserFLOAT = 165 - DorisSQLParserFLOOR = 166 - DorisSQLParserFN = 167 - DorisSQLParserFOLLOWING = 168 - DorisSQLParserFOLLOWER = 169 - DorisSQLParserFOR = 170 - DorisSQLParserFORCE = 171 - DorisSQLParserFORMAT = 172 - DorisSQLParserFREE = 173 - DorisSQLParserFROM = 174 - DorisSQLParserFRONTEND = 175 - DorisSQLParserFRONTENDS = 176 - DorisSQLParserFULL = 177 - DorisSQLParserFUNCTION = 178 - DorisSQLParserFUNCTIONS = 179 - DorisSQLParserGLOBAL = 180 - DorisSQLParserGRANT = 181 - DorisSQLParserGRANTS = 182 - DorisSQLParserGROUP = 183 - DorisSQLParserGROUPS = 184 - DorisSQLParserGROUPING = 185 - DorisSQLParserGROUPING_ID = 186 - DorisSQLParserGROUP_CONCAT = 187 - DorisSQLParserHASH = 188 - DorisSQLParserHAVING = 189 - DorisSQLParserHELP = 190 - DorisSQLParserHISTOGRAM = 191 - DorisSQLParserHLL = 192 - DorisSQLParserHLL_UNION = 193 - DorisSQLParserHOST = 194 - DorisSQLParserHOUR = 195 - DorisSQLParserHOURS = 196 - DorisSQLParserHUB = 197 - DorisSQLParserIDENTIFIED = 198 - DorisSQLParserIF = 199 - DorisSQLParserIMPERSONATE = 200 - DorisSQLParserIMMEDIATE = 201 - DorisSQLParserIGNORE = 202 - DorisSQLParserIMAGE = 203 - DorisSQLParserIN = 204 - DorisSQLParserINACTIVE = 205 - DorisSQLParserINCREMENTAL = 206 - DorisSQLParserINDEX = 207 - DorisSQLParserINDEXES = 208 - DorisSQLParserINFILE = 209 - DorisSQLParserINNER = 210 - DorisSQLParserINSTALL = 211 - DorisSQLParserINSERT = 212 - DorisSQLParserINT = 213 - DorisSQLParserINTEGER = 214 - DorisSQLParserINTEGRATION = 215 - DorisSQLParserINTEGRATIONS = 216 - DorisSQLParserINTERMEDIATE = 217 - DorisSQLParserINTERSECT = 218 - DorisSQLParserINTERVAL = 219 - DorisSQLParserINTO = 220 - DorisSQLParserINVOKER = 221 - DorisSQLParserGIN = 222 - DorisSQLParserOVERWRITE = 223 - DorisSQLParserIS = 224 - DorisSQLParserISOLATION = 225 - DorisSQLParserJOB = 226 - DorisSQLParserJOIN = 227 - DorisSQLParserJSON = 228 - DorisSQLParserKEY = 229 - DorisSQLParserKEYS = 230 - DorisSQLParserKILL = 231 - DorisSQLParserLABEL = 232 - DorisSQLParserLAG = 233 - DorisSQLParserLARGEINT = 234 - DorisSQLParserLAST = 235 - DorisSQLParserLAST_VALUE = 236 - DorisSQLParserLATERAL = 237 - DorisSQLParserLEAD = 238 - DorisSQLParserLEFT = 239 - DorisSQLParserLESS = 240 - DorisSQLParserLEVEL = 241 - DorisSQLParserLIKE = 242 - DorisSQLParserLIMIT = 243 - DorisSQLParserLIST = 244 - DorisSQLParserLOAD = 245 - DorisSQLParserLOCAL = 246 - DorisSQLParserLOCALTIME = 247 - DorisSQLParserLOCALTIMESTAMP = 248 - DorisSQLParserLOCATION = 249 - DorisSQLParserLOCATIONS = 250 - DorisSQLParserLOGS = 251 - DorisSQLParserLOGICAL = 252 - DorisSQLParserMANUAL = 253 - DorisSQLParserMAP = 254 - DorisSQLParserMAPPING = 255 - DorisSQLParserMAPPINGS = 256 - DorisSQLParserMASKING = 257 - DorisSQLParserMATCH = 258 - DorisSQLParserMATERIALIZED = 259 - DorisSQLParserMAX = 260 - DorisSQLParserMAXVALUE = 261 - DorisSQLParserMERGE = 262 - DorisSQLParserMICROSECOND = 263 - DorisSQLParserMILLISECOND = 264 - DorisSQLParserMIN = 265 - DorisSQLParserMINUTE = 266 - DorisSQLParserMINUTES = 267 - DorisSQLParserMINUS = 268 - DorisSQLParserMETA = 269 - DorisSQLParserMOD = 270 - DorisSQLParserMODE = 271 - DorisSQLParserMODIFY = 272 - DorisSQLParserMONTH = 273 - DorisSQLParserMULTIPLE = 274 - DorisSQLParserNAME = 275 - DorisSQLParserNAMES = 276 - DorisSQLParserNEGATIVE = 277 - DorisSQLParserNGRAMBF = 278 - DorisSQLParserNO = 279 - DorisSQLParserNODE = 280 - DorisSQLParserNODES = 281 - DorisSQLParserNONE = 282 - DorisSQLParserNOT = 283 - DorisSQLParserNULL = 284 - DorisSQLParserNULLS = 285 - DorisSQLParserNUMBER = 286 - DorisSQLParserNUMERIC = 287 - DorisSQLParserOBSERVER = 288 - DorisSQLParserOF = 289 - DorisSQLParserOFF = 290 - DorisSQLParserOFFSET = 291 - DorisSQLParserON = 292 - DorisSQLParserONLY = 293 - DorisSQLParserOPEN = 294 - DorisSQLParserOPERATE = 295 - DorisSQLParserOPTIMIZE = 296 - DorisSQLParserOPTIMIZER = 297 - DorisSQLParserOPTION = 298 - DorisSQLParserOR = 299 - DorisSQLParserORDER = 300 - DorisSQLParserOUTER = 301 - DorisSQLParserOUTFILE = 302 - DorisSQLParserOVER = 303 - DorisSQLParserPARAMETER = 304 - DorisSQLParserPARTITION = 305 - DorisSQLParserPARTITIONS = 306 - DorisSQLParserPASSWORD = 307 - DorisSQLParserPATH = 308 - DorisSQLParserPAUSE = 309 - DorisSQLParserPENDING = 310 - DorisSQLParserPERCENT_RANK = 311 - DorisSQLParserPERCENTILE = 312 - DorisSQLParserPERCENTILE_UNION = 313 - DorisSQLParserPLAN = 314 - DorisSQLParserPLUGIN = 315 - DorisSQLParserPLUGINS = 316 - DorisSQLParserPIPE = 317 - DorisSQLParserPIPES = 318 - DorisSQLParserPIVOT = 319 - DorisSQLParserPOLICY = 320 - DorisSQLParserPOLICIES = 321 - DorisSQLParserPRECEDING = 322 - DorisSQLParserPREDICATE = 323 - DorisSQLParserPREPARE = 324 - DorisSQLParserPRIMARY = 325 - DorisSQLParserPRIORITY = 326 - DorisSQLParserPRIVILEGES = 327 - DorisSQLParserPROBABILITY = 328 - DorisSQLParserPROC = 329 - DorisSQLParserPROCEDURE = 330 - DorisSQLParserPROCESSLIST = 331 - DorisSQLParserPROFILE = 332 - DorisSQLParserPROFILELIST = 333 - DorisSQLParserPROPERTIES = 334 - DorisSQLParserPROPERTY = 335 - DorisSQLParserPROVIDER = 336 - DorisSQLParserPROVIDERS = 337 - DorisSQLParserQUALIFY = 338 - DorisSQLParserQUARTER = 339 - DorisSQLParserQUERY = 340 - DorisSQLParserQUERIES = 341 - DorisSQLParserQUEUE = 342 - DorisSQLParserQUOTA = 343 - DorisSQLParserRANDOM = 344 - DorisSQLParserRANGE = 345 - DorisSQLParserRANK = 346 - DorisSQLParserREAD = 347 - DorisSQLParserREASON = 348 - DorisSQLParserRECOVER = 349 - DorisSQLParserREFRESH = 350 - DorisSQLParserREWRITE = 351 - DorisSQLParserREGEXP = 352 - DorisSQLParserRELEASE = 353 - DorisSQLParserREMOVE = 354 - DorisSQLParserRENAME = 355 - DorisSQLParserREPAIR = 356 - DorisSQLParserREPEATABLE = 357 - DorisSQLParserREPLACE = 358 - DorisSQLParserREPLACE_IF_NOT_NULL = 359 - DorisSQLParserREPLICA = 360 - DorisSQLParserREPOSITORY = 361 - DorisSQLParserREPOSITORIES = 362 - DorisSQLParserRESOURCE = 363 - DorisSQLParserRESOURCES = 364 - DorisSQLParserRESTORE = 365 - DorisSQLParserRESUME = 366 - DorisSQLParserRETAIN = 367 - DorisSQLParserRETENTION = 368 - DorisSQLParserRETURNS = 369 - DorisSQLParserRETRY = 370 - DorisSQLParserREVOKE = 371 - DorisSQLParserREVERT = 372 - DorisSQLParserRIGHT = 373 - DorisSQLParserRLIKE = 374 - DorisSQLParserROLE = 375 - DorisSQLParserROLES = 376 - DorisSQLParserROLLBACK = 377 - DorisSQLParserROLLUP = 378 - DorisSQLParserROUTINE = 379 - DorisSQLParserROW = 380 - DorisSQLParserROWS = 381 - DorisSQLParserROW_NUMBER = 382 - DorisSQLParserRULE = 383 - DorisSQLParserRULES = 384 - DorisSQLParserRUNNING = 385 - DorisSQLParserSAMPLE = 386 - DorisSQLParserSCHEDULE = 387 - DorisSQLParserSCHEDULER = 388 - DorisSQLParserSCHEMA = 389 - DorisSQLParserSCHEMAS = 390 - DorisSQLParserSECOND = 391 - DorisSQLParserSECURITY = 392 - DorisSQLParserSELECT = 393 - DorisSQLParserSEMI = 394 - DorisSQLParserSEPARATOR = 395 - DorisSQLParserSERIALIZABLE = 396 - DorisSQLParserSESSION = 397 - DorisSQLParserSET = 398 - DorisSQLParserSETS = 399 - DorisSQLParserSET_VAR = 400 - DorisSQLParserSIGNED = 401 - DorisSQLParserSKIP_HEADER = 402 - DorisSQLParserSHOW = 403 - DorisSQLParserSMALLINT = 404 - DorisSQLParserSNAPSHOT = 405 - DorisSQLParserSNAPSHOTS = 406 - DorisSQLParserSQLBLACKLIST = 407 - DorisSQLParserSTART = 408 - DorisSQLParserSTATS = 409 - DorisSQLParserSTATUS = 410 - DorisSQLParserSTOP = 411 - DorisSQLParserSTORAGE = 412 - DorisSQLParserSTREAM = 413 - DorisSQLParserSTRING = 414 - DorisSQLParserTEXT = 415 - DorisSQLParserSUBMIT = 416 - DorisSQLParserSUM = 417 - DorisSQLParserSUSPEND = 418 - DorisSQLParserSYNC = 419 - DorisSQLParserSYSTEM = 420 - DorisSQLParserSYSTEM_TIME = 421 - DorisSQLParserSWAP = 422 - DorisSQLParserSTRUCT = 423 - DorisSQLParserTABLE = 424 - DorisSQLParserTABLES = 425 - DorisSQLParserTABLET = 426 - DorisSQLParserTABLETS = 427 - DorisSQLParserTAG = 428 - DorisSQLParserTASK = 429 - DorisSQLParserTEMPORARY = 430 - DorisSQLParserTERMINATED = 431 - DorisSQLParserTHAN = 432 - DorisSQLParserTHEN = 433 - DorisSQLParserTIME = 434 - DorisSQLParserTIMES = 435 - DorisSQLParserTIMESTAMP = 436 - DorisSQLParserTIMESTAMPADD = 437 - DorisSQLParserTIMESTAMPDIFF = 438 - DorisSQLParserTINYINT = 439 - DorisSQLParserTRANSACTION = 440 - DorisSQLParserTRANSLATE = 441 - DorisSQLParserTO = 442 - DorisSQLParserTRACE = 443 - DorisSQLParserTRIGGERS = 444 - DorisSQLParserTRIM_SPACE = 445 - DorisSQLParserTRUE = 446 - DorisSQLParserTRUNCATE = 447 - DorisSQLParserTYPE = 448 - DorisSQLParserTYPES = 449 - DorisSQLParserUNBOUNDED = 450 - DorisSQLParserUNCOMMITTED = 451 - DorisSQLParserUNION = 452 - DorisSQLParserUNIQUE = 453 - DorisSQLParserUNINSTALL = 454 - DorisSQLParserUNSET = 455 - DorisSQLParserUNSIGNED = 456 - DorisSQLParserUPDATE = 457 - DorisSQLParserUSAGE = 458 - DorisSQLParserUSE = 459 - DorisSQLParserUSER = 460 - DorisSQLParserUSERS = 461 - DorisSQLParserUSING = 462 - DorisSQLParserVALUE = 463 - DorisSQLParserVALUES = 464 - DorisSQLParserVARBINARY = 465 - DorisSQLParserVARCHAR = 466 - DorisSQLParserVARIABLES = 467 - DorisSQLParserVECTOR = 468 - DorisSQLParserVERBOSE = 469 - DorisSQLParserVERSION = 470 - DorisSQLParserVIEW = 471 - DorisSQLParserVIEWS = 472 - DorisSQLParserVOLUME = 473 - DorisSQLParserVOLUMES = 474 - DorisSQLParserWAREHOUSE = 475 - DorisSQLParserWAREHOUSES = 476 - DorisSQLParserWARNINGS = 477 - DorisSQLParserWEEK = 478 - DorisSQLParserWHEN = 479 - DorisSQLParserWHERE = 480 - DorisSQLParserWHITELIST = 481 - DorisSQLParserWITH = 482 - DorisSQLParserWORK = 483 - DorisSQLParserWRITE = 484 - DorisSQLParserYEAR = 485 - DorisSQLParserLOCK = 486 - DorisSQLParserUNLOCK = 487 - DorisSQLParserLOW_PRIORITY = 488 - DorisSQLParserDISK = 489 - DorisSQLParserDISKS = 490 - DorisSQLParserBEFORE = 491 - DorisSQLParserDOUBLE_DOLLAR = 492 - DorisSQLParserFIELD = 493 - DorisSQLParserPERSISTENT = 494 - DorisSQLParserSKEW = 495 - DorisSQLParserENCRYPT = 496 - DorisSQLParserCACHED = 497 - DorisSQLParserLIGHT = 498 - DorisSQLParserRECYCLE = 499 - DorisSQLParserBIN = 500 - DorisSQLParserTRASH = 501 - DorisSQLParserWORKLOAD = 502 - DorisSQLParserSQL = 503 - DorisSQLParserBLOCK = 504 - DorisSQLParserTASKS = 505 - DorisSQLParserCHANGE = 506 - DorisSQLParserPROCESS = 507 - DorisSQLParserMIGRATIONS = 508 - DorisSQLParserEQ = 509 - DorisSQLParserNEQ = 510 - DorisSQLParserLT = 511 - DorisSQLParserLTE = 512 - DorisSQLParserGT = 513 - DorisSQLParserGTE = 514 - DorisSQLParserEQ_FOR_NULL = 515 - DorisSQLParserARRAY_ELEMENT = 516 - DorisSQLParserPLUS_SYMBOL = 517 - DorisSQLParserMINUS_SYMBOL = 518 - DorisSQLParserASTERISK_SYMBOL = 519 - DorisSQLParserSLASH_SYMBOL = 520 - DorisSQLParserPERCENT_SYMBOL = 521 - DorisSQLParserLOGICAL_OR = 522 - DorisSQLParserLOGICAL_AND = 523 - DorisSQLParserLOGICAL_NOT = 524 - DorisSQLParserINT_DIV = 525 - DorisSQLParserBITAND = 526 - DorisSQLParserBITOR = 527 - DorisSQLParserBITXOR = 528 - DorisSQLParserBITNOT = 529 - DorisSQLParserBIT_SHIFT_LEFT = 530 - DorisSQLParserBIT_SHIFT_RIGHT = 531 - DorisSQLParserBIT_SHIFT_RIGHT_LOGICAL = 532 - DorisSQLParserARROW = 533 - DorisSQLParserAT = 534 - DorisSQLParserINTEGER_VALUE = 535 - DorisSQLParserDECIMAL_VALUE = 536 - DorisSQLParserDOUBLE_VALUE = 537 - DorisSQLParserSINGLE_QUOTED_TEXT = 538 - DorisSQLParserDOUBLE_QUOTED_TEXT = 539 - DorisSQLParserBINARY_SINGLE_QUOTED_TEXT = 540 - DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT = 541 - DorisSQLParserLETTER_IDENTIFIER = 542 - DorisSQLParserDIGIT_IDENTIFIER = 543 - DorisSQLParserBACKQUOTED_IDENTIFIER = 544 - DorisSQLParserDOT_IDENTIFIER = 545 - DorisSQLParserSIMPLE_COMMENT = 546 - DorisSQLParserBRACKETED_COMMENT = 547 - DorisSQLParserOPTIMIZER_HINT = 548 - DorisSQLParserSEMICOLON = 549 - DorisSQLParserDOTDOTDOT = 550 - DorisSQLParserWS = 551 - DorisSQLParserATTACHMENT = 552 - DorisSQLParserCONCAT = 553 + StarRocksSQLParserEOF = antlr.TokenEOF + StarRocksSQLParserT__0 = 1 + StarRocksSQLParserT__1 = 2 + StarRocksSQLParserT__2 = 3 + StarRocksSQLParserT__3 = 4 + StarRocksSQLParserT__4 = 5 + StarRocksSQLParserT__5 = 6 + StarRocksSQLParserT__6 = 7 + StarRocksSQLParserT__7 = 8 + StarRocksSQLParserT__8 = 9 + StarRocksSQLParserT__9 = 10 + StarRocksSQLParserACCESS = 11 + StarRocksSQLParserACTIVE = 12 + StarRocksSQLParserADD = 13 + StarRocksSQLParserADMIN = 14 + StarRocksSQLParserADVISOR = 15 + StarRocksSQLParserAFTER = 16 + StarRocksSQLParserAGGREGATE = 17 + StarRocksSQLParserALL = 18 + StarRocksSQLParserALTER = 19 + StarRocksSQLParserANALYZE = 20 + StarRocksSQLParserAND = 21 + StarRocksSQLParserANTI = 22 + StarRocksSQLParserAPPLY = 23 + StarRocksSQLParserARRAY = 24 + StarRocksSQLParserARRAY_AGG = 25 + StarRocksSQLParserARRAY_AGG_DISTINCT = 26 + StarRocksSQLParserAS = 27 + StarRocksSQLParserASC = 28 + StarRocksSQLParserASYNC = 29 + StarRocksSQLParserAUTHORS = 30 + StarRocksSQLParserAUTHENTICATION = 31 + StarRocksSQLParserAUTOMATED = 32 + StarRocksSQLParserAUTO_INCREMENT = 33 + StarRocksSQLParserAVG = 34 + StarRocksSQLParserBACKEND = 35 + StarRocksSQLParserBACKENDS = 36 + StarRocksSQLParserBACKUP = 37 + StarRocksSQLParserBASE = 38 + StarRocksSQLParserBASELINE = 39 + StarRocksSQLParserBEGIN = 40 + StarRocksSQLParserBETWEEN = 41 + StarRocksSQLParserBIGINT = 42 + StarRocksSQLParserBINARY = 43 + StarRocksSQLParserBITMAP = 44 + StarRocksSQLParserBITMAP_UNION = 45 + StarRocksSQLParserBLACKHOLE = 46 + StarRocksSQLParserBLACKLIST = 47 + StarRocksSQLParserBODY = 48 + StarRocksSQLParserBOOLEAN = 49 + StarRocksSQLParserBOTH = 50 + StarRocksSQLParserBRANCH = 51 + StarRocksSQLParserBROKER = 52 + StarRocksSQLParserBUCKETS = 53 + StarRocksSQLParserBUILTIN = 54 + StarRocksSQLParserBY = 55 + StarRocksSQLParserCACHE = 56 + StarRocksSQLParserCANCEL = 57 + StarRocksSQLParserCASE = 58 + StarRocksSQLParserCAST = 59 + StarRocksSQLParserCATALOG = 60 + StarRocksSQLParserCATALOGS = 61 + StarRocksSQLParserCEIL = 62 + StarRocksSQLParserCHAIN = 63 + StarRocksSQLParserCHAR = 64 + StarRocksSQLParserCHARACTER = 65 + StarRocksSQLParserCHARSET = 66 + StarRocksSQLParserCHECK = 67 + StarRocksSQLParserCLEAN = 68 + StarRocksSQLParserCLEAR = 69 + StarRocksSQLParserCLUSTER = 70 + StarRocksSQLParserCLUSTERS = 71 + StarRocksSQLParserCNGROUP = 72 + StarRocksSQLParserCNGROUPS = 73 + StarRocksSQLParserCOLLATE = 74 + StarRocksSQLParserCOLLATION = 75 + StarRocksSQLParserCOLUMN = 76 + StarRocksSQLParserCOLUMNS = 77 + StarRocksSQLParserCOMMENT = 78 + StarRocksSQLParserCOMMIT = 79 + StarRocksSQLParserCOMMITTED = 80 + StarRocksSQLParserCOMPACT = 81 + StarRocksSQLParserCOMPACTION = 82 + StarRocksSQLParserCOMPUTE = 83 + StarRocksSQLParserCONFIG = 84 + StarRocksSQLParserCONNECTION = 85 + StarRocksSQLParserCONSISTENT = 86 + StarRocksSQLParserCONVERT = 87 + StarRocksSQLParserCOSTS = 88 + StarRocksSQLParserCOUNT = 89 + StarRocksSQLParserCREATE = 90 + StarRocksSQLParserCROSS = 91 + StarRocksSQLParserCUBE = 92 + StarRocksSQLParserCUME_DIST = 93 + StarRocksSQLParserCUMULATIVE = 94 + StarRocksSQLParserCURRENT = 95 + StarRocksSQLParserCURRENT_DATE = 96 + StarRocksSQLParserCURRENT_GROUP = 97 + StarRocksSQLParserCURRENT_ROLE = 98 + StarRocksSQLParserCURRENT_TIME = 99 + StarRocksSQLParserCURRENT_TIMESTAMP = 100 + StarRocksSQLParserCURRENT_USER = 101 + StarRocksSQLParserDATA = 102 + StarRocksSQLParserDATACACHE = 103 + StarRocksSQLParserDATABASE = 104 + StarRocksSQLParserDATABASES = 105 + StarRocksSQLParserDATE = 106 + StarRocksSQLParserDATETIME = 107 + StarRocksSQLParserDAY = 108 + StarRocksSQLParserDAYS = 109 + StarRocksSQLParserDEALLOCATE = 110 + StarRocksSQLParserDECIMAL = 111 + StarRocksSQLParserDECIMALV2 = 112 + StarRocksSQLParserDECIMAL32 = 113 + StarRocksSQLParserDECIMAL64 = 114 + StarRocksSQLParserDECIMAL128 = 115 + StarRocksSQLParserDECOMMISSION = 116 + StarRocksSQLParserDEFAULT = 117 + StarRocksSQLParserDELETE = 118 + StarRocksSQLParserDENSE_RANK = 119 + StarRocksSQLParserDEFERRED = 120 + StarRocksSQLParserDIALECT = 121 + StarRocksSQLParserDICTIONARY = 122 + StarRocksSQLParserDICTIONARY_GET = 123 + StarRocksSQLParserNTILE = 124 + StarRocksSQLParserDESC = 125 + StarRocksSQLParserDESCRIBE = 126 + StarRocksSQLParserDISABLE = 127 + StarRocksSQLParserDISTINCT = 128 + StarRocksSQLParserDISTRIBUTED = 129 + StarRocksSQLParserDISTRIBUTION = 130 + StarRocksSQLParserDOUBLE = 131 + StarRocksSQLParserDROP = 132 + StarRocksSQLParserDUAL = 133 + StarRocksSQLParserDUPLICATE = 134 + StarRocksSQLParserDYNAMIC = 135 + StarRocksSQLParserELSE = 136 + StarRocksSQLParserENABLE = 137 + StarRocksSQLParserENCLOSE = 138 + StarRocksSQLParserEND = 139 + StarRocksSQLParserENGINE = 140 + StarRocksSQLParserENGINES = 141 + StarRocksSQLParserERRORS = 142 + StarRocksSQLParserESCAPE = 143 + StarRocksSQLParserEVENTS = 144 + StarRocksSQLParserEXCEPT = 145 + StarRocksSQLParserEXCLUDE = 146 + StarRocksSQLParserEXECUTE = 147 + StarRocksSQLParserEXISTS = 148 + StarRocksSQLParserEXPLAIN = 149 + StarRocksSQLParserEXPLODE = 150 + StarRocksSQLParserEXPLODE_SPLIT = 151 + StarRocksSQLParserEXPORT = 152 + StarRocksSQLParserEXTERNAL = 153 + StarRocksSQLParserEXTRACT = 154 + StarRocksSQLParserEVERY = 155 + StarRocksSQLParserFAILPOINT = 156 + StarRocksSQLParserFAILPOINTS = 157 + StarRocksSQLParserFALSE = 158 + StarRocksSQLParserFIELDS = 159 + StarRocksSQLParserFILE = 160 + StarRocksSQLParserFILES = 161 + StarRocksSQLParserFILTER = 162 + StarRocksSQLParserFIRST = 163 + StarRocksSQLParserFIRST_VALUE = 164 + StarRocksSQLParserFLOAT = 165 + StarRocksSQLParserFLOOR = 166 + StarRocksSQLParserFN = 167 + StarRocksSQLParserFOLLOWING = 168 + StarRocksSQLParserFOLLOWER = 169 + StarRocksSQLParserFOR = 170 + StarRocksSQLParserFORCE = 171 + StarRocksSQLParserFORMAT = 172 + StarRocksSQLParserFREE = 173 + StarRocksSQLParserFROM = 174 + StarRocksSQLParserFRONTEND = 175 + StarRocksSQLParserFRONTENDS = 176 + StarRocksSQLParserFULL = 177 + StarRocksSQLParserFUNCTION = 178 + StarRocksSQLParserFUNCTIONS = 179 + StarRocksSQLParserGLOBAL = 180 + StarRocksSQLParserGRANT = 181 + StarRocksSQLParserGRANTS = 182 + StarRocksSQLParserGROUP = 183 + StarRocksSQLParserGROUPS = 184 + StarRocksSQLParserGROUPING = 185 + StarRocksSQLParserGROUPING_ID = 186 + StarRocksSQLParserGROUP_CONCAT = 187 + StarRocksSQLParserHASH = 188 + StarRocksSQLParserHAVING = 189 + StarRocksSQLParserHELP = 190 + StarRocksSQLParserHISTOGRAM = 191 + StarRocksSQLParserHLL = 192 + StarRocksSQLParserHLL_UNION = 193 + StarRocksSQLParserHOST = 194 + StarRocksSQLParserHOUR = 195 + StarRocksSQLParserHOURS = 196 + StarRocksSQLParserHUB = 197 + StarRocksSQLParserIDENTIFIED = 198 + StarRocksSQLParserIF = 199 + StarRocksSQLParserIMPERSONATE = 200 + StarRocksSQLParserIMMEDIATE = 201 + StarRocksSQLParserIGNORE = 202 + StarRocksSQLParserIMAGE = 203 + StarRocksSQLParserIN = 204 + StarRocksSQLParserINACTIVE = 205 + StarRocksSQLParserINCREMENTAL = 206 + StarRocksSQLParserINDEX = 207 + StarRocksSQLParserINDEXES = 208 + StarRocksSQLParserINFILE = 209 + StarRocksSQLParserINNER = 210 + StarRocksSQLParserINSTALL = 211 + StarRocksSQLParserINSERT = 212 + StarRocksSQLParserINT = 213 + StarRocksSQLParserINTEGER = 214 + StarRocksSQLParserINTEGRATION = 215 + StarRocksSQLParserINTEGRATIONS = 216 + StarRocksSQLParserINTERMEDIATE = 217 + StarRocksSQLParserINTERSECT = 218 + StarRocksSQLParserINTERVAL = 219 + StarRocksSQLParserINTO = 220 + StarRocksSQLParserINVOKER = 221 + StarRocksSQLParserGIN = 222 + StarRocksSQLParserOVERWRITE = 223 + StarRocksSQLParserIS = 224 + StarRocksSQLParserISOLATION = 225 + StarRocksSQLParserJOB = 226 + StarRocksSQLParserJOIN = 227 + StarRocksSQLParserJSON = 228 + StarRocksSQLParserKEY = 229 + StarRocksSQLParserKEYS = 230 + StarRocksSQLParserKILL = 231 + StarRocksSQLParserLABEL = 232 + StarRocksSQLParserLAG = 233 + StarRocksSQLParserLARGEINT = 234 + StarRocksSQLParserLAST = 235 + StarRocksSQLParserLAST_VALUE = 236 + StarRocksSQLParserLATERAL = 237 + StarRocksSQLParserLEAD = 238 + StarRocksSQLParserLEFT = 239 + StarRocksSQLParserLESS = 240 + StarRocksSQLParserLEVEL = 241 + StarRocksSQLParserLIKE = 242 + StarRocksSQLParserLIMIT = 243 + StarRocksSQLParserLIST = 244 + StarRocksSQLParserLOAD = 245 + StarRocksSQLParserLOCAL = 246 + StarRocksSQLParserLOCALTIME = 247 + StarRocksSQLParserLOCALTIMESTAMP = 248 + StarRocksSQLParserLOCATION = 249 + StarRocksSQLParserLOCATIONS = 250 + StarRocksSQLParserLOGS = 251 + StarRocksSQLParserLOGICAL = 252 + StarRocksSQLParserMANUAL = 253 + StarRocksSQLParserMAP = 254 + StarRocksSQLParserMAPPING = 255 + StarRocksSQLParserMAPPINGS = 256 + StarRocksSQLParserMASKING = 257 + StarRocksSQLParserMATCH = 258 + StarRocksSQLParserMATERIALIZED = 259 + StarRocksSQLParserMAX = 260 + StarRocksSQLParserMAXVALUE = 261 + StarRocksSQLParserMERGE = 262 + StarRocksSQLParserMICROSECOND = 263 + StarRocksSQLParserMILLISECOND = 264 + StarRocksSQLParserMIN = 265 + StarRocksSQLParserMINUTE = 266 + StarRocksSQLParserMINUTES = 267 + StarRocksSQLParserMINUS = 268 + StarRocksSQLParserMETA = 269 + StarRocksSQLParserMOD = 270 + StarRocksSQLParserMODE = 271 + StarRocksSQLParserMODIFY = 272 + StarRocksSQLParserMONTH = 273 + StarRocksSQLParserMULTIPLE = 274 + StarRocksSQLParserNAME = 275 + StarRocksSQLParserNAMES = 276 + StarRocksSQLParserNEGATIVE = 277 + StarRocksSQLParserNGRAMBF = 278 + StarRocksSQLParserNO = 279 + StarRocksSQLParserNODE = 280 + StarRocksSQLParserNODES = 281 + StarRocksSQLParserNONE = 282 + StarRocksSQLParserNOT = 283 + StarRocksSQLParserNULL = 284 + StarRocksSQLParserNULLS = 285 + StarRocksSQLParserNUMBER = 286 + StarRocksSQLParserNUMERIC = 287 + StarRocksSQLParserOBSERVER = 288 + StarRocksSQLParserOF = 289 + StarRocksSQLParserOFF = 290 + StarRocksSQLParserOFFSET = 291 + StarRocksSQLParserON = 292 + StarRocksSQLParserONLY = 293 + StarRocksSQLParserOPEN = 294 + StarRocksSQLParserOPERATE = 295 + StarRocksSQLParserOPTIMIZE = 296 + StarRocksSQLParserOPTIMIZER = 297 + StarRocksSQLParserOPTION = 298 + StarRocksSQLParserOR = 299 + StarRocksSQLParserORDER = 300 + StarRocksSQLParserOUTER = 301 + StarRocksSQLParserOUTFILE = 302 + StarRocksSQLParserOVER = 303 + StarRocksSQLParserPARAMETER = 304 + StarRocksSQLParserPARTITION = 305 + StarRocksSQLParserPARTITIONS = 306 + StarRocksSQLParserPASSWORD = 307 + StarRocksSQLParserPATH = 308 + StarRocksSQLParserPAUSE = 309 + StarRocksSQLParserPENDING = 310 + StarRocksSQLParserPERCENT_RANK = 311 + StarRocksSQLParserPERCENTILE = 312 + StarRocksSQLParserPERCENTILE_UNION = 313 + StarRocksSQLParserPLAN = 314 + StarRocksSQLParserPLUGIN = 315 + StarRocksSQLParserPLUGINS = 316 + StarRocksSQLParserPIPE = 317 + StarRocksSQLParserPIPES = 318 + StarRocksSQLParserPIVOT = 319 + StarRocksSQLParserPOLICY = 320 + StarRocksSQLParserPOLICIES = 321 + StarRocksSQLParserPRECEDING = 322 + StarRocksSQLParserPREDICATE = 323 + StarRocksSQLParserPREPARE = 324 + StarRocksSQLParserPRIMARY = 325 + StarRocksSQLParserPRIORITY = 326 + StarRocksSQLParserPRIVILEGES = 327 + StarRocksSQLParserPROBABILITY = 328 + StarRocksSQLParserPROC = 329 + StarRocksSQLParserPROCEDURE = 330 + StarRocksSQLParserPROCESSLIST = 331 + StarRocksSQLParserPROFILE = 332 + StarRocksSQLParserPROFILELIST = 333 + StarRocksSQLParserPROPERTIES = 334 + StarRocksSQLParserPROPERTY = 335 + StarRocksSQLParserPROVIDER = 336 + StarRocksSQLParserPROVIDERS = 337 + StarRocksSQLParserQUALIFY = 338 + StarRocksSQLParserQUARTER = 339 + StarRocksSQLParserQUERY = 340 + StarRocksSQLParserQUERIES = 341 + StarRocksSQLParserQUEUE = 342 + StarRocksSQLParserQUOTA = 343 + StarRocksSQLParserRANDOM = 344 + StarRocksSQLParserRANGE = 345 + StarRocksSQLParserRANK = 346 + StarRocksSQLParserREAD = 347 + StarRocksSQLParserREASON = 348 + StarRocksSQLParserRECOVER = 349 + StarRocksSQLParserREFRESH = 350 + StarRocksSQLParserREWRITE = 351 + StarRocksSQLParserREGEXP = 352 + StarRocksSQLParserRELEASE = 353 + StarRocksSQLParserREMOVE = 354 + StarRocksSQLParserRENAME = 355 + StarRocksSQLParserREPAIR = 356 + StarRocksSQLParserREPEATABLE = 357 + StarRocksSQLParserREPLACE = 358 + StarRocksSQLParserREPLACE_IF_NOT_NULL = 359 + StarRocksSQLParserREPLICA = 360 + StarRocksSQLParserREPOSITORY = 361 + StarRocksSQLParserREPOSITORIES = 362 + StarRocksSQLParserRESOURCE = 363 + StarRocksSQLParserRESOURCES = 364 + StarRocksSQLParserRESTORE = 365 + StarRocksSQLParserRESUME = 366 + StarRocksSQLParserRETAIN = 367 + StarRocksSQLParserRETENTION = 368 + StarRocksSQLParserRETURNS = 369 + StarRocksSQLParserRETRY = 370 + StarRocksSQLParserREVOKE = 371 + StarRocksSQLParserREVERT = 372 + StarRocksSQLParserRIGHT = 373 + StarRocksSQLParserRLIKE = 374 + StarRocksSQLParserROLE = 375 + StarRocksSQLParserROLES = 376 + StarRocksSQLParserROLLBACK = 377 + StarRocksSQLParserROLLUP = 378 + StarRocksSQLParserROUTINE = 379 + StarRocksSQLParserROW = 380 + StarRocksSQLParserROWS = 381 + StarRocksSQLParserROW_NUMBER = 382 + StarRocksSQLParserRULE = 383 + StarRocksSQLParserRULES = 384 + StarRocksSQLParserRUNNING = 385 + StarRocksSQLParserSAMPLE = 386 + StarRocksSQLParserSCHEDULE = 387 + StarRocksSQLParserSCHEDULER = 388 + StarRocksSQLParserSCHEMA = 389 + StarRocksSQLParserSCHEMAS = 390 + StarRocksSQLParserSECOND = 391 + StarRocksSQLParserSECURITY = 392 + StarRocksSQLParserSELECT = 393 + StarRocksSQLParserSEMI = 394 + StarRocksSQLParserSEPARATOR = 395 + StarRocksSQLParserSERIALIZABLE = 396 + StarRocksSQLParserSESSION = 397 + StarRocksSQLParserSET = 398 + StarRocksSQLParserSETS = 399 + StarRocksSQLParserSET_VAR = 400 + StarRocksSQLParserSIGNED = 401 + StarRocksSQLParserSKIP_HEADER = 402 + StarRocksSQLParserSHOW = 403 + StarRocksSQLParserSMALLINT = 404 + StarRocksSQLParserSNAPSHOT = 405 + StarRocksSQLParserSNAPSHOTS = 406 + StarRocksSQLParserSQLBLACKLIST = 407 + StarRocksSQLParserSTART = 408 + StarRocksSQLParserSTATS = 409 + StarRocksSQLParserSTATUS = 410 + StarRocksSQLParserSTOP = 411 + StarRocksSQLParserSTORAGE = 412 + StarRocksSQLParserSTREAM = 413 + StarRocksSQLParserSTRING = 414 + StarRocksSQLParserTEXT = 415 + StarRocksSQLParserSUBMIT = 416 + StarRocksSQLParserSUM = 417 + StarRocksSQLParserSUSPEND = 418 + StarRocksSQLParserSYNC = 419 + StarRocksSQLParserSYSTEM = 420 + StarRocksSQLParserSYSTEM_TIME = 421 + StarRocksSQLParserSWAP = 422 + StarRocksSQLParserSTRUCT = 423 + StarRocksSQLParserTABLE = 424 + StarRocksSQLParserTABLES = 425 + StarRocksSQLParserTABLET = 426 + StarRocksSQLParserTABLETS = 427 + StarRocksSQLParserTAG = 428 + StarRocksSQLParserTASK = 429 + StarRocksSQLParserTEMPORARY = 430 + StarRocksSQLParserTERMINATED = 431 + StarRocksSQLParserTHAN = 432 + StarRocksSQLParserTHEN = 433 + StarRocksSQLParserTIME = 434 + StarRocksSQLParserTIMES = 435 + StarRocksSQLParserTIMESTAMP = 436 + StarRocksSQLParserTIMESTAMPADD = 437 + StarRocksSQLParserTIMESTAMPDIFF = 438 + StarRocksSQLParserTINYINT = 439 + StarRocksSQLParserTRANSACTION = 440 + StarRocksSQLParserTRANSLATE = 441 + StarRocksSQLParserTO = 442 + StarRocksSQLParserTRACE = 443 + StarRocksSQLParserTRIGGERS = 444 + StarRocksSQLParserTRIM_SPACE = 445 + StarRocksSQLParserTRUE = 446 + StarRocksSQLParserTRUNCATE = 447 + StarRocksSQLParserTYPE = 448 + StarRocksSQLParserTYPES = 449 + StarRocksSQLParserUNBOUNDED = 450 + StarRocksSQLParserUNCOMMITTED = 451 + StarRocksSQLParserUNION = 452 + StarRocksSQLParserUNIQUE = 453 + StarRocksSQLParserUNINSTALL = 454 + StarRocksSQLParserUNSET = 455 + StarRocksSQLParserUNSIGNED = 456 + StarRocksSQLParserUPDATE = 457 + StarRocksSQLParserUSAGE = 458 + StarRocksSQLParserUSE = 459 + StarRocksSQLParserUSER = 460 + StarRocksSQLParserUSERS = 461 + StarRocksSQLParserUSING = 462 + StarRocksSQLParserVALUE = 463 + StarRocksSQLParserVALUES = 464 + StarRocksSQLParserVARBINARY = 465 + StarRocksSQLParserVARCHAR = 466 + StarRocksSQLParserVARIABLES = 467 + StarRocksSQLParserVECTOR = 468 + StarRocksSQLParserVERBOSE = 469 + StarRocksSQLParserVERSION = 470 + StarRocksSQLParserVIEW = 471 + StarRocksSQLParserVIEWS = 472 + StarRocksSQLParserVOLUME = 473 + StarRocksSQLParserVOLUMES = 474 + StarRocksSQLParserWAREHOUSE = 475 + StarRocksSQLParserWAREHOUSES = 476 + StarRocksSQLParserWARNINGS = 477 + StarRocksSQLParserWEEK = 478 + StarRocksSQLParserWHEN = 479 + StarRocksSQLParserWHERE = 480 + StarRocksSQLParserWHITELIST = 481 + StarRocksSQLParserWITH = 482 + StarRocksSQLParserWORK = 483 + StarRocksSQLParserWRITE = 484 + StarRocksSQLParserYEAR = 485 + StarRocksSQLParserLOCK = 486 + StarRocksSQLParserUNLOCK = 487 + StarRocksSQLParserLOW_PRIORITY = 488 + StarRocksSQLParserDISK = 489 + StarRocksSQLParserDISKS = 490 + StarRocksSQLParserBEFORE = 491 + StarRocksSQLParserDOUBLE_DOLLAR = 492 + StarRocksSQLParserFIELD = 493 + StarRocksSQLParserPERSISTENT = 494 + StarRocksSQLParserSKEW = 495 + StarRocksSQLParserENCRYPT = 496 + StarRocksSQLParserCACHED = 497 + StarRocksSQLParserLIGHT = 498 + StarRocksSQLParserRECYCLE = 499 + StarRocksSQLParserBIN = 500 + StarRocksSQLParserTRASH = 501 + StarRocksSQLParserWORKLOAD = 502 + StarRocksSQLParserSQL = 503 + StarRocksSQLParserBLOCK = 504 + StarRocksSQLParserTASKS = 505 + StarRocksSQLParserCHANGE = 506 + StarRocksSQLParserPROCESS = 507 + StarRocksSQLParserMIGRATIONS = 508 + StarRocksSQLParserEQ = 509 + StarRocksSQLParserNEQ = 510 + StarRocksSQLParserLT = 511 + StarRocksSQLParserLTE = 512 + StarRocksSQLParserGT = 513 + StarRocksSQLParserGTE = 514 + StarRocksSQLParserEQ_FOR_NULL = 515 + StarRocksSQLParserARRAY_ELEMENT = 516 + StarRocksSQLParserPLUS_SYMBOL = 517 + StarRocksSQLParserMINUS_SYMBOL = 518 + StarRocksSQLParserASTERISK_SYMBOL = 519 + StarRocksSQLParserSLASH_SYMBOL = 520 + StarRocksSQLParserPERCENT_SYMBOL = 521 + StarRocksSQLParserLOGICAL_OR = 522 + StarRocksSQLParserLOGICAL_AND = 523 + StarRocksSQLParserLOGICAL_NOT = 524 + StarRocksSQLParserINT_DIV = 525 + StarRocksSQLParserBITAND = 526 + StarRocksSQLParserBITOR = 527 + StarRocksSQLParserBITXOR = 528 + StarRocksSQLParserBITNOT = 529 + StarRocksSQLParserBIT_SHIFT_LEFT = 530 + StarRocksSQLParserBIT_SHIFT_RIGHT = 531 + StarRocksSQLParserBIT_SHIFT_RIGHT_LOGICAL = 532 + StarRocksSQLParserARROW = 533 + StarRocksSQLParserAT = 534 + StarRocksSQLParserINTEGER_VALUE = 535 + StarRocksSQLParserDECIMAL_VALUE = 536 + StarRocksSQLParserDOUBLE_VALUE = 537 + StarRocksSQLParserSINGLE_QUOTED_TEXT = 538 + StarRocksSQLParserDOUBLE_QUOTED_TEXT = 539 + StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT = 540 + StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT = 541 + StarRocksSQLParserLETTER_IDENTIFIER = 542 + StarRocksSQLParserDIGIT_IDENTIFIER = 543 + StarRocksSQLParserBACKQUOTED_IDENTIFIER = 544 + StarRocksSQLParserDOT_IDENTIFIER = 545 + StarRocksSQLParserSIMPLE_COMMENT = 546 + StarRocksSQLParserBRACKETED_COMMENT = 547 + StarRocksSQLParserOPTIMIZER_HINT = 548 + StarRocksSQLParserSEMICOLON = 549 + StarRocksSQLParserDOTDOTDOT = 550 + StarRocksSQLParserWS = 551 + StarRocksSQLParserATTACHMENT = 552 + StarRocksSQLParserCONCAT = 553 ) -// DorisSQLParser rules. +// StarRocksSQLParser rules. const ( - DorisSQLParserRULE_sqlStatements = 0 - DorisSQLParserRULE_singleStatement = 1 - DorisSQLParserRULE_statement = 2 - DorisSQLParserRULE_useDatabaseStatement = 3 - DorisSQLParserRULE_useCatalogStatement = 4 - DorisSQLParserRULE_setCatalogStatement = 5 - DorisSQLParserRULE_showDatabasesStatement = 6 - DorisSQLParserRULE_alterDbQuotaStatement = 7 - DorisSQLParserRULE_createDbStatement = 8 - DorisSQLParserRULE_dropDbStatement = 9 - DorisSQLParserRULE_showCreateDbStatement = 10 - DorisSQLParserRULE_alterDatabaseRenameStatement = 11 - DorisSQLParserRULE_recoverDbStmt = 12 - DorisSQLParserRULE_showDataStmt = 13 - DorisSQLParserRULE_showDataDistributionStmt = 14 - DorisSQLParserRULE_createTableStatement = 15 - DorisSQLParserRULE_columnDesc = 16 - DorisSQLParserRULE_charsetName = 17 - DorisSQLParserRULE_defaultDesc = 18 - DorisSQLParserRULE_generatedColumnDesc = 19 - DorisSQLParserRULE_indexDesc = 20 - DorisSQLParserRULE_engineDesc = 21 - DorisSQLParserRULE_charsetDesc = 22 - DorisSQLParserRULE_collateDesc = 23 - DorisSQLParserRULE_keyDesc = 24 - DorisSQLParserRULE_orderByDesc = 25 - DorisSQLParserRULE_columnNullable = 26 - DorisSQLParserRULE_typeWithNullable = 27 - DorisSQLParserRULE_aggStateDesc = 28 - DorisSQLParserRULE_aggDesc = 29 - DorisSQLParserRULE_rollupDesc = 30 - DorisSQLParserRULE_rollupItem = 31 - DorisSQLParserRULE_dupKeys = 32 - DorisSQLParserRULE_fromRollup = 33 - DorisSQLParserRULE_orReplace = 34 - DorisSQLParserRULE_ifNotExists = 35 - DorisSQLParserRULE_createTableAsSelectStatement = 36 - DorisSQLParserRULE_dropTableStatement = 37 - DorisSQLParserRULE_cleanTemporaryTableStatement = 38 - DorisSQLParserRULE_alterTableStatement = 39 - DorisSQLParserRULE_createIndexStatement = 40 - DorisSQLParserRULE_dropIndexStatement = 41 - DorisSQLParserRULE_indexType = 42 - DorisSQLParserRULE_showTableStatement = 43 - DorisSQLParserRULE_showTemporaryTablesStatement = 44 - DorisSQLParserRULE_showCreateTableStatement = 45 - DorisSQLParserRULE_showColumnStatement = 46 - DorisSQLParserRULE_showTableStatusStatement = 47 - DorisSQLParserRULE_refreshTableStatement = 48 - DorisSQLParserRULE_showAlterStatement = 49 - DorisSQLParserRULE_descTableStatement = 50 - DorisSQLParserRULE_createTableLikeStatement = 51 - DorisSQLParserRULE_showIndexStatement = 52 - DorisSQLParserRULE_recoverTableStatement = 53 - DorisSQLParserRULE_truncateTableStatement = 54 - DorisSQLParserRULE_cancelAlterTableStatement = 55 - DorisSQLParserRULE_showPartitionsStatement = 56 - DorisSQLParserRULE_recoverPartitionStatement = 57 - DorisSQLParserRULE_createViewStatement = 58 - DorisSQLParserRULE_alterViewStatement = 59 - DorisSQLParserRULE_dropViewStatement = 60 - DorisSQLParserRULE_columnNameWithComment = 61 - DorisSQLParserRULE_submitTaskStatement = 62 - DorisSQLParserRULE_taskClause = 63 - DorisSQLParserRULE_dropTaskStatement = 64 - DorisSQLParserRULE_taskScheduleDesc = 65 - DorisSQLParserRULE_createMaterializedViewStatement = 66 - DorisSQLParserRULE_mvPartitionExprs = 67 - DorisSQLParserRULE_materializedViewDesc = 68 - DorisSQLParserRULE_showMaterializedViewsStatement = 69 - DorisSQLParserRULE_dropMaterializedViewStatement = 70 - DorisSQLParserRULE_alterMaterializedViewStatement = 71 - DorisSQLParserRULE_refreshMaterializedViewStatement = 72 - DorisSQLParserRULE_cancelRefreshMaterializedViewStatement = 73 - DorisSQLParserRULE_adminSetConfigStatement = 74 - DorisSQLParserRULE_adminSetReplicaStatusStatement = 75 - DorisSQLParserRULE_adminShowConfigStatement = 76 - DorisSQLParserRULE_adminShowReplicaDistributionStatement = 77 - DorisSQLParserRULE_adminShowReplicaStatusStatement = 78 - DorisSQLParserRULE_adminRepairTableStatement = 79 - DorisSQLParserRULE_adminCancelRepairTableStatement = 80 - DorisSQLParserRULE_adminCheckTabletsStatement = 81 - DorisSQLParserRULE_adminSetPartitionVersion = 82 - DorisSQLParserRULE_killStatement = 83 - DorisSQLParserRULE_syncStatement = 84 - DorisSQLParserRULE_adminSetAutomatedSnapshotOnStatement = 85 - DorisSQLParserRULE_adminSetAutomatedSnapshotOffStatement = 86 - DorisSQLParserRULE_alterSystemStatement = 87 - DorisSQLParserRULE_cancelAlterSystemStatement = 88 - DorisSQLParserRULE_showComputeNodesStatement = 89 - DorisSQLParserRULE_createExternalCatalogStatement = 90 - DorisSQLParserRULE_showCreateExternalCatalogStatement = 91 - DorisSQLParserRULE_dropExternalCatalogStatement = 92 - DorisSQLParserRULE_showCatalogsStatement = 93 - DorisSQLParserRULE_alterCatalogStatement = 94 - DorisSQLParserRULE_createStorageVolumeStatement = 95 - DorisSQLParserRULE_typeDesc = 96 - DorisSQLParserRULE_locationsDesc = 97 - DorisSQLParserRULE_showStorageVolumesStatement = 98 - DorisSQLParserRULE_dropStorageVolumeStatement = 99 - DorisSQLParserRULE_alterStorageVolumeStatement = 100 - DorisSQLParserRULE_alterStorageVolumeClause = 101 - DorisSQLParserRULE_modifyStorageVolumePropertiesClause = 102 - DorisSQLParserRULE_modifyStorageVolumeCommentClause = 103 - DorisSQLParserRULE_descStorageVolumeStatement = 104 - DorisSQLParserRULE_setDefaultStorageVolumeStatement = 105 - DorisSQLParserRULE_updateFailPointStatusStatement = 106 - DorisSQLParserRULE_showFailPointStatement = 107 - DorisSQLParserRULE_createDictionaryStatement = 108 - DorisSQLParserRULE_dropDictionaryStatement = 109 - DorisSQLParserRULE_refreshDictionaryStatement = 110 - DorisSQLParserRULE_showDictionaryStatement = 111 - DorisSQLParserRULE_cancelRefreshDictionaryStatement = 112 - DorisSQLParserRULE_dictionaryColumnDesc = 113 - DorisSQLParserRULE_dictionaryName = 114 - DorisSQLParserRULE_alterClause = 115 - DorisSQLParserRULE_addFrontendClause = 116 - DorisSQLParserRULE_dropFrontendClause = 117 - DorisSQLParserRULE_modifyFrontendHostClause = 118 - DorisSQLParserRULE_addBackendClause = 119 - DorisSQLParserRULE_dropBackendClause = 120 - DorisSQLParserRULE_decommissionBackendClause = 121 - DorisSQLParserRULE_modifyBackendClause = 122 - DorisSQLParserRULE_addComputeNodeClause = 123 - DorisSQLParserRULE_dropComputeNodeClause = 124 - DorisSQLParserRULE_modifyBrokerClause = 125 - DorisSQLParserRULE_alterLoadErrorUrlClause = 126 - DorisSQLParserRULE_createImageClause = 127 - DorisSQLParserRULE_cleanTabletSchedQClause = 128 - DorisSQLParserRULE_decommissionDiskClause = 129 - DorisSQLParserRULE_cancelDecommissionDiskClause = 130 - DorisSQLParserRULE_disableDiskClause = 131 - DorisSQLParserRULE_cancelDisableDiskClause = 132 - DorisSQLParserRULE_createIndexClause = 133 - DorisSQLParserRULE_dropIndexClause = 134 - DorisSQLParserRULE_tableRenameClause = 135 - DorisSQLParserRULE_swapTableClause = 136 - DorisSQLParserRULE_modifyPropertiesClause = 137 - DorisSQLParserRULE_modifyCommentClause = 138 - DorisSQLParserRULE_optimizeRange = 139 - DorisSQLParserRULE_optimizeClause = 140 - DorisSQLParserRULE_addColumnClause = 141 - DorisSQLParserRULE_addColumnsClause = 142 - DorisSQLParserRULE_dropColumnClause = 143 - DorisSQLParserRULE_modifyColumnClause = 144 - DorisSQLParserRULE_modifyColumnCommentClause = 145 - DorisSQLParserRULE_columnRenameClause = 146 - DorisSQLParserRULE_reorderColumnsClause = 147 - DorisSQLParserRULE_rollupRenameClause = 148 - DorisSQLParserRULE_compactionClause = 149 - DorisSQLParserRULE_subfieldName = 150 - DorisSQLParserRULE_nestedFieldName = 151 - DorisSQLParserRULE_addFieldClause = 152 - DorisSQLParserRULE_dropFieldClause = 153 - DorisSQLParserRULE_createOrReplaceTagClause = 154 - DorisSQLParserRULE_createOrReplaceBranchClause = 155 - DorisSQLParserRULE_dropBranchClause = 156 - DorisSQLParserRULE_dropTagClause = 157 - DorisSQLParserRULE_tableOperationClause = 158 - DorisSQLParserRULE_tagOptions = 159 - DorisSQLParserRULE_branchOptions = 160 - DorisSQLParserRULE_snapshotRetention = 161 - DorisSQLParserRULE_refRetain = 162 - DorisSQLParserRULE_maxSnapshotAge = 163 - DorisSQLParserRULE_minSnapshotsToKeep = 164 - DorisSQLParserRULE_snapshotId = 165 - DorisSQLParserRULE_timeUnit = 166 - DorisSQLParserRULE_integer_list = 167 - DorisSQLParserRULE_dropPersistentIndexClause = 168 - DorisSQLParserRULE_addPartitionClause = 169 - DorisSQLParserRULE_dropPartitionClause = 170 - DorisSQLParserRULE_truncatePartitionClause = 171 - DorisSQLParserRULE_modifyPartitionClause = 172 - DorisSQLParserRULE_replacePartitionClause = 173 - DorisSQLParserRULE_partitionRenameClause = 174 - DorisSQLParserRULE_insertStatement = 175 - DorisSQLParserRULE_insertLabelOrColumnAliases = 176 - DorisSQLParserRULE_columnAliasesOrByName = 177 - DorisSQLParserRULE_updateStatement = 178 - DorisSQLParserRULE_deleteStatement = 179 - DorisSQLParserRULE_createRoutineLoadStatement = 180 - DorisSQLParserRULE_alterRoutineLoadStatement = 181 - DorisSQLParserRULE_dataSource = 182 - DorisSQLParserRULE_loadProperties = 183 - DorisSQLParserRULE_colSeparatorProperty = 184 - DorisSQLParserRULE_rowDelimiterProperty = 185 - DorisSQLParserRULE_importColumns = 186 - DorisSQLParserRULE_columnProperties = 187 - DorisSQLParserRULE_jobProperties = 188 - DorisSQLParserRULE_dataSourceProperties = 189 - DorisSQLParserRULE_stopRoutineLoadStatement = 190 - DorisSQLParserRULE_resumeRoutineLoadStatement = 191 - DorisSQLParserRULE_pauseRoutineLoadStatement = 192 - DorisSQLParserRULE_showRoutineLoadStatement = 193 - DorisSQLParserRULE_showRoutineLoadTaskStatement = 194 - DorisSQLParserRULE_showCreateRoutineLoadStatement = 195 - DorisSQLParserRULE_showStreamLoadStatement = 196 - DorisSQLParserRULE_analyzeStatement = 197 - DorisSQLParserRULE_analyzeColumnClause = 198 - DorisSQLParserRULE_dropStatsStatement = 199 - DorisSQLParserRULE_histogramStatement = 200 - DorisSQLParserRULE_analyzeHistogramStatement = 201 - DorisSQLParserRULE_dropHistogramStatement = 202 - DorisSQLParserRULE_createAnalyzeStatement = 203 - DorisSQLParserRULE_dropAnalyzeJobStatement = 204 - DorisSQLParserRULE_showAnalyzeStatement = 205 - DorisSQLParserRULE_showStatsMetaStatement = 206 - DorisSQLParserRULE_showHistogramMetaStatement = 207 - DorisSQLParserRULE_killAnalyzeStatement = 208 - DorisSQLParserRULE_analyzeProfileStatement = 209 - DorisSQLParserRULE_createBaselinePlanStatement = 210 - DorisSQLParserRULE_dropBaselinePlanStatement = 211 - DorisSQLParserRULE_showBaselinePlanStatement = 212 - DorisSQLParserRULE_createResourceGroupStatement = 213 - DorisSQLParserRULE_dropResourceGroupStatement = 214 - DorisSQLParserRULE_alterResourceGroupStatement = 215 - DorisSQLParserRULE_showResourceGroupStatement = 216 - DorisSQLParserRULE_showResourceGroupUsageStatement = 217 - DorisSQLParserRULE_createResourceStatement = 218 - DorisSQLParserRULE_alterResourceStatement = 219 - DorisSQLParserRULE_dropResourceStatement = 220 - DorisSQLParserRULE_showResourceStatement = 221 - DorisSQLParserRULE_classifier = 222 - DorisSQLParserRULE_showFunctionsStatement = 223 - DorisSQLParserRULE_dropFunctionStatement = 224 - DorisSQLParserRULE_createFunctionStatement = 225 - DorisSQLParserRULE_inlineFunction = 226 - DorisSQLParserRULE_typeList = 227 - DorisSQLParserRULE_loadStatement = 228 - DorisSQLParserRULE_labelName = 229 - DorisSQLParserRULE_dataDescList = 230 - DorisSQLParserRULE_dataDesc = 231 - DorisSQLParserRULE_formatProps = 232 - DorisSQLParserRULE_brokerDesc = 233 - DorisSQLParserRULE_resourceDesc = 234 - DorisSQLParserRULE_showLoadStatement = 235 - DorisSQLParserRULE_showLoadWarningsStatement = 236 - DorisSQLParserRULE_cancelLoadStatement = 237 - DorisSQLParserRULE_alterLoadStatement = 238 - DorisSQLParserRULE_cancelCompactionStatement = 239 - DorisSQLParserRULE_showAuthorStatement = 240 - DorisSQLParserRULE_showBackendsStatement = 241 - DorisSQLParserRULE_showBrokerStatement = 242 - DorisSQLParserRULE_showCharsetStatement = 243 - DorisSQLParserRULE_showCollationStatement = 244 - DorisSQLParserRULE_showDeleteStatement = 245 - DorisSQLParserRULE_showDynamicPartitionStatement = 246 - DorisSQLParserRULE_showEventsStatement = 247 - DorisSQLParserRULE_showEnginesStatement = 248 - DorisSQLParserRULE_showFrontendsStatement = 249 - DorisSQLParserRULE_showFrontendsDisksStatement = 250 - DorisSQLParserRULE_showPluginsStatement = 251 - DorisSQLParserRULE_showRepositoriesStatement = 252 - DorisSQLParserRULE_showOpenTableStatement = 253 - DorisSQLParserRULE_showPrivilegesStatement = 254 - DorisSQLParserRULE_showProcedureStatement = 255 - DorisSQLParserRULE_showProcStatement = 256 - DorisSQLParserRULE_showProcesslistStatement = 257 - DorisSQLParserRULE_showProfilelistStatement = 258 - DorisSQLParserRULE_showRunningQueriesStatement = 259 - DorisSQLParserRULE_showStatusStatement = 260 - DorisSQLParserRULE_showTabletStatement = 261 - DorisSQLParserRULE_showTransactionStatement = 262 - DorisSQLParserRULE_showTriggersStatement = 263 - DorisSQLParserRULE_showUserPropertyStatement = 264 - DorisSQLParserRULE_showVariablesStatement = 265 - DorisSQLParserRULE_showWarningStatement = 266 - DorisSQLParserRULE_helpStatement = 267 - DorisSQLParserRULE_showQueryProfileStatement = 268 - DorisSQLParserRULE_showQueryStatsStatement = 269 - DorisSQLParserRULE_showLoadProfileStatement = 270 - DorisSQLParserRULE_showDataSkewStatement = 271 - DorisSQLParserRULE_showDataTypesStatement = 272 - DorisSQLParserRULE_showSyncJobStatement = 273 - DorisSQLParserRULE_showPolicyStatement = 274 - DorisSQLParserRULE_showSqlBlockRuleStatement = 275 - DorisSQLParserRULE_showEncryptKeysStatement = 276 - DorisSQLParserRULE_showCreateLoadStatement = 277 - DorisSQLParserRULE_showCreateRepositoryStatement = 278 - DorisSQLParserRULE_showLastInsertStatement = 279 - DorisSQLParserRULE_showTableIdStatement = 280 - DorisSQLParserRULE_showDatabaseIdStatement = 281 - DorisSQLParserRULE_showPartitionIdStatement = 282 - DorisSQLParserRULE_showTableStatsStatement = 283 - DorisSQLParserRULE_showColumnStatsStatement = 284 - DorisSQLParserRULE_showConvertLightSchemaChangeStatement = 285 - DorisSQLParserRULE_showCatalogRecycleBinStatement = 286 - DorisSQLParserRULE_showTrashStatement = 287 - DorisSQLParserRULE_showMigrationsStatement = 288 - DorisSQLParserRULE_showWorkloadGroupsStatement = 289 - DorisSQLParserRULE_showJobTaskStatement = 290 - DorisSQLParserRULE_createUserStatement = 291 - DorisSQLParserRULE_dropUserStatement = 292 - DorisSQLParserRULE_alterUserStatement = 293 - DorisSQLParserRULE_showUserStatement = 294 - DorisSQLParserRULE_showAuthenticationStatement = 295 - DorisSQLParserRULE_executeAsStatement = 296 - DorisSQLParserRULE_createRoleStatement = 297 - DorisSQLParserRULE_alterRoleStatement = 298 - DorisSQLParserRULE_dropRoleStatement = 299 - DorisSQLParserRULE_showRolesStatement = 300 - DorisSQLParserRULE_grantRoleStatement = 301 - DorisSQLParserRULE_revokeRoleStatement = 302 - DorisSQLParserRULE_setRoleStatement = 303 - DorisSQLParserRULE_setDefaultRoleStatement = 304 - DorisSQLParserRULE_grantRevokeClause = 305 - DorisSQLParserRULE_grantPrivilegeStatement = 306 - DorisSQLParserRULE_revokePrivilegeStatement = 307 - DorisSQLParserRULE_showGrantsStatement = 308 - DorisSQLParserRULE_authOption = 309 - DorisSQLParserRULE_privObjectName = 310 - DorisSQLParserRULE_privObjectNameList = 311 - DorisSQLParserRULE_privFunctionObjectNameList = 312 - DorisSQLParserRULE_privilegeTypeList = 313 - DorisSQLParserRULE_privilegeType = 314 - DorisSQLParserRULE_privObjectType = 315 - DorisSQLParserRULE_privObjectTypePlural = 316 - DorisSQLParserRULE_createSecurityIntegrationStatement = 317 - DorisSQLParserRULE_alterSecurityIntegrationStatement = 318 - DorisSQLParserRULE_dropSecurityIntegrationStatement = 319 - DorisSQLParserRULE_showSecurityIntegrationStatement = 320 - DorisSQLParserRULE_showCreateSecurityIntegrationStatement = 321 - DorisSQLParserRULE_createGroupProviderStatement = 322 - DorisSQLParserRULE_dropGroupProviderStatement = 323 - DorisSQLParserRULE_showGroupProvidersStatement = 324 - DorisSQLParserRULE_showCreateGroupProviderStatement = 325 - DorisSQLParserRULE_backupStatement = 326 - DorisSQLParserRULE_cancelBackupStatement = 327 - DorisSQLParserRULE_showBackupStatement = 328 - DorisSQLParserRULE_restoreStatement = 329 - DorisSQLParserRULE_cancelRestoreStatement = 330 - DorisSQLParserRULE_showRestoreStatement = 331 - DorisSQLParserRULE_showSnapshotStatement = 332 - DorisSQLParserRULE_createRepositoryStatement = 333 - DorisSQLParserRULE_dropRepositoryStatement = 334 - DorisSQLParserRULE_addSqlBlackListStatement = 335 - DorisSQLParserRULE_delSqlBlackListStatement = 336 - DorisSQLParserRULE_showSqlBlackListStatement = 337 - DorisSQLParserRULE_showWhiteListStatement = 338 - DorisSQLParserRULE_addBackendBlackListStatement = 339 - DorisSQLParserRULE_delBackendBlackListStatement = 340 - DorisSQLParserRULE_showBackendBlackListStatement = 341 - DorisSQLParserRULE_dataCacheTarget = 342 - DorisSQLParserRULE_createDataCacheRuleStatement = 343 - DorisSQLParserRULE_showDataCacheRulesStatement = 344 - DorisSQLParserRULE_dropDataCacheRuleStatement = 345 - DorisSQLParserRULE_clearDataCacheRulesStatement = 346 - DorisSQLParserRULE_dataCacheSelectStatement = 347 - DorisSQLParserRULE_exportStatement = 348 - DorisSQLParserRULE_cancelExportStatement = 349 - DorisSQLParserRULE_showExportStatement = 350 - DorisSQLParserRULE_installPluginStatement = 351 - DorisSQLParserRULE_uninstallPluginStatement = 352 - DorisSQLParserRULE_createFileStatement = 353 - DorisSQLParserRULE_dropFileStatement = 354 - DorisSQLParserRULE_showSmallFilesStatement = 355 - DorisSQLParserRULE_createPipeStatement = 356 - DorisSQLParserRULE_dropPipeStatement = 357 - DorisSQLParserRULE_alterPipeClause = 358 - DorisSQLParserRULE_alterPipeStatement = 359 - DorisSQLParserRULE_descPipeStatement = 360 - DorisSQLParserRULE_showPipeStatement = 361 - DorisSQLParserRULE_setStatement = 362 - DorisSQLParserRULE_setVar = 363 - DorisSQLParserRULE_transaction_characteristics = 364 - DorisSQLParserRULE_transaction_access_mode = 365 - DorisSQLParserRULE_isolation_level = 366 - DorisSQLParserRULE_isolation_types = 367 - DorisSQLParserRULE_setExprOrDefault = 368 - DorisSQLParserRULE_setUserPropertyStatement = 369 - DorisSQLParserRULE_roleList = 370 - DorisSQLParserRULE_executeScriptStatement = 371 - DorisSQLParserRULE_unsupportedStatement = 372 - DorisSQLParserRULE_lock_item = 373 - DorisSQLParserRULE_lock_type = 374 - DorisSQLParserRULE_alterPlanAdvisorAddStatement = 375 - DorisSQLParserRULE_truncatePlanAdvisorStatement = 376 - DorisSQLParserRULE_alterPlanAdvisorDropStatement = 377 - DorisSQLParserRULE_showPlanAdvisorStatement = 378 - DorisSQLParserRULE_createWarehouseStatement = 379 - DorisSQLParserRULE_dropWarehouseStatement = 380 - DorisSQLParserRULE_suspendWarehouseStatement = 381 - DorisSQLParserRULE_resumeWarehouseStatement = 382 - DorisSQLParserRULE_setWarehouseStatement = 383 - DorisSQLParserRULE_showWarehousesStatement = 384 - DorisSQLParserRULE_showClustersStatement = 385 - DorisSQLParserRULE_showNodesStatement = 386 - DorisSQLParserRULE_alterWarehouseStatement = 387 - DorisSQLParserRULE_createCNGroupStatement = 388 - DorisSQLParserRULE_dropCNGroupStatement = 389 - DorisSQLParserRULE_enableCNGroupStatement = 390 - DorisSQLParserRULE_disableCNGroupStatement = 391 - DorisSQLParserRULE_alterCNGroupStatement = 392 - DorisSQLParserRULE_beginStatement = 393 - DorisSQLParserRULE_commitStatement = 394 - DorisSQLParserRULE_rollbackStatement = 395 - DorisSQLParserRULE_translateStatement = 396 - DorisSQLParserRULE_dialect = 397 - DorisSQLParserRULE_translateSQL = 398 - DorisSQLParserRULE_queryStatement = 399 - DorisSQLParserRULE_queryRelation = 400 - DorisSQLParserRULE_withClause = 401 - DorisSQLParserRULE_queryNoWith = 402 - DorisSQLParserRULE_queryPeriod = 403 - DorisSQLParserRULE_periodType = 404 - DorisSQLParserRULE_queryPrimary = 405 - DorisSQLParserRULE_subquery = 406 - DorisSQLParserRULE_rowConstructor = 407 - DorisSQLParserRULE_sortItem = 408 - DorisSQLParserRULE_limitConstExpr = 409 - DorisSQLParserRULE_limitElement = 410 - DorisSQLParserRULE_querySpecification = 411 - DorisSQLParserRULE_fromClause = 412 - DorisSQLParserRULE_groupingElement = 413 - DorisSQLParserRULE_groupingSet = 414 - DorisSQLParserRULE_commonTableExpression = 415 - DorisSQLParserRULE_setQuantifier = 416 - DorisSQLParserRULE_selectItem = 417 - DorisSQLParserRULE_excludeClause = 418 - DorisSQLParserRULE_relations = 419 - DorisSQLParserRULE_relationLateralView = 420 - DorisSQLParserRULE_lateralView = 421 - DorisSQLParserRULE_generatorFunction = 422 - DorisSQLParserRULE_relation = 423 - DorisSQLParserRULE_relationPrimary = 424 - DorisSQLParserRULE_pivotClause = 425 - DorisSQLParserRULE_pivotAggregationExpression = 426 - DorisSQLParserRULE_pivotValue = 427 - DorisSQLParserRULE_sampleClause = 428 - DorisSQLParserRULE_argumentList = 429 - DorisSQLParserRULE_namedArgumentList = 430 - DorisSQLParserRULE_namedArgument = 431 - DorisSQLParserRULE_joinRelation = 432 - DorisSQLParserRULE_crossOrInnerJoinType = 433 - DorisSQLParserRULE_outerAndSemiJoinType = 434 - DorisSQLParserRULE_bracketHint = 435 - DorisSQLParserRULE_hintMap = 436 - DorisSQLParserRULE_joinCriteria = 437 - DorisSQLParserRULE_columnAliases = 438 - DorisSQLParserRULE_columnAliasesWithoutParentheses = 439 - DorisSQLParserRULE_partitionNames = 440 - DorisSQLParserRULE_keyPartitions = 441 - DorisSQLParserRULE_tabletList = 442 - DorisSQLParserRULE_prepareStatement = 443 - DorisSQLParserRULE_prepareSql = 444 - DorisSQLParserRULE_executeStatement = 445 - DorisSQLParserRULE_deallocateStatement = 446 - DorisSQLParserRULE_replicaList = 447 - DorisSQLParserRULE_expressionsWithDefault = 448 - DorisSQLParserRULE_expressionOrDefault = 449 - DorisSQLParserRULE_mapExpressionList = 450 - DorisSQLParserRULE_mapExpression = 451 - DorisSQLParserRULE_expressionSingleton = 452 - DorisSQLParserRULE_expression = 453 - DorisSQLParserRULE_expressionList = 454 - DorisSQLParserRULE_booleanExpression = 455 - DorisSQLParserRULE_predicate = 456 - DorisSQLParserRULE_tupleInSubquery = 457 - DorisSQLParserRULE_predicateOperations = 458 - DorisSQLParserRULE_valueExpression = 459 - DorisSQLParserRULE_primaryExpression = 460 - DorisSQLParserRULE_literalExpression = 461 - DorisSQLParserRULE_functionCall = 462 - DorisSQLParserRULE_aggregationFunction = 463 - DorisSQLParserRULE_userVariable = 464 - DorisSQLParserRULE_systemVariable = 465 - DorisSQLParserRULE_columnReference = 466 - DorisSQLParserRULE_informationFunctionExpression = 467 - DorisSQLParserRULE_specialDateTimeExpression = 468 - DorisSQLParserRULE_specialFunctionExpression = 469 - DorisSQLParserRULE_windowFunction = 470 - DorisSQLParserRULE_whenClause = 471 - DorisSQLParserRULE_over = 472 - DorisSQLParserRULE_ignoreNulls = 473 - DorisSQLParserRULE_windowFrame = 474 - DorisSQLParserRULE_frameBound = 475 - DorisSQLParserRULE_backupRestoreObjectDesc = 476 - DorisSQLParserRULE_tableDesc = 477 - DorisSQLParserRULE_backupRestoreTableDesc = 478 - DorisSQLParserRULE_explainDesc = 479 - DorisSQLParserRULE_optimizerTrace = 480 - DorisSQLParserRULE_partitionExpr = 481 - DorisSQLParserRULE_partitionDesc = 482 - DorisSQLParserRULE_listPartitionDesc = 483 - DorisSQLParserRULE_singleItemListPartitionDesc = 484 - DorisSQLParserRULE_multiItemListPartitionDesc = 485 - DorisSQLParserRULE_multiListPartitionValues = 486 - DorisSQLParserRULE_singleListPartitionValues = 487 - DorisSQLParserRULE_listPartitionValues = 488 - DorisSQLParserRULE_listPartitionValue = 489 - DorisSQLParserRULE_stringList = 490 - DorisSQLParserRULE_literalExpressionList = 491 - DorisSQLParserRULE_rangePartitionDesc = 492 - DorisSQLParserRULE_singleRangePartition = 493 - DorisSQLParserRULE_multiRangePartition = 494 - DorisSQLParserRULE_partitionRangeDesc = 495 - DorisSQLParserRULE_partitionKeyDesc = 496 - DorisSQLParserRULE_partitionValueList = 497 - DorisSQLParserRULE_keyPartition = 498 - DorisSQLParserRULE_partitionValue = 499 - DorisSQLParserRULE_distributionClause = 500 - DorisSQLParserRULE_distributionDesc = 501 - DorisSQLParserRULE_refreshSchemeDesc = 502 - DorisSQLParserRULE_statusDesc = 503 - DorisSQLParserRULE_properties = 504 - DorisSQLParserRULE_extProperties = 505 - DorisSQLParserRULE_propertyList = 506 - DorisSQLParserRULE_userPropertyList = 507 - DorisSQLParserRULE_property = 508 - DorisSQLParserRULE_inlineProperties = 509 - DorisSQLParserRULE_inlineProperty = 510 - DorisSQLParserRULE_varType = 511 - DorisSQLParserRULE_comment = 512 - DorisSQLParserRULE_outfile = 513 - DorisSQLParserRULE_fileFormat = 514 - DorisSQLParserRULE_string = 515 - DorisSQLParserRULE_binary = 516 - DorisSQLParserRULE_comparisonOperator = 517 - DorisSQLParserRULE_booleanValue = 518 - DorisSQLParserRULE_interval = 519 - DorisSQLParserRULE_taskInterval = 520 - DorisSQLParserRULE_taskUnitIdentifier = 521 - DorisSQLParserRULE_unitIdentifier = 522 - DorisSQLParserRULE_unitBoundary = 523 - DorisSQLParserRULE_type = 524 - DorisSQLParserRULE_arrayType = 525 - DorisSQLParserRULE_mapType = 526 - DorisSQLParserRULE_subfieldDesc = 527 - DorisSQLParserRULE_subfieldDescs = 528 - DorisSQLParserRULE_structType = 529 - DorisSQLParserRULE_typeParameter = 530 - DorisSQLParserRULE_baseType = 531 - DorisSQLParserRULE_decimalType = 532 - DorisSQLParserRULE_qualifiedName = 533 - DorisSQLParserRULE_tableName = 534 - DorisSQLParserRULE_writeBranch = 535 - DorisSQLParserRULE_identifier = 536 - DorisSQLParserRULE_identifierWithAlias = 537 - DorisSQLParserRULE_identifierWithAliasList = 538 - DorisSQLParserRULE_identifierList = 539 - DorisSQLParserRULE_identifierOrString = 540 - DorisSQLParserRULE_identifierOrStringList = 541 - DorisSQLParserRULE_identifierOrStringOrStar = 542 - DorisSQLParserRULE_user = 543 - DorisSQLParserRULE_assignment = 544 - DorisSQLParserRULE_assignmentList = 545 - DorisSQLParserRULE_number = 546 - DorisSQLParserRULE_nonReserved = 547 + StarRocksSQLParserRULE_sqlStatements = 0 + StarRocksSQLParserRULE_singleStatement = 1 + StarRocksSQLParserRULE_statement = 2 + StarRocksSQLParserRULE_useDatabaseStatement = 3 + StarRocksSQLParserRULE_useCatalogStatement = 4 + StarRocksSQLParserRULE_setCatalogStatement = 5 + StarRocksSQLParserRULE_showDatabasesStatement = 6 + StarRocksSQLParserRULE_alterDbQuotaStatement = 7 + StarRocksSQLParserRULE_createDbStatement = 8 + StarRocksSQLParserRULE_dropDbStatement = 9 + StarRocksSQLParserRULE_showCreateDbStatement = 10 + StarRocksSQLParserRULE_alterDatabaseRenameStatement = 11 + StarRocksSQLParserRULE_recoverDbStmt = 12 + StarRocksSQLParserRULE_showDataStmt = 13 + StarRocksSQLParserRULE_showDataDistributionStmt = 14 + StarRocksSQLParserRULE_createTableStatement = 15 + StarRocksSQLParserRULE_columnDesc = 16 + StarRocksSQLParserRULE_charsetName = 17 + StarRocksSQLParserRULE_defaultDesc = 18 + StarRocksSQLParserRULE_generatedColumnDesc = 19 + StarRocksSQLParserRULE_indexDesc = 20 + StarRocksSQLParserRULE_engineDesc = 21 + StarRocksSQLParserRULE_charsetDesc = 22 + StarRocksSQLParserRULE_collateDesc = 23 + StarRocksSQLParserRULE_keyDesc = 24 + StarRocksSQLParserRULE_orderByDesc = 25 + StarRocksSQLParserRULE_columnNullable = 26 + StarRocksSQLParserRULE_typeWithNullable = 27 + StarRocksSQLParserRULE_aggStateDesc = 28 + StarRocksSQLParserRULE_aggDesc = 29 + StarRocksSQLParserRULE_rollupDesc = 30 + StarRocksSQLParserRULE_rollupItem = 31 + StarRocksSQLParserRULE_dupKeys = 32 + StarRocksSQLParserRULE_fromRollup = 33 + StarRocksSQLParserRULE_orReplace = 34 + StarRocksSQLParserRULE_ifNotExists = 35 + StarRocksSQLParserRULE_createTableAsSelectStatement = 36 + StarRocksSQLParserRULE_dropTableStatement = 37 + StarRocksSQLParserRULE_cleanTemporaryTableStatement = 38 + StarRocksSQLParserRULE_alterTableStatement = 39 + StarRocksSQLParserRULE_createIndexStatement = 40 + StarRocksSQLParserRULE_dropIndexStatement = 41 + StarRocksSQLParserRULE_indexType = 42 + StarRocksSQLParserRULE_showTableStatement = 43 + StarRocksSQLParserRULE_showTemporaryTablesStatement = 44 + StarRocksSQLParserRULE_showCreateTableStatement = 45 + StarRocksSQLParserRULE_showColumnStatement = 46 + StarRocksSQLParserRULE_showTableStatusStatement = 47 + StarRocksSQLParserRULE_refreshTableStatement = 48 + StarRocksSQLParserRULE_showAlterStatement = 49 + StarRocksSQLParserRULE_descTableStatement = 50 + StarRocksSQLParserRULE_createTableLikeStatement = 51 + StarRocksSQLParserRULE_showIndexStatement = 52 + StarRocksSQLParserRULE_recoverTableStatement = 53 + StarRocksSQLParserRULE_truncateTableStatement = 54 + StarRocksSQLParserRULE_cancelAlterTableStatement = 55 + StarRocksSQLParserRULE_showPartitionsStatement = 56 + StarRocksSQLParserRULE_recoverPartitionStatement = 57 + StarRocksSQLParserRULE_createViewStatement = 58 + StarRocksSQLParserRULE_alterViewStatement = 59 + StarRocksSQLParserRULE_dropViewStatement = 60 + StarRocksSQLParserRULE_columnNameWithComment = 61 + StarRocksSQLParserRULE_submitTaskStatement = 62 + StarRocksSQLParserRULE_taskClause = 63 + StarRocksSQLParserRULE_dropTaskStatement = 64 + StarRocksSQLParserRULE_taskScheduleDesc = 65 + StarRocksSQLParserRULE_createMaterializedViewStatement = 66 + StarRocksSQLParserRULE_mvPartitionExprs = 67 + StarRocksSQLParserRULE_materializedViewDesc = 68 + StarRocksSQLParserRULE_showMaterializedViewsStatement = 69 + StarRocksSQLParserRULE_dropMaterializedViewStatement = 70 + StarRocksSQLParserRULE_alterMaterializedViewStatement = 71 + StarRocksSQLParserRULE_refreshMaterializedViewStatement = 72 + StarRocksSQLParserRULE_cancelRefreshMaterializedViewStatement = 73 + StarRocksSQLParserRULE_adminSetConfigStatement = 74 + StarRocksSQLParserRULE_adminSetReplicaStatusStatement = 75 + StarRocksSQLParserRULE_adminShowConfigStatement = 76 + StarRocksSQLParserRULE_adminShowReplicaDistributionStatement = 77 + StarRocksSQLParserRULE_adminShowReplicaStatusStatement = 78 + StarRocksSQLParserRULE_adminRepairTableStatement = 79 + StarRocksSQLParserRULE_adminCancelRepairTableStatement = 80 + StarRocksSQLParserRULE_adminCheckTabletsStatement = 81 + StarRocksSQLParserRULE_adminSetPartitionVersion = 82 + StarRocksSQLParserRULE_killStatement = 83 + StarRocksSQLParserRULE_syncStatement = 84 + StarRocksSQLParserRULE_adminSetAutomatedSnapshotOnStatement = 85 + StarRocksSQLParserRULE_adminSetAutomatedSnapshotOffStatement = 86 + StarRocksSQLParserRULE_alterSystemStatement = 87 + StarRocksSQLParserRULE_cancelAlterSystemStatement = 88 + StarRocksSQLParserRULE_showComputeNodesStatement = 89 + StarRocksSQLParserRULE_createExternalCatalogStatement = 90 + StarRocksSQLParserRULE_showCreateExternalCatalogStatement = 91 + StarRocksSQLParserRULE_dropExternalCatalogStatement = 92 + StarRocksSQLParserRULE_showCatalogsStatement = 93 + StarRocksSQLParserRULE_alterCatalogStatement = 94 + StarRocksSQLParserRULE_createStorageVolumeStatement = 95 + StarRocksSQLParserRULE_typeDesc = 96 + StarRocksSQLParserRULE_locationsDesc = 97 + StarRocksSQLParserRULE_showStorageVolumesStatement = 98 + StarRocksSQLParserRULE_dropStorageVolumeStatement = 99 + StarRocksSQLParserRULE_alterStorageVolumeStatement = 100 + StarRocksSQLParserRULE_alterStorageVolumeClause = 101 + StarRocksSQLParserRULE_modifyStorageVolumePropertiesClause = 102 + StarRocksSQLParserRULE_modifyStorageVolumeCommentClause = 103 + StarRocksSQLParserRULE_descStorageVolumeStatement = 104 + StarRocksSQLParserRULE_setDefaultStorageVolumeStatement = 105 + StarRocksSQLParserRULE_updateFailPointStatusStatement = 106 + StarRocksSQLParserRULE_showFailPointStatement = 107 + StarRocksSQLParserRULE_createDictionaryStatement = 108 + StarRocksSQLParserRULE_dropDictionaryStatement = 109 + StarRocksSQLParserRULE_refreshDictionaryStatement = 110 + StarRocksSQLParserRULE_showDictionaryStatement = 111 + StarRocksSQLParserRULE_cancelRefreshDictionaryStatement = 112 + StarRocksSQLParserRULE_dictionaryColumnDesc = 113 + StarRocksSQLParserRULE_dictionaryName = 114 + StarRocksSQLParserRULE_alterClause = 115 + StarRocksSQLParserRULE_addFrontendClause = 116 + StarRocksSQLParserRULE_dropFrontendClause = 117 + StarRocksSQLParserRULE_modifyFrontendHostClause = 118 + StarRocksSQLParserRULE_addBackendClause = 119 + StarRocksSQLParserRULE_dropBackendClause = 120 + StarRocksSQLParserRULE_decommissionBackendClause = 121 + StarRocksSQLParserRULE_modifyBackendClause = 122 + StarRocksSQLParserRULE_addComputeNodeClause = 123 + StarRocksSQLParserRULE_dropComputeNodeClause = 124 + StarRocksSQLParserRULE_modifyBrokerClause = 125 + StarRocksSQLParserRULE_alterLoadErrorUrlClause = 126 + StarRocksSQLParserRULE_createImageClause = 127 + StarRocksSQLParserRULE_cleanTabletSchedQClause = 128 + StarRocksSQLParserRULE_decommissionDiskClause = 129 + StarRocksSQLParserRULE_cancelDecommissionDiskClause = 130 + StarRocksSQLParserRULE_disableDiskClause = 131 + StarRocksSQLParserRULE_cancelDisableDiskClause = 132 + StarRocksSQLParserRULE_createIndexClause = 133 + StarRocksSQLParserRULE_dropIndexClause = 134 + StarRocksSQLParserRULE_tableRenameClause = 135 + StarRocksSQLParserRULE_swapTableClause = 136 + StarRocksSQLParserRULE_modifyPropertiesClause = 137 + StarRocksSQLParserRULE_modifyCommentClause = 138 + StarRocksSQLParserRULE_optimizeRange = 139 + StarRocksSQLParserRULE_optimizeClause = 140 + StarRocksSQLParserRULE_addColumnClause = 141 + StarRocksSQLParserRULE_addColumnsClause = 142 + StarRocksSQLParserRULE_dropColumnClause = 143 + StarRocksSQLParserRULE_modifyColumnClause = 144 + StarRocksSQLParserRULE_modifyColumnCommentClause = 145 + StarRocksSQLParserRULE_columnRenameClause = 146 + StarRocksSQLParserRULE_reorderColumnsClause = 147 + StarRocksSQLParserRULE_rollupRenameClause = 148 + StarRocksSQLParserRULE_compactionClause = 149 + StarRocksSQLParserRULE_subfieldName = 150 + StarRocksSQLParserRULE_nestedFieldName = 151 + StarRocksSQLParserRULE_addFieldClause = 152 + StarRocksSQLParserRULE_dropFieldClause = 153 + StarRocksSQLParserRULE_createOrReplaceTagClause = 154 + StarRocksSQLParserRULE_createOrReplaceBranchClause = 155 + StarRocksSQLParserRULE_dropBranchClause = 156 + StarRocksSQLParserRULE_dropTagClause = 157 + StarRocksSQLParserRULE_tableOperationClause = 158 + StarRocksSQLParserRULE_tagOptions = 159 + StarRocksSQLParserRULE_branchOptions = 160 + StarRocksSQLParserRULE_snapshotRetention = 161 + StarRocksSQLParserRULE_refRetain = 162 + StarRocksSQLParserRULE_maxSnapshotAge = 163 + StarRocksSQLParserRULE_minSnapshotsToKeep = 164 + StarRocksSQLParserRULE_snapshotId = 165 + StarRocksSQLParserRULE_timeUnit = 166 + StarRocksSQLParserRULE_integer_list = 167 + StarRocksSQLParserRULE_dropPersistentIndexClause = 168 + StarRocksSQLParserRULE_addPartitionClause = 169 + StarRocksSQLParserRULE_dropPartitionClause = 170 + StarRocksSQLParserRULE_truncatePartitionClause = 171 + StarRocksSQLParserRULE_modifyPartitionClause = 172 + StarRocksSQLParserRULE_replacePartitionClause = 173 + StarRocksSQLParserRULE_partitionRenameClause = 174 + StarRocksSQLParserRULE_insertStatement = 175 + StarRocksSQLParserRULE_insertLabelOrColumnAliases = 176 + StarRocksSQLParserRULE_columnAliasesOrByName = 177 + StarRocksSQLParserRULE_updateStatement = 178 + StarRocksSQLParserRULE_deleteStatement = 179 + StarRocksSQLParserRULE_createRoutineLoadStatement = 180 + StarRocksSQLParserRULE_alterRoutineLoadStatement = 181 + StarRocksSQLParserRULE_dataSource = 182 + StarRocksSQLParserRULE_loadProperties = 183 + StarRocksSQLParserRULE_colSeparatorProperty = 184 + StarRocksSQLParserRULE_rowDelimiterProperty = 185 + StarRocksSQLParserRULE_importColumns = 186 + StarRocksSQLParserRULE_columnProperties = 187 + StarRocksSQLParserRULE_jobProperties = 188 + StarRocksSQLParserRULE_dataSourceProperties = 189 + StarRocksSQLParserRULE_stopRoutineLoadStatement = 190 + StarRocksSQLParserRULE_resumeRoutineLoadStatement = 191 + StarRocksSQLParserRULE_pauseRoutineLoadStatement = 192 + StarRocksSQLParserRULE_showRoutineLoadStatement = 193 + StarRocksSQLParserRULE_showRoutineLoadTaskStatement = 194 + StarRocksSQLParserRULE_showCreateRoutineLoadStatement = 195 + StarRocksSQLParserRULE_showStreamLoadStatement = 196 + StarRocksSQLParserRULE_analyzeStatement = 197 + StarRocksSQLParserRULE_analyzeColumnClause = 198 + StarRocksSQLParserRULE_dropStatsStatement = 199 + StarRocksSQLParserRULE_histogramStatement = 200 + StarRocksSQLParserRULE_analyzeHistogramStatement = 201 + StarRocksSQLParserRULE_dropHistogramStatement = 202 + StarRocksSQLParserRULE_createAnalyzeStatement = 203 + StarRocksSQLParserRULE_dropAnalyzeJobStatement = 204 + StarRocksSQLParserRULE_showAnalyzeStatement = 205 + StarRocksSQLParserRULE_showStatsMetaStatement = 206 + StarRocksSQLParserRULE_showHistogramMetaStatement = 207 + StarRocksSQLParserRULE_killAnalyzeStatement = 208 + StarRocksSQLParserRULE_analyzeProfileStatement = 209 + StarRocksSQLParserRULE_createBaselinePlanStatement = 210 + StarRocksSQLParserRULE_dropBaselinePlanStatement = 211 + StarRocksSQLParserRULE_showBaselinePlanStatement = 212 + StarRocksSQLParserRULE_createResourceGroupStatement = 213 + StarRocksSQLParserRULE_dropResourceGroupStatement = 214 + StarRocksSQLParserRULE_alterResourceGroupStatement = 215 + StarRocksSQLParserRULE_showResourceGroupStatement = 216 + StarRocksSQLParserRULE_showResourceGroupUsageStatement = 217 + StarRocksSQLParserRULE_createResourceStatement = 218 + StarRocksSQLParserRULE_alterResourceStatement = 219 + StarRocksSQLParserRULE_dropResourceStatement = 220 + StarRocksSQLParserRULE_showResourceStatement = 221 + StarRocksSQLParserRULE_classifier = 222 + StarRocksSQLParserRULE_showFunctionsStatement = 223 + StarRocksSQLParserRULE_dropFunctionStatement = 224 + StarRocksSQLParserRULE_createFunctionStatement = 225 + StarRocksSQLParserRULE_inlineFunction = 226 + StarRocksSQLParserRULE_typeList = 227 + StarRocksSQLParserRULE_loadStatement = 228 + StarRocksSQLParserRULE_labelName = 229 + StarRocksSQLParserRULE_dataDescList = 230 + StarRocksSQLParserRULE_dataDesc = 231 + StarRocksSQLParserRULE_formatProps = 232 + StarRocksSQLParserRULE_brokerDesc = 233 + StarRocksSQLParserRULE_resourceDesc = 234 + StarRocksSQLParserRULE_showLoadStatement = 235 + StarRocksSQLParserRULE_showLoadWarningsStatement = 236 + StarRocksSQLParserRULE_cancelLoadStatement = 237 + StarRocksSQLParserRULE_alterLoadStatement = 238 + StarRocksSQLParserRULE_cancelCompactionStatement = 239 + StarRocksSQLParserRULE_showAuthorStatement = 240 + StarRocksSQLParserRULE_showBackendsStatement = 241 + StarRocksSQLParserRULE_showBrokerStatement = 242 + StarRocksSQLParserRULE_showCharsetStatement = 243 + StarRocksSQLParserRULE_showCollationStatement = 244 + StarRocksSQLParserRULE_showDeleteStatement = 245 + StarRocksSQLParserRULE_showDynamicPartitionStatement = 246 + StarRocksSQLParserRULE_showEventsStatement = 247 + StarRocksSQLParserRULE_showEnginesStatement = 248 + StarRocksSQLParserRULE_showFrontendsStatement = 249 + StarRocksSQLParserRULE_showFrontendsDisksStatement = 250 + StarRocksSQLParserRULE_showPluginsStatement = 251 + StarRocksSQLParserRULE_showRepositoriesStatement = 252 + StarRocksSQLParserRULE_showOpenTableStatement = 253 + StarRocksSQLParserRULE_showPrivilegesStatement = 254 + StarRocksSQLParserRULE_showProcedureStatement = 255 + StarRocksSQLParserRULE_showProcStatement = 256 + StarRocksSQLParserRULE_showProcesslistStatement = 257 + StarRocksSQLParserRULE_showProfilelistStatement = 258 + StarRocksSQLParserRULE_showRunningQueriesStatement = 259 + StarRocksSQLParserRULE_showStatusStatement = 260 + StarRocksSQLParserRULE_showTabletStatement = 261 + StarRocksSQLParserRULE_showTransactionStatement = 262 + StarRocksSQLParserRULE_showTriggersStatement = 263 + StarRocksSQLParserRULE_showUserPropertyStatement = 264 + StarRocksSQLParserRULE_showVariablesStatement = 265 + StarRocksSQLParserRULE_showWarningStatement = 266 + StarRocksSQLParserRULE_helpStatement = 267 + StarRocksSQLParserRULE_showQueryProfileStatement = 268 + StarRocksSQLParserRULE_showQueryStatsStatement = 269 + StarRocksSQLParserRULE_showLoadProfileStatement = 270 + StarRocksSQLParserRULE_showDataSkewStatement = 271 + StarRocksSQLParserRULE_showDataTypesStatement = 272 + StarRocksSQLParserRULE_showSyncJobStatement = 273 + StarRocksSQLParserRULE_showPolicyStatement = 274 + StarRocksSQLParserRULE_showSqlBlockRuleStatement = 275 + StarRocksSQLParserRULE_showEncryptKeysStatement = 276 + StarRocksSQLParserRULE_showCreateLoadStatement = 277 + StarRocksSQLParserRULE_showCreateRepositoryStatement = 278 + StarRocksSQLParserRULE_showLastInsertStatement = 279 + StarRocksSQLParserRULE_showTableIdStatement = 280 + StarRocksSQLParserRULE_showDatabaseIdStatement = 281 + StarRocksSQLParserRULE_showPartitionIdStatement = 282 + StarRocksSQLParserRULE_showTableStatsStatement = 283 + StarRocksSQLParserRULE_showColumnStatsStatement = 284 + StarRocksSQLParserRULE_showConvertLightSchemaChangeStatement = 285 + StarRocksSQLParserRULE_showCatalogRecycleBinStatement = 286 + StarRocksSQLParserRULE_showTrashStatement = 287 + StarRocksSQLParserRULE_showMigrationsStatement = 288 + StarRocksSQLParserRULE_showWorkloadGroupsStatement = 289 + StarRocksSQLParserRULE_showJobTaskStatement = 290 + StarRocksSQLParserRULE_createUserStatement = 291 + StarRocksSQLParserRULE_dropUserStatement = 292 + StarRocksSQLParserRULE_alterUserStatement = 293 + StarRocksSQLParserRULE_showUserStatement = 294 + StarRocksSQLParserRULE_showAuthenticationStatement = 295 + StarRocksSQLParserRULE_executeAsStatement = 296 + StarRocksSQLParserRULE_createRoleStatement = 297 + StarRocksSQLParserRULE_alterRoleStatement = 298 + StarRocksSQLParserRULE_dropRoleStatement = 299 + StarRocksSQLParserRULE_showRolesStatement = 300 + StarRocksSQLParserRULE_grantRoleStatement = 301 + StarRocksSQLParserRULE_revokeRoleStatement = 302 + StarRocksSQLParserRULE_setRoleStatement = 303 + StarRocksSQLParserRULE_setDefaultRoleStatement = 304 + StarRocksSQLParserRULE_grantRevokeClause = 305 + StarRocksSQLParserRULE_grantPrivilegeStatement = 306 + StarRocksSQLParserRULE_revokePrivilegeStatement = 307 + StarRocksSQLParserRULE_showGrantsStatement = 308 + StarRocksSQLParserRULE_authOption = 309 + StarRocksSQLParserRULE_privObjectName = 310 + StarRocksSQLParserRULE_privObjectNameList = 311 + StarRocksSQLParserRULE_privFunctionObjectNameList = 312 + StarRocksSQLParserRULE_privilegeTypeList = 313 + StarRocksSQLParserRULE_privilegeType = 314 + StarRocksSQLParserRULE_privObjectType = 315 + StarRocksSQLParserRULE_privObjectTypePlural = 316 + StarRocksSQLParserRULE_createSecurityIntegrationStatement = 317 + StarRocksSQLParserRULE_alterSecurityIntegrationStatement = 318 + StarRocksSQLParserRULE_dropSecurityIntegrationStatement = 319 + StarRocksSQLParserRULE_showSecurityIntegrationStatement = 320 + StarRocksSQLParserRULE_showCreateSecurityIntegrationStatement = 321 + StarRocksSQLParserRULE_createGroupProviderStatement = 322 + StarRocksSQLParserRULE_dropGroupProviderStatement = 323 + StarRocksSQLParserRULE_showGroupProvidersStatement = 324 + StarRocksSQLParserRULE_showCreateGroupProviderStatement = 325 + StarRocksSQLParserRULE_backupStatement = 326 + StarRocksSQLParserRULE_cancelBackupStatement = 327 + StarRocksSQLParserRULE_showBackupStatement = 328 + StarRocksSQLParserRULE_restoreStatement = 329 + StarRocksSQLParserRULE_cancelRestoreStatement = 330 + StarRocksSQLParserRULE_showRestoreStatement = 331 + StarRocksSQLParserRULE_showSnapshotStatement = 332 + StarRocksSQLParserRULE_createRepositoryStatement = 333 + StarRocksSQLParserRULE_dropRepositoryStatement = 334 + StarRocksSQLParserRULE_addSqlBlackListStatement = 335 + StarRocksSQLParserRULE_delSqlBlackListStatement = 336 + StarRocksSQLParserRULE_showSqlBlackListStatement = 337 + StarRocksSQLParserRULE_showWhiteListStatement = 338 + StarRocksSQLParserRULE_addBackendBlackListStatement = 339 + StarRocksSQLParserRULE_delBackendBlackListStatement = 340 + StarRocksSQLParserRULE_showBackendBlackListStatement = 341 + StarRocksSQLParserRULE_dataCacheTarget = 342 + StarRocksSQLParserRULE_createDataCacheRuleStatement = 343 + StarRocksSQLParserRULE_showDataCacheRulesStatement = 344 + StarRocksSQLParserRULE_dropDataCacheRuleStatement = 345 + StarRocksSQLParserRULE_clearDataCacheRulesStatement = 346 + StarRocksSQLParserRULE_dataCacheSelectStatement = 347 + StarRocksSQLParserRULE_exportStatement = 348 + StarRocksSQLParserRULE_cancelExportStatement = 349 + StarRocksSQLParserRULE_showExportStatement = 350 + StarRocksSQLParserRULE_installPluginStatement = 351 + StarRocksSQLParserRULE_uninstallPluginStatement = 352 + StarRocksSQLParserRULE_createFileStatement = 353 + StarRocksSQLParserRULE_dropFileStatement = 354 + StarRocksSQLParserRULE_showSmallFilesStatement = 355 + StarRocksSQLParserRULE_createPipeStatement = 356 + StarRocksSQLParserRULE_dropPipeStatement = 357 + StarRocksSQLParserRULE_alterPipeClause = 358 + StarRocksSQLParserRULE_alterPipeStatement = 359 + StarRocksSQLParserRULE_descPipeStatement = 360 + StarRocksSQLParserRULE_showPipeStatement = 361 + StarRocksSQLParserRULE_setStatement = 362 + StarRocksSQLParserRULE_setVar = 363 + StarRocksSQLParserRULE_transaction_characteristics = 364 + StarRocksSQLParserRULE_transaction_access_mode = 365 + StarRocksSQLParserRULE_isolation_level = 366 + StarRocksSQLParserRULE_isolation_types = 367 + StarRocksSQLParserRULE_setExprOrDefault = 368 + StarRocksSQLParserRULE_setUserPropertyStatement = 369 + StarRocksSQLParserRULE_roleList = 370 + StarRocksSQLParserRULE_executeScriptStatement = 371 + StarRocksSQLParserRULE_unsupportedStatement = 372 + StarRocksSQLParserRULE_lock_item = 373 + StarRocksSQLParserRULE_lock_type = 374 + StarRocksSQLParserRULE_alterPlanAdvisorAddStatement = 375 + StarRocksSQLParserRULE_truncatePlanAdvisorStatement = 376 + StarRocksSQLParserRULE_alterPlanAdvisorDropStatement = 377 + StarRocksSQLParserRULE_showPlanAdvisorStatement = 378 + StarRocksSQLParserRULE_createWarehouseStatement = 379 + StarRocksSQLParserRULE_dropWarehouseStatement = 380 + StarRocksSQLParserRULE_suspendWarehouseStatement = 381 + StarRocksSQLParserRULE_resumeWarehouseStatement = 382 + StarRocksSQLParserRULE_setWarehouseStatement = 383 + StarRocksSQLParserRULE_showWarehousesStatement = 384 + StarRocksSQLParserRULE_showClustersStatement = 385 + StarRocksSQLParserRULE_showNodesStatement = 386 + StarRocksSQLParserRULE_alterWarehouseStatement = 387 + StarRocksSQLParserRULE_createCNGroupStatement = 388 + StarRocksSQLParserRULE_dropCNGroupStatement = 389 + StarRocksSQLParserRULE_enableCNGroupStatement = 390 + StarRocksSQLParserRULE_disableCNGroupStatement = 391 + StarRocksSQLParserRULE_alterCNGroupStatement = 392 + StarRocksSQLParserRULE_beginStatement = 393 + StarRocksSQLParserRULE_commitStatement = 394 + StarRocksSQLParserRULE_rollbackStatement = 395 + StarRocksSQLParserRULE_translateStatement = 396 + StarRocksSQLParserRULE_dialect = 397 + StarRocksSQLParserRULE_translateSQL = 398 + StarRocksSQLParserRULE_queryStatement = 399 + StarRocksSQLParserRULE_queryRelation = 400 + StarRocksSQLParserRULE_withClause = 401 + StarRocksSQLParserRULE_queryNoWith = 402 + StarRocksSQLParserRULE_queryPeriod = 403 + StarRocksSQLParserRULE_periodType = 404 + StarRocksSQLParserRULE_queryPrimary = 405 + StarRocksSQLParserRULE_subquery = 406 + StarRocksSQLParserRULE_rowConstructor = 407 + StarRocksSQLParserRULE_sortItem = 408 + StarRocksSQLParserRULE_limitConstExpr = 409 + StarRocksSQLParserRULE_limitElement = 410 + StarRocksSQLParserRULE_querySpecification = 411 + StarRocksSQLParserRULE_fromClause = 412 + StarRocksSQLParserRULE_groupingElement = 413 + StarRocksSQLParserRULE_groupingSet = 414 + StarRocksSQLParserRULE_commonTableExpression = 415 + StarRocksSQLParserRULE_setQuantifier = 416 + StarRocksSQLParserRULE_selectItem = 417 + StarRocksSQLParserRULE_excludeClause = 418 + StarRocksSQLParserRULE_relations = 419 + StarRocksSQLParserRULE_relationLateralView = 420 + StarRocksSQLParserRULE_lateralView = 421 + StarRocksSQLParserRULE_generatorFunction = 422 + StarRocksSQLParserRULE_relation = 423 + StarRocksSQLParserRULE_relationPrimary = 424 + StarRocksSQLParserRULE_pivotClause = 425 + StarRocksSQLParserRULE_pivotAggregationExpression = 426 + StarRocksSQLParserRULE_pivotValue = 427 + StarRocksSQLParserRULE_sampleClause = 428 + StarRocksSQLParserRULE_argumentList = 429 + StarRocksSQLParserRULE_namedArgumentList = 430 + StarRocksSQLParserRULE_namedArgument = 431 + StarRocksSQLParserRULE_joinRelation = 432 + StarRocksSQLParserRULE_crossOrInnerJoinType = 433 + StarRocksSQLParserRULE_outerAndSemiJoinType = 434 + StarRocksSQLParserRULE_bracketHint = 435 + StarRocksSQLParserRULE_hintMap = 436 + StarRocksSQLParserRULE_joinCriteria = 437 + StarRocksSQLParserRULE_columnAliases = 438 + StarRocksSQLParserRULE_columnAliasesWithoutParentheses = 439 + StarRocksSQLParserRULE_partitionNames = 440 + StarRocksSQLParserRULE_keyPartitions = 441 + StarRocksSQLParserRULE_tabletList = 442 + StarRocksSQLParserRULE_prepareStatement = 443 + StarRocksSQLParserRULE_prepareSql = 444 + StarRocksSQLParserRULE_executeStatement = 445 + StarRocksSQLParserRULE_deallocateStatement = 446 + StarRocksSQLParserRULE_replicaList = 447 + StarRocksSQLParserRULE_expressionsWithDefault = 448 + StarRocksSQLParserRULE_expressionOrDefault = 449 + StarRocksSQLParserRULE_mapExpressionList = 450 + StarRocksSQLParserRULE_mapExpression = 451 + StarRocksSQLParserRULE_expressionSingleton = 452 + StarRocksSQLParserRULE_expression = 453 + StarRocksSQLParserRULE_expressionList = 454 + StarRocksSQLParserRULE_booleanExpression = 455 + StarRocksSQLParserRULE_predicate = 456 + StarRocksSQLParserRULE_tupleInSubquery = 457 + StarRocksSQLParserRULE_predicateOperations = 458 + StarRocksSQLParserRULE_valueExpression = 459 + StarRocksSQLParserRULE_primaryExpression = 460 + StarRocksSQLParserRULE_literalExpression = 461 + StarRocksSQLParserRULE_functionCall = 462 + StarRocksSQLParserRULE_aggregationFunction = 463 + StarRocksSQLParserRULE_userVariable = 464 + StarRocksSQLParserRULE_systemVariable = 465 + StarRocksSQLParserRULE_columnReference = 466 + StarRocksSQLParserRULE_informationFunctionExpression = 467 + StarRocksSQLParserRULE_specialDateTimeExpression = 468 + StarRocksSQLParserRULE_specialFunctionExpression = 469 + StarRocksSQLParserRULE_windowFunction = 470 + StarRocksSQLParserRULE_whenClause = 471 + StarRocksSQLParserRULE_over = 472 + StarRocksSQLParserRULE_ignoreNulls = 473 + StarRocksSQLParserRULE_windowFrame = 474 + StarRocksSQLParserRULE_frameBound = 475 + StarRocksSQLParserRULE_backupRestoreObjectDesc = 476 + StarRocksSQLParserRULE_tableDesc = 477 + StarRocksSQLParserRULE_backupRestoreTableDesc = 478 + StarRocksSQLParserRULE_explainDesc = 479 + StarRocksSQLParserRULE_optimizerTrace = 480 + StarRocksSQLParserRULE_partitionExpr = 481 + StarRocksSQLParserRULE_partitionDesc = 482 + StarRocksSQLParserRULE_listPartitionDesc = 483 + StarRocksSQLParserRULE_singleItemListPartitionDesc = 484 + StarRocksSQLParserRULE_multiItemListPartitionDesc = 485 + StarRocksSQLParserRULE_multiListPartitionValues = 486 + StarRocksSQLParserRULE_singleListPartitionValues = 487 + StarRocksSQLParserRULE_listPartitionValues = 488 + StarRocksSQLParserRULE_listPartitionValue = 489 + StarRocksSQLParserRULE_stringList = 490 + StarRocksSQLParserRULE_literalExpressionList = 491 + StarRocksSQLParserRULE_rangePartitionDesc = 492 + StarRocksSQLParserRULE_singleRangePartition = 493 + StarRocksSQLParserRULE_multiRangePartition = 494 + StarRocksSQLParserRULE_partitionRangeDesc = 495 + StarRocksSQLParserRULE_partitionKeyDesc = 496 + StarRocksSQLParserRULE_partitionValueList = 497 + StarRocksSQLParserRULE_keyPartition = 498 + StarRocksSQLParserRULE_partitionValue = 499 + StarRocksSQLParserRULE_distributionClause = 500 + StarRocksSQLParserRULE_distributionDesc = 501 + StarRocksSQLParserRULE_refreshSchemeDesc = 502 + StarRocksSQLParserRULE_statusDesc = 503 + StarRocksSQLParserRULE_properties = 504 + StarRocksSQLParserRULE_extProperties = 505 + StarRocksSQLParserRULE_propertyList = 506 + StarRocksSQLParserRULE_userPropertyList = 507 + StarRocksSQLParserRULE_property = 508 + StarRocksSQLParserRULE_inlineProperties = 509 + StarRocksSQLParserRULE_inlineProperty = 510 + StarRocksSQLParserRULE_varType = 511 + StarRocksSQLParserRULE_comment = 512 + StarRocksSQLParserRULE_outfile = 513 + StarRocksSQLParserRULE_fileFormat = 514 + StarRocksSQLParserRULE_string = 515 + StarRocksSQLParserRULE_binary = 516 + StarRocksSQLParserRULE_comparisonOperator = 517 + StarRocksSQLParserRULE_booleanValue = 518 + StarRocksSQLParserRULE_interval = 519 + StarRocksSQLParserRULE_taskInterval = 520 + StarRocksSQLParserRULE_taskUnitIdentifier = 521 + StarRocksSQLParserRULE_unitIdentifier = 522 + StarRocksSQLParserRULE_unitBoundary = 523 + StarRocksSQLParserRULE_type = 524 + StarRocksSQLParserRULE_arrayType = 525 + StarRocksSQLParserRULE_mapType = 526 + StarRocksSQLParserRULE_subfieldDesc = 527 + StarRocksSQLParserRULE_subfieldDescs = 528 + StarRocksSQLParserRULE_structType = 529 + StarRocksSQLParserRULE_typeParameter = 530 + StarRocksSQLParserRULE_baseType = 531 + StarRocksSQLParserRULE_decimalType = 532 + StarRocksSQLParserRULE_qualifiedName = 533 + StarRocksSQLParserRULE_tableName = 534 + StarRocksSQLParserRULE_writeBranch = 535 + StarRocksSQLParserRULE_identifier = 536 + StarRocksSQLParserRULE_identifierWithAlias = 537 + StarRocksSQLParserRULE_identifierWithAliasList = 538 + StarRocksSQLParserRULE_identifierList = 539 + StarRocksSQLParserRULE_identifierOrString = 540 + StarRocksSQLParserRULE_identifierOrStringList = 541 + StarRocksSQLParserRULE_identifierOrStringOrStar = 542 + StarRocksSQLParserRULE_user = 543 + StarRocksSQLParserRULE_assignment = 544 + StarRocksSQLParserRULE_assignmentList = 545 + StarRocksSQLParserRULE_number = 546 + StarRocksSQLParserRULE_nonReserved = 547 ) // ISqlStatementsContext is an interface to support dynamic dispatch. @@ -5991,13 +5991,13 @@ type SqlStatementsContext struct { func NewEmptySqlStatementsContext() *SqlStatementsContext { var p = new(SqlStatementsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_sqlStatements + p.RuleIndex = StarRocksSQLParserRULE_sqlStatements return p } func InitEmptySqlStatementsContext(p *SqlStatementsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_sqlStatements + p.RuleIndex = StarRocksSQLParserRULE_sqlStatements } func (*SqlStatementsContext) IsSqlStatementsContext() {} @@ -6008,7 +6008,7 @@ func NewSqlStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_sqlStatements + p.RuleIndex = StarRocksSQLParserRULE_sqlStatements return p } @@ -6016,7 +6016,7 @@ func NewSqlStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *SqlStatementsContext) GetParser() antlr.Parser { return s.parser } func (s *SqlStatementsContext) EOF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEOF, 0) + return s.GetToken(StarRocksSQLParserEOF, 0) } func (s *SqlStatementsContext) AllSingleStatement() []ISingleStatementContext { @@ -6069,20 +6069,20 @@ func (s *SqlStatementsContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *SqlStatementsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSqlStatements(s) } } func (s *SqlStatementsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSqlStatements(s) } } func (s *SqlStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSqlStatements(s) default: @@ -6090,9 +6090,9 @@ func (s *SqlStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) SqlStatements() (localctx ISqlStatementsContext) { +func (p *StarRocksSQLParser) SqlStatements() (localctx ISqlStatementsContext) { localctx = NewSqlStatementsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 0, DorisSQLParserRULE_sqlStatements) + p.EnterRule(localctx, 0, StarRocksSQLParserRULE_sqlStatements) var _la int p.EnterOuterAlt(localctx, 1) @@ -6103,7 +6103,7 @@ func (p *DorisSQLParser) SqlStatements() (localctx ISqlStatementsContext) { } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&216174019065962500) != 0) || ((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&433475862185117699) != 0) || ((int64((_la-132)) & ^0x3f) == 0 && ((int64(1)<<(_la-132))&288793326106345473) != 0) || ((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&17180917763) != 0) || ((int64((_la-309)) & ^0x3f) == 0 && ((int64(1)<<(_la-309))&4827862099076087809) != 0) || ((int64((_la-377)) & ^0x3f) == 0 && ((int64(1)<<(_la-377))&7166222204929) != 0) || ((int64((_la-441)) & ^0x3f) == 0 && ((int64(1)<<(_la-441))&107752139857989) != 0) || _la == DorisSQLParserSEMICOLON { + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&216174019065962500) != 0) || ((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&433475862185117699) != 0) || ((int64((_la-132)) & ^0x3f) == 0 && ((int64(1)<<(_la-132))&288793326106345473) != 0) || ((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&17180917763) != 0) || ((int64((_la-309)) & ^0x3f) == 0 && ((int64(1)<<(_la-309))&4827862099076087809) != 0) || ((int64((_la-377)) & ^0x3f) == 0 && ((int64(1)<<(_la-377))&7166222204929) != 0) || ((int64((_la-441)) & ^0x3f) == 0 && ((int64(1)<<(_la-441))&107752139857989) != 0) || _la == StarRocksSQLParserSEMICOLON { { p.SetState(1096) p.SingleStatement() @@ -6118,7 +6118,7 @@ func (p *DorisSQLParser) SqlStatements() (localctx ISqlStatementsContext) { } { p.SetState(1101) - p.Match(DorisSQLParserEOF) + p.Match(StarRocksSQLParserEOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6162,13 +6162,13 @@ type SingleStatementContext struct { func NewEmptySingleStatementContext() *SingleStatementContext { var p = new(SingleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleStatement + p.RuleIndex = StarRocksSQLParserRULE_singleStatement return p } func InitEmptySingleStatementContext(p *SingleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleStatement + p.RuleIndex = StarRocksSQLParserRULE_singleStatement } func (*SingleStatementContext) IsSingleStatementContext() {} @@ -6179,7 +6179,7 @@ func NewSingleStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_singleStatement + p.RuleIndex = StarRocksSQLParserRULE_singleStatement return p } @@ -6203,11 +6203,11 @@ func (s *SingleStatementContext) Statement() IStatementContext { } func (s *SingleStatementContext) SEMICOLON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSEMICOLON, 0) + return s.GetToken(StarRocksSQLParserSEMICOLON, 0) } func (s *SingleStatementContext) EOF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEOF, 0) + return s.GetToken(StarRocksSQLParserEOF, 0) } func (s *SingleStatementContext) GetRuleContext() antlr.RuleContext { @@ -6219,20 +6219,20 @@ func (s *SingleStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *SingleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSingleStatement(s) } } func (s *SingleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSingleStatement(s) } } func (s *SingleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSingleStatement(s) default: @@ -6240,9 +6240,9 @@ func (s *SingleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) SingleStatement() (localctx ISingleStatementContext) { +func (p *StarRocksSQLParser) SingleStatement() (localctx ISingleStatementContext) { localctx = NewSingleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 2, DorisSQLParserRULE_singleStatement) + p.EnterRule(localctx, 2, StarRocksSQLParserRULE_singleStatement) var _la int p.SetState(1107) @@ -6252,7 +6252,7 @@ func (p *DorisSQLParser) SingleStatement() (localctx ISingleStatementContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1, DorisSQLParserADD, DorisSQLParserADMIN, DorisSQLParserALTER, DorisSQLParserANALYZE, DorisSQLParserBACKUP, DorisSQLParserBEGIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCOMMIT, DorisSQLParserCREATE, DorisSQLParserDEALLOCATE, DorisSQLParserDELETE, DorisSQLParserDESC, DorisSQLParserDESCRIBE, DorisSQLParserDROP, DorisSQLParserEXECUTE, DorisSQLParserEXPLAIN, DorisSQLParserEXPORT, DorisSQLParserGRANT, DorisSQLParserHELP, DorisSQLParserINSTALL, DorisSQLParserINSERT, DorisSQLParserKILL, DorisSQLParserLOAD, DorisSQLParserPAUSE, DorisSQLParserPREPARE, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserREVOKE, DorisSQLParserROLLBACK, DorisSQLParserSELECT, DorisSQLParserSET, DorisSQLParserSHOW, DorisSQLParserSTART, DorisSQLParserSTOP, DorisSQLParserSUBMIT, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRUNCATE, DorisSQLParserUNINSTALL, DorisSQLParserUPDATE, DorisSQLParserUSE, DorisSQLParserWITH, DorisSQLParserLOCK, DorisSQLParserUNLOCK: + case StarRocksSQLParserT__1, StarRocksSQLParserADD, StarRocksSQLParserADMIN, StarRocksSQLParserALTER, StarRocksSQLParserANALYZE, StarRocksSQLParserBACKUP, StarRocksSQLParserBEGIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCOMMIT, StarRocksSQLParserCREATE, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDELETE, StarRocksSQLParserDESC, StarRocksSQLParserDESCRIBE, StarRocksSQLParserDROP, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPLAIN, StarRocksSQLParserEXPORT, StarRocksSQLParserGRANT, StarRocksSQLParserHELP, StarRocksSQLParserINSTALL, StarRocksSQLParserINSERT, StarRocksSQLParserKILL, StarRocksSQLParserLOAD, StarRocksSQLParserPAUSE, StarRocksSQLParserPREPARE, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserREVOKE, StarRocksSQLParserROLLBACK, StarRocksSQLParserSELECT, StarRocksSQLParserSET, StarRocksSQLParserSHOW, StarRocksSQLParserSTART, StarRocksSQLParserSTOP, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUPDATE, StarRocksSQLParserUSE, StarRocksSQLParserWITH, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK: p.EnterOuterAlt(localctx, 1) { p.SetState(1103) @@ -6262,7 +6262,7 @@ func (p *DorisSQLParser) SingleStatement() (localctx ISingleStatementContext) { p.SetState(1104) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserEOF || _la == DorisSQLParserSEMICOLON) { + if !(_la == StarRocksSQLParserEOF || _la == StarRocksSQLParserSEMICOLON) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -6270,11 +6270,11 @@ func (p *DorisSQLParser) SingleStatement() (localctx ISingleStatementContext) { } } - case DorisSQLParserSEMICOLON: + case StarRocksSQLParserSEMICOLON: p.EnterOuterAlt(localctx, 2) { p.SetState(1106) - p.Match(DorisSQLParserSEMICOLON) + p.Match(StarRocksSQLParserSEMICOLON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -6584,13 +6584,13 @@ type StatementContext struct { func NewEmptyStatementContext() *StatementContext { var p = new(StatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_statement + p.RuleIndex = StarRocksSQLParserRULE_statement return p } func InitEmptyStatementContext(p *StatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_statement + p.RuleIndex = StarRocksSQLParserRULE_statement } func (*StatementContext) IsStatementContext() {} @@ -6601,7 +6601,7 @@ func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_statement + p.RuleIndex = StarRocksSQLParserRULE_statement return p } @@ -10841,20 +10841,20 @@ func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterStatement(s) } } func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitStatement(s) } } func (s *StatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitStatement(s) default: @@ -10862,9 +10862,9 @@ func (s *StatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Statement() (localctx IStatementContext) { +func (p *StarRocksSQLParser) Statement() (localctx IStatementContext) { localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 4, DorisSQLParserRULE_statement) + p.EnterRule(localctx, 4, StarRocksSQLParserRULE_statement) p.SetState(1373) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -12760,13 +12760,13 @@ type UseDatabaseStatementContext struct { func NewEmptyUseDatabaseStatementContext() *UseDatabaseStatementContext { var p = new(UseDatabaseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_useDatabaseStatement + p.RuleIndex = StarRocksSQLParserRULE_useDatabaseStatement return p } func InitEmptyUseDatabaseStatementContext(p *UseDatabaseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_useDatabaseStatement + p.RuleIndex = StarRocksSQLParserRULE_useDatabaseStatement } func (*UseDatabaseStatementContext) IsUseDatabaseStatementContext() {} @@ -12777,7 +12777,7 @@ func NewUseDatabaseStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_useDatabaseStatement + p.RuleIndex = StarRocksSQLParserRULE_useDatabaseStatement return p } @@ -12785,7 +12785,7 @@ func NewUseDatabaseStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *UseDatabaseStatementContext) GetParser() antlr.Parser { return s.parser } func (s *UseDatabaseStatementContext) USE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSE, 0) + return s.GetToken(StarRocksSQLParserUSE, 0) } func (s *UseDatabaseStatementContext) QualifiedName() IQualifiedNameContext { @@ -12813,20 +12813,20 @@ func (s *UseDatabaseStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *UseDatabaseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUseDatabaseStatement(s) } } func (s *UseDatabaseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUseDatabaseStatement(s) } } func (s *UseDatabaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUseDatabaseStatement(s) default: @@ -12834,13 +12834,13 @@ func (s *UseDatabaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) UseDatabaseStatement() (localctx IUseDatabaseStatementContext) { +func (p *StarRocksSQLParser) UseDatabaseStatement() (localctx IUseDatabaseStatementContext) { localctx = NewUseDatabaseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 6, DorisSQLParserRULE_useDatabaseStatement) + p.EnterRule(localctx, 6, StarRocksSQLParserRULE_useDatabaseStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1375) - p.Match(DorisSQLParserUSE) + p.Match(StarRocksSQLParserUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -12887,13 +12887,13 @@ type UseCatalogStatementContext struct { func NewEmptyUseCatalogStatementContext() *UseCatalogStatementContext { var p = new(UseCatalogStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_useCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_useCatalogStatement return p } func InitEmptyUseCatalogStatementContext(p *UseCatalogStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_useCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_useCatalogStatement } func (*UseCatalogStatementContext) IsUseCatalogStatementContext() {} @@ -12904,7 +12904,7 @@ func NewUseCatalogStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_useCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_useCatalogStatement return p } @@ -12912,7 +12912,7 @@ func NewUseCatalogStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *UseCatalogStatementContext) GetParser() antlr.Parser { return s.parser } func (s *UseCatalogStatementContext) USE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSE, 0) + return s.GetToken(StarRocksSQLParserUSE, 0) } func (s *UseCatalogStatementContext) String_() IStringContext { @@ -12940,20 +12940,20 @@ func (s *UseCatalogStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *UseCatalogStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUseCatalogStatement(s) } } func (s *UseCatalogStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUseCatalogStatement(s) } } func (s *UseCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUseCatalogStatement(s) default: @@ -12961,13 +12961,13 @@ func (s *UseCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) UseCatalogStatement() (localctx IUseCatalogStatementContext) { +func (p *StarRocksSQLParser) UseCatalogStatement() (localctx IUseCatalogStatementContext) { localctx = NewUseCatalogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 8, DorisSQLParserRULE_useCatalogStatement) + p.EnterRule(localctx, 8, StarRocksSQLParserRULE_useCatalogStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1378) - p.Match(DorisSQLParserUSE) + p.Match(StarRocksSQLParserUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13015,13 +13015,13 @@ type SetCatalogStatementContext struct { func NewEmptySetCatalogStatementContext() *SetCatalogStatementContext { var p = new(SetCatalogStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_setCatalogStatement return p } func InitEmptySetCatalogStatementContext(p *SetCatalogStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_setCatalogStatement } func (*SetCatalogStatementContext) IsSetCatalogStatementContext() {} @@ -13032,7 +13032,7 @@ func NewSetCatalogStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_setCatalogStatement return p } @@ -13040,11 +13040,11 @@ func NewSetCatalogStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *SetCatalogStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetCatalogStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetCatalogStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *SetCatalogStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -13072,20 +13072,20 @@ func (s *SetCatalogStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *SetCatalogStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetCatalogStatement(s) } } func (s *SetCatalogStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetCatalogStatement(s) } } func (s *SetCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetCatalogStatement(s) default: @@ -13093,13 +13093,13 @@ func (s *SetCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) SetCatalogStatement() (localctx ISetCatalogStatementContext) { +func (p *StarRocksSQLParser) SetCatalogStatement() (localctx ISetCatalogStatementContext) { localctx = NewSetCatalogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 10, DorisSQLParserRULE_setCatalogStatement) + p.EnterRule(localctx, 10, StarRocksSQLParserRULE_setCatalogStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1381) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13107,7 +13107,7 @@ func (p *DorisSQLParser) SetCatalogStatement() (localctx ISetCatalogStatementCon } { p.SetState(1382) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13176,13 +13176,13 @@ type ShowDatabasesStatementContext struct { func NewEmptyShowDatabasesStatementContext() *ShowDatabasesStatementContext { var p = new(ShowDatabasesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDatabasesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDatabasesStatement return p } func InitEmptyShowDatabasesStatementContext(p *ShowDatabasesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDatabasesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDatabasesStatement } func (*ShowDatabasesStatementContext) IsShowDatabasesStatementContext() {} @@ -13193,7 +13193,7 @@ func NewShowDatabasesStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDatabasesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDatabasesStatement return p } @@ -13209,19 +13209,19 @@ func (s *ShowDatabasesStatementContext) SetCatalog(v IQualifiedNameContext) { s. func (s *ShowDatabasesStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowDatabasesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDatabasesStatementContext) DATABASES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASES, 0) + return s.GetToken(StarRocksSQLParserDATABASES, 0) } func (s *ShowDatabasesStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowDatabasesStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowDatabasesStatementContext) QualifiedName() IQualifiedNameContext { @@ -13241,11 +13241,11 @@ func (s *ShowDatabasesStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowDatabasesStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowDatabasesStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowDatabasesStatementContext) Expression() IExpressionContext { @@ -13281,7 +13281,7 @@ func (s *ShowDatabasesStatementContext) String_() IStringContext { } func (s *ShowDatabasesStatementContext) SCHEMAS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMAS, 0) + return s.GetToken(StarRocksSQLParserSCHEMAS, 0) } func (s *ShowDatabasesStatementContext) GetRuleContext() antlr.RuleContext { @@ -13293,20 +13293,20 @@ func (s *ShowDatabasesStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowDatabasesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDatabasesStatement(s) } } func (s *ShowDatabasesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDatabasesStatement(s) } } func (s *ShowDatabasesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDatabasesStatement(s) default: @@ -13314,9 +13314,9 @@ func (s *ShowDatabasesStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatementContext) { +func (p *StarRocksSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatementContext) { localctx = NewShowDatabasesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 12, DorisSQLParserRULE_showDatabasesStatement) + p.EnterRule(localctx, 12, StarRocksSQLParserRULE_showDatabasesStatement) var _la int p.SetState(1405) @@ -13330,7 +13330,7 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem p.EnterOuterAlt(localctx, 1) { p.SetState(1385) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13338,7 +13338,7 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem } { p.SetState(1386) - p.Match(DorisSQLParserDATABASES) + p.Match(StarRocksSQLParserDATABASES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13351,12 +13351,12 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1387) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -13378,10 +13378,10 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(1391) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13395,10 +13395,10 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem localctx.(*ShowDatabasesStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(1393) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13409,7 +13409,7 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -13418,7 +13418,7 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem p.EnterOuterAlt(localctx, 2) { p.SetState(1397) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13426,7 +13426,7 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem } { p.SetState(1398) - p.Match(DorisSQLParserSCHEMAS) + p.Match(StarRocksSQLParserSCHEMAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13438,10 +13438,10 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(1399) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13455,10 +13455,10 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem localctx.(*ShowDatabasesStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(1401) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13469,7 +13469,7 @@ func (p *DorisSQLParser) ShowDatabasesStatement() (localctx IShowDatabasesStatem p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -13521,13 +13521,13 @@ type AlterDbQuotaStatementContext struct { func NewEmptyAlterDbQuotaStatementContext() *AlterDbQuotaStatementContext { var p = new(AlterDbQuotaStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterDbQuotaStatement + p.RuleIndex = StarRocksSQLParserRULE_alterDbQuotaStatement return p } func InitEmptyAlterDbQuotaStatementContext(p *AlterDbQuotaStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterDbQuotaStatement + p.RuleIndex = StarRocksSQLParserRULE_alterDbQuotaStatement } func (*AlterDbQuotaStatementContext) IsAlterDbQuotaStatementContext() {} @@ -13538,7 +13538,7 @@ func NewAlterDbQuotaStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterDbQuotaStatement + p.RuleIndex = StarRocksSQLParserRULE_alterDbQuotaStatement return p } @@ -13546,11 +13546,11 @@ func NewAlterDbQuotaStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *AlterDbQuotaStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterDbQuotaStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterDbQuotaStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *AlterDbQuotaStatementContext) AllIdentifier() []IIdentifierContext { @@ -13595,23 +13595,23 @@ func (s *AlterDbQuotaStatementContext) Identifier(i int) IIdentifierContext { } func (s *AlterDbQuotaStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterDbQuotaStatementContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *AlterDbQuotaStatementContext) QUOTA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUOTA, 0) + return s.GetToken(StarRocksSQLParserQUOTA, 0) } func (s *AlterDbQuotaStatementContext) REPLICA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLICA, 0) + return s.GetToken(StarRocksSQLParserREPLICA, 0) } func (s *AlterDbQuotaStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *AlterDbQuotaStatementContext) GetRuleContext() antlr.RuleContext { @@ -13623,20 +13623,20 @@ func (s *AlterDbQuotaStatementContext) ToStringTree(ruleNames []string, recog an } func (s *AlterDbQuotaStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterDbQuotaStatement(s) } } func (s *AlterDbQuotaStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterDbQuotaStatement(s) } } func (s *AlterDbQuotaStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterDbQuotaStatement(s) default: @@ -13644,9 +13644,9 @@ func (s *AlterDbQuotaStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatementContext) { +func (p *StarRocksSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatementContext) { localctx = NewAlterDbQuotaStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 14, DorisSQLParserRULE_alterDbQuotaStatement) + p.EnterRule(localctx, 14, StarRocksSQLParserRULE_alterDbQuotaStatement) p.SetState(1423) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -13658,7 +13658,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen p.EnterOuterAlt(localctx, 1) { p.SetState(1407) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13666,7 +13666,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1408) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13678,7 +13678,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1410) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13686,7 +13686,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1411) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13694,7 +13694,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1412) - p.Match(DorisSQLParserQUOTA) + p.Match(StarRocksSQLParserQUOTA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13709,7 +13709,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen p.EnterOuterAlt(localctx, 2) { p.SetState(1415) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13717,7 +13717,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1416) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13729,7 +13729,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1418) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13737,7 +13737,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1419) - p.Match(DorisSQLParserREPLICA) + p.Match(StarRocksSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13745,7 +13745,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1420) - p.Match(DorisSQLParserQUOTA) + p.Match(StarRocksSQLParserQUOTA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13753,7 +13753,7 @@ func (p *DorisSQLParser) AlterDbQuotaStatement() (localctx IAlterDbQuotaStatemen } { p.SetState(1421) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -13823,13 +13823,13 @@ type CreateDbStatementContext struct { func NewEmptyCreateDbStatementContext() *CreateDbStatementContext { var p = new(CreateDbStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createDbStatement + p.RuleIndex = StarRocksSQLParserRULE_createDbStatement return p } func InitEmptyCreateDbStatementContext(p *CreateDbStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createDbStatement + p.RuleIndex = StarRocksSQLParserRULE_createDbStatement } func (*CreateDbStatementContext) IsCreateDbStatementContext() {} @@ -13840,7 +13840,7 @@ func NewCreateDbStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createDbStatement + p.RuleIndex = StarRocksSQLParserRULE_createDbStatement return p } @@ -13856,15 +13856,15 @@ func (s *CreateDbStatementContext) SetCatalog(v IIdentifierContext) { s.catalog func (s *CreateDbStatementContext) SetDatabase(v IQualifiedNameContext) { s.database = v } func (s *CreateDbStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateDbStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *CreateDbStatementContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMA, 0) + return s.GetToken(StarRocksSQLParserSCHEMA, 0) } func (s *CreateDbStatementContext) QualifiedName() IQualifiedNameContext { @@ -13884,15 +13884,15 @@ func (s *CreateDbStatementContext) QualifiedName() IQualifiedNameContext { } func (s *CreateDbStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateDbStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateDbStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateDbStatementContext) CharsetDesc() ICharsetDescContext { @@ -13968,20 +13968,20 @@ func (s *CreateDbStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *CreateDbStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateDbStatement(s) } } func (s *CreateDbStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateDbStatement(s) } } func (s *CreateDbStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateDbStatement(s) default: @@ -13989,15 +13989,15 @@ func (s *CreateDbStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext) { +func (p *StarRocksSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext) { localctx = NewCreateDbStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 16, DorisSQLParserRULE_createDbStatement) + p.EnterRule(localctx, 16, StarRocksSQLParserRULE_createDbStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1425) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14007,7 +14007,7 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext p.SetState(1426) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDATABASE || _la == DorisSQLParserSCHEMA) { + if !(_la == StarRocksSQLParserDATABASE || _la == StarRocksSQLParserSCHEMA) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -14021,10 +14021,10 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(1427) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14032,7 +14032,7 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext } { p.SetState(1428) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14040,7 +14040,7 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext } { p.SetState(1429) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14061,7 +14061,7 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext } { p.SetState(1433) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14097,7 +14097,7 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOLLATE || _la == DorisSQLParserDEFAULT { + if _la == StarRocksSQLParserCOLLATE || _la == StarRocksSQLParserDEFAULT { { p.SetState(1441) p.CollateDesc() @@ -14111,7 +14111,7 @@ func (p *DorisSQLParser) CreateDbStatement() (localctx ICreateDbStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(1444) p.Properties() @@ -14175,13 +14175,13 @@ type DropDbStatementContext struct { func NewEmptyDropDbStatementContext() *DropDbStatementContext { var p = new(DropDbStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropDbStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDbStatement return p } func InitEmptyDropDbStatementContext(p *DropDbStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropDbStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDbStatement } func (*DropDbStatementContext) IsDropDbStatementContext() {} @@ -14192,7 +14192,7 @@ func NewDropDbStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropDbStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDbStatement return p } @@ -14208,15 +14208,15 @@ func (s *DropDbStatementContext) SetCatalog(v IIdentifierContext) { s.catalog = func (s *DropDbStatementContext) SetDatabase(v IQualifiedNameContext) { s.database = v } func (s *DropDbStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropDbStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *DropDbStatementContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMA, 0) + return s.GetToken(StarRocksSQLParserSCHEMA, 0) } func (s *DropDbStatementContext) QualifiedName() IQualifiedNameContext { @@ -14236,15 +14236,15 @@ func (s *DropDbStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropDbStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropDbStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropDbStatementContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *DropDbStatementContext) Identifier() IIdentifierContext { @@ -14272,20 +14272,20 @@ func (s *DropDbStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *DropDbStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropDbStatement(s) } } func (s *DropDbStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropDbStatement(s) } } func (s *DropDbStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropDbStatement(s) default: @@ -14293,15 +14293,15 @@ func (s *DropDbStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { +func (p *StarRocksSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { localctx = NewDropDbStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 18, DorisSQLParserRULE_dropDbStatement) + p.EnterRule(localctx, 18, StarRocksSQLParserRULE_dropDbStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1447) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14311,7 +14311,7 @@ func (p *DorisSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { p.SetState(1448) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDATABASE || _la == DorisSQLParserSCHEMA) { + if !(_la == StarRocksSQLParserDATABASE || _la == StarRocksSQLParserSCHEMA) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -14325,10 +14325,10 @@ func (p *DorisSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(1449) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14336,7 +14336,7 @@ func (p *DorisSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { } { p.SetState(1450) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14357,7 +14357,7 @@ func (p *DorisSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { } { p.SetState(1454) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14381,10 +14381,10 @@ func (p *DorisSQLParser) DropDbStatement() (localctx IDropDbStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(1459) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14432,13 +14432,13 @@ type ShowCreateDbStatementContext struct { func NewEmptyShowCreateDbStatementContext() *ShowCreateDbStatementContext { var p = new(ShowCreateDbStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateDbStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateDbStatement return p } func InitEmptyShowCreateDbStatementContext(p *ShowCreateDbStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateDbStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateDbStatement } func (*ShowCreateDbStatementContext) IsShowCreateDbStatementContext() {} @@ -14449,7 +14449,7 @@ func NewShowCreateDbStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateDbStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateDbStatement return p } @@ -14457,11 +14457,11 @@ func NewShowCreateDbStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *ShowCreateDbStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowCreateDbStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateDbStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateDbStatementContext) Identifier() IIdentifierContext { @@ -14481,11 +14481,11 @@ func (s *ShowCreateDbStatementContext) Identifier() IIdentifierContext { } func (s *ShowCreateDbStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *ShowCreateDbStatementContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMA, 0) + return s.GetToken(StarRocksSQLParserSCHEMA, 0) } func (s *ShowCreateDbStatementContext) GetRuleContext() antlr.RuleContext { @@ -14497,20 +14497,20 @@ func (s *ShowCreateDbStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowCreateDbStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateDbStatement(s) } } func (s *ShowCreateDbStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateDbStatement(s) } } func (s *ShowCreateDbStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateDbStatement(s) default: @@ -14518,15 +14518,15 @@ func (s *ShowCreateDbStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowCreateDbStatement() (localctx IShowCreateDbStatementContext) { +func (p *StarRocksSQLParser) ShowCreateDbStatement() (localctx IShowCreateDbStatementContext) { localctx = NewShowCreateDbStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 20, DorisSQLParserRULE_showCreateDbStatement) + p.EnterRule(localctx, 20, StarRocksSQLParserRULE_showCreateDbStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1462) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14534,7 +14534,7 @@ func (p *DorisSQLParser) ShowCreateDbStatement() (localctx IShowCreateDbStatemen } { p.SetState(1463) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14544,7 +14544,7 @@ func (p *DorisSQLParser) ShowCreateDbStatement() (localctx IShowCreateDbStatemen p.SetState(1464) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDATABASE || _la == DorisSQLParserSCHEMA) { + if !(_la == StarRocksSQLParserDATABASE || _la == StarRocksSQLParserSCHEMA) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -14595,13 +14595,13 @@ type AlterDatabaseRenameStatementContext struct { func NewEmptyAlterDatabaseRenameStatementContext() *AlterDatabaseRenameStatementContext { var p = new(AlterDatabaseRenameStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterDatabaseRenameStatement + p.RuleIndex = StarRocksSQLParserRULE_alterDatabaseRenameStatement return p } func InitEmptyAlterDatabaseRenameStatementContext(p *AlterDatabaseRenameStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterDatabaseRenameStatement + p.RuleIndex = StarRocksSQLParserRULE_alterDatabaseRenameStatement } func (*AlterDatabaseRenameStatementContext) IsAlterDatabaseRenameStatementContext() {} @@ -14612,7 +14612,7 @@ func NewAlterDatabaseRenameStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterDatabaseRenameStatement + p.RuleIndex = StarRocksSQLParserRULE_alterDatabaseRenameStatement return p } @@ -14620,11 +14620,11 @@ func NewAlterDatabaseRenameStatementContext(parser antlr.Parser, parent antlr.Pa func (s *AlterDatabaseRenameStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterDatabaseRenameStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterDatabaseRenameStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *AlterDatabaseRenameStatementContext) AllIdentifier() []IIdentifierContext { @@ -14669,7 +14669,7 @@ func (s *AlterDatabaseRenameStatementContext) Identifier(i int) IIdentifierConte } func (s *AlterDatabaseRenameStatementContext) RENAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRENAME, 0) + return s.GetToken(StarRocksSQLParserRENAME, 0) } func (s *AlterDatabaseRenameStatementContext) GetRuleContext() antlr.RuleContext { @@ -14681,20 +14681,20 @@ func (s *AlterDatabaseRenameStatementContext) ToStringTree(ruleNames []string, r } func (s *AlterDatabaseRenameStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterDatabaseRenameStatement(s) } } func (s *AlterDatabaseRenameStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterDatabaseRenameStatement(s) } } func (s *AlterDatabaseRenameStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterDatabaseRenameStatement(s) default: @@ -14702,13 +14702,13 @@ func (s *AlterDatabaseRenameStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) AlterDatabaseRenameStatement() (localctx IAlterDatabaseRenameStatementContext) { +func (p *StarRocksSQLParser) AlterDatabaseRenameStatement() (localctx IAlterDatabaseRenameStatementContext) { localctx = NewAlterDatabaseRenameStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 22, DorisSQLParserRULE_alterDatabaseRenameStatement) + p.EnterRule(localctx, 22, StarRocksSQLParserRULE_alterDatabaseRenameStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1467) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14716,7 +14716,7 @@ func (p *DorisSQLParser) AlterDatabaseRenameStatement() (localctx IAlterDatabase } { p.SetState(1468) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14728,7 +14728,7 @@ func (p *DorisSQLParser) AlterDatabaseRenameStatement() (localctx IAlterDatabase } { p.SetState(1470) - p.Match(DorisSQLParserRENAME) + p.Match(StarRocksSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14777,13 +14777,13 @@ type RecoverDbStmtContext struct { func NewEmptyRecoverDbStmtContext() *RecoverDbStmtContext { var p = new(RecoverDbStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_recoverDbStmt + p.RuleIndex = StarRocksSQLParserRULE_recoverDbStmt return p } func InitEmptyRecoverDbStmtContext(p *RecoverDbStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_recoverDbStmt + p.RuleIndex = StarRocksSQLParserRULE_recoverDbStmt } func (*RecoverDbStmtContext) IsRecoverDbStmtContext() {} @@ -14794,7 +14794,7 @@ func NewRecoverDbStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_recoverDbStmt + p.RuleIndex = StarRocksSQLParserRULE_recoverDbStmt return p } @@ -14802,7 +14802,7 @@ func NewRecoverDbStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *RecoverDbStmtContext) GetParser() antlr.Parser { return s.parser } func (s *RecoverDbStmtContext) RECOVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRECOVER, 0) + return s.GetToken(StarRocksSQLParserRECOVER, 0) } func (s *RecoverDbStmtContext) Identifier() IIdentifierContext { @@ -14822,11 +14822,11 @@ func (s *RecoverDbStmtContext) Identifier() IIdentifierContext { } func (s *RecoverDbStmtContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *RecoverDbStmtContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMA, 0) + return s.GetToken(StarRocksSQLParserSCHEMA, 0) } func (s *RecoverDbStmtContext) GetRuleContext() antlr.RuleContext { @@ -14838,20 +14838,20 @@ func (s *RecoverDbStmtContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *RecoverDbStmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRecoverDbStmt(s) } } func (s *RecoverDbStmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRecoverDbStmt(s) } } func (s *RecoverDbStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRecoverDbStmt(s) default: @@ -14859,15 +14859,15 @@ func (s *RecoverDbStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) RecoverDbStmt() (localctx IRecoverDbStmtContext) { +func (p *StarRocksSQLParser) RecoverDbStmt() (localctx IRecoverDbStmtContext) { localctx = NewRecoverDbStmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 24, DorisSQLParserRULE_recoverDbStmt) + p.EnterRule(localctx, 24, StarRocksSQLParserRULE_recoverDbStmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1473) - p.Match(DorisSQLParserRECOVER) + p.Match(StarRocksSQLParserRECOVER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -14877,7 +14877,7 @@ func (p *DorisSQLParser) RecoverDbStmt() (localctx IRecoverDbStmtContext) { p.SetState(1474) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDATABASE || _la == DorisSQLParserSCHEMA) { + if !(_la == StarRocksSQLParserDATABASE || _la == StarRocksSQLParserSCHEMA) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -14927,13 +14927,13 @@ type ShowDataStmtContext struct { func NewEmptyShowDataStmtContext() *ShowDataStmtContext { var p = new(ShowDataStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataStmt + p.RuleIndex = StarRocksSQLParserRULE_showDataStmt return p } func InitEmptyShowDataStmtContext(p *ShowDataStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataStmt + p.RuleIndex = StarRocksSQLParserRULE_showDataStmt } func (*ShowDataStmtContext) IsShowDataStmtContext() {} @@ -14944,7 +14944,7 @@ func NewShowDataStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDataStmt + p.RuleIndex = StarRocksSQLParserRULE_showDataStmt return p } @@ -14952,15 +14952,15 @@ func NewShowDataStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *ShowDataStmtContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDataStmtContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDataStmtContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *ShowDataStmtContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowDataStmtContext) QualifiedName() IQualifiedNameContext { @@ -14988,20 +14988,20 @@ func (s *ShowDataStmtContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *ShowDataStmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDataStmt(s) } } func (s *ShowDataStmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDataStmt(s) } } func (s *ShowDataStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDataStmt(s) default: @@ -15009,9 +15009,9 @@ func (s *ShowDataStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { +func (p *StarRocksSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { localctx = NewShowDataStmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 26, DorisSQLParserRULE_showDataStmt) + p.EnterRule(localctx, 26, StarRocksSQLParserRULE_showDataStmt) p.SetState(1483) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -15023,7 +15023,7 @@ func (p *DorisSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(1477) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15031,7 +15031,7 @@ func (p *DorisSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { } { p.SetState(1478) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15042,7 +15042,7 @@ func (p *DorisSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(1479) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15050,7 +15050,7 @@ func (p *DorisSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { } { p.SetState(1480) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15058,7 +15058,7 @@ func (p *DorisSQLParser) ShowDataStmt() (localctx IShowDataStmtContext) { } { p.SetState(1481) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15113,13 +15113,13 @@ type ShowDataDistributionStmtContext struct { func NewEmptyShowDataDistributionStmtContext() *ShowDataDistributionStmtContext { var p = new(ShowDataDistributionStmtContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataDistributionStmt + p.RuleIndex = StarRocksSQLParserRULE_showDataDistributionStmt return p } func InitEmptyShowDataDistributionStmtContext(p *ShowDataDistributionStmtContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataDistributionStmt + p.RuleIndex = StarRocksSQLParserRULE_showDataDistributionStmt } func (*ShowDataDistributionStmtContext) IsShowDataDistributionStmtContext() {} @@ -15130,7 +15130,7 @@ func NewShowDataDistributionStmtContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDataDistributionStmt + p.RuleIndex = StarRocksSQLParserRULE_showDataDistributionStmt return p } @@ -15138,19 +15138,19 @@ func NewShowDataDistributionStmtContext(parser antlr.Parser, parent antlr.Parser func (s *ShowDataDistributionStmtContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDataDistributionStmtContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDataDistributionStmtContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *ShowDataDistributionStmtContext) DISTRIBUTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTRIBUTION, 0) + return s.GetToken(StarRocksSQLParserDISTRIBUTION, 0) } func (s *ShowDataDistributionStmtContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowDataDistributionStmtContext) QualifiedName() IQualifiedNameContext { @@ -15194,20 +15194,20 @@ func (s *ShowDataDistributionStmtContext) ToStringTree(ruleNames []string, recog } func (s *ShowDataDistributionStmtContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDataDistributionStmt(s) } } func (s *ShowDataDistributionStmtContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDataDistributionStmt(s) } } func (s *ShowDataDistributionStmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDataDistributionStmt(s) default: @@ -15215,15 +15215,15 @@ func (s *ShowDataDistributionStmtContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowDataDistributionStmt() (localctx IShowDataDistributionStmtContext) { +func (p *StarRocksSQLParser) ShowDataDistributionStmt() (localctx IShowDataDistributionStmtContext) { localctx = NewShowDataDistributionStmtContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 28, DorisSQLParserRULE_showDataDistributionStmt) + p.EnterRule(localctx, 28, StarRocksSQLParserRULE_showDataDistributionStmt) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1485) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15231,7 +15231,7 @@ func (p *DorisSQLParser) ShowDataDistributionStmt() (localctx IShowDataDistribut } { p.SetState(1486) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15239,7 +15239,7 @@ func (p *DorisSQLParser) ShowDataDistributionStmt() (localctx IShowDataDistribut } { p.SetState(1487) - p.Match(DorisSQLParserDISTRIBUTION) + p.Match(StarRocksSQLParserDISTRIBUTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15247,7 +15247,7 @@ func (p *DorisSQLParser) ShowDataDistributionStmt() (localctx IShowDataDistribut } { p.SetState(1488) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15264,7 +15264,7 @@ func (p *DorisSQLParser) ShowDataDistributionStmt() (localctx IShowDataDistribut } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(1490) p.PartitionNames() @@ -15328,13 +15328,13 @@ type CreateTableStatementContext struct { func NewEmptyCreateTableStatementContext() *CreateTableStatementContext { var p = new(CreateTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createTableStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableStatement return p } func InitEmptyCreateTableStatementContext(p *CreateTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createTableStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableStatement } func (*CreateTableStatementContext) IsCreateTableStatementContext() {} @@ -15345,7 +15345,7 @@ func NewCreateTableStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createTableStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableStatement return p } @@ -15353,11 +15353,11 @@ func NewCreateTableStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *CreateTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateTableStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CreateTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -15418,15 +15418,15 @@ func (s *CreateTableStatementContext) ColumnDesc(i int) IColumnDescContext { } func (s *CreateTableStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateTableStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateTableStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateTableStatementContext) AllIndexDesc() []IIndexDescContext { @@ -15631,11 +15631,11 @@ func (s *CreateTableStatementContext) ExtProperties() IExtPropertiesContext { } func (s *CreateTableStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *CreateTableStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *CreateTableStatementContext) GetRuleContext() antlr.RuleContext { @@ -15647,20 +15647,20 @@ func (s *CreateTableStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *CreateTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateTableStatement(s) } } func (s *CreateTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateTableStatement(s) } } func (s *CreateTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateTableStatement(s) default: @@ -15668,9 +15668,9 @@ func (s *CreateTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementContext) { +func (p *StarRocksSQLParser) CreateTableStatement() (localctx ICreateTableStatementContext) { localctx = NewCreateTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 30, DorisSQLParserRULE_createTableStatement) + p.EnterRule(localctx, 30, StarRocksSQLParserRULE_createTableStatement) var _la int var _alt int @@ -15678,7 +15678,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC p.EnterOuterAlt(localctx, 1) { p.SetState(1493) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15691,12 +15691,12 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEXTERNAL || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserEXTERNAL || _la == StarRocksSQLParserTEMPORARY { { p.SetState(1494) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserEXTERNAL || _la == DorisSQLParserTEMPORARY) { + if !(_la == StarRocksSQLParserEXTERNAL || _la == StarRocksSQLParserTEMPORARY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -15707,7 +15707,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } { p.SetState(1497) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15720,10 +15720,10 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(1498) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15731,7 +15731,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } { p.SetState(1499) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15739,7 +15739,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } { p.SetState(1500) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15753,7 +15753,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } { p.SetState(1504) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15776,7 +15776,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC if _alt == 1 { { p.SetState(1506) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15805,10 +15805,10 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1513) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15828,7 +15828,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } { p.SetState(1520) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -15841,7 +15841,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserENGINE { + if _la == StarRocksSQLParserENGINE { { p.SetState(1521) p.EngineDesc() @@ -15869,7 +15869,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAGGREGATE || _la == DorisSQLParserDUPLICATE || _la == DorisSQLParserPRIMARY || _la == DorisSQLParserUNIQUE { + if _la == StarRocksSQLParserAGGREGATE || _la == StarRocksSQLParserDUPLICATE || _la == StarRocksSQLParserPRIMARY || _la == StarRocksSQLParserUNIQUE { { p.SetState(1527) p.KeyDesc() @@ -15883,7 +15883,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(1530) p.Comment() @@ -15897,7 +15897,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(1533) p.PartitionDesc() @@ -15911,7 +15911,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDISTRIBUTED { + if _la == StarRocksSQLParserDISTRIBUTED { { p.SetState(1536) p.DistributionDesc() @@ -15925,7 +15925,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(1539) p.OrderByDesc() @@ -15939,7 +15939,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserROLLUP { + if _la == StarRocksSQLParserROLLUP { { p.SetState(1542) p.RollupDesc() @@ -15953,7 +15953,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(1545) p.Properties() @@ -15967,7 +15967,7 @@ func (p *DorisSQLParser) CreateTableStatement() (localctx ICreateTableStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBROKER { + if _la == StarRocksSQLParserBROKER { { p.SetState(1548) p.ExtProperties() @@ -16019,13 +16019,13 @@ type ColumnDescContext struct { func NewEmptyColumnDescContext() *ColumnDescContext { var p = new(ColumnDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnDesc + p.RuleIndex = StarRocksSQLParserRULE_columnDesc return p } func InitEmptyColumnDescContext(p *ColumnDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnDesc + p.RuleIndex = StarRocksSQLParserRULE_columnDesc } func (*ColumnDescContext) IsColumnDescContext() {} @@ -16036,7 +16036,7 @@ func NewColumnDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnDesc + p.RuleIndex = StarRocksSQLParserRULE_columnDesc return p } @@ -16092,7 +16092,7 @@ func (s *ColumnDescContext) CharsetName() ICharsetNameContext { } func (s *ColumnDescContext) KEY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEY, 0) + return s.GetToken(StarRocksSQLParserKEY, 0) } func (s *ColumnDescContext) AggDesc() IAggDescContext { @@ -16144,7 +16144,7 @@ func (s *ColumnDescContext) DefaultDesc() IDefaultDescContext { } func (s *ColumnDescContext) AUTO_INCREMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTO_INCREMENT, 0) + return s.GetToken(StarRocksSQLParserAUTO_INCREMENT, 0) } func (s *ColumnDescContext) GeneratedColumnDesc() IGeneratedColumnDescContext { @@ -16188,20 +16188,20 @@ func (s *ColumnDescContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *ColumnDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnDesc(s) } } func (s *ColumnDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnDesc(s) } } func (s *ColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnDesc(s) default: @@ -16209,9 +16209,9 @@ func (s *ColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) ColumnDesc() (localctx IColumnDescContext) { +func (p *StarRocksSQLParser) ColumnDesc() (localctx IColumnDescContext) { localctx = NewColumnDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 32, DorisSQLParserRULE_columnDesc) + p.EnterRule(localctx, 32, StarRocksSQLParserRULE_columnDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -16250,10 +16250,10 @@ func (p *DorisSQLParser) ColumnDesc() (localctx IColumnDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserKEY { + if _la == StarRocksSQLParserKEY { { p.SetState(1558) - p.Match(DorisSQLParserKEY) + p.Match(StarRocksSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16280,7 +16280,7 @@ func (p *DorisSQLParser) ColumnDesc() (localctx IColumnDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT || _la == DorisSQLParserNULL { + if _la == StarRocksSQLParserNOT || _la == StarRocksSQLParserNULL { { p.SetState(1564) p.ColumnNullable() @@ -16293,29 +16293,29 @@ func (p *DorisSQLParser) ColumnDesc() (localctx IColumnDescContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDEFAULT: + case StarRocksSQLParserDEFAULT: { p.SetState(1567) p.DefaultDesc() } - case DorisSQLParserAUTO_INCREMENT: + case StarRocksSQLParserAUTO_INCREMENT: { p.SetState(1568) - p.Match(DorisSQLParserAUTO_INCREMENT) + p.Match(StarRocksSQLParserAUTO_INCREMENT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserAS: + case StarRocksSQLParserAS: { p.SetState(1569) p.GeneratedColumnDesc() } - case DorisSQLParserEOF, DorisSQLParserT__2, DorisSQLParserT__3, DorisSQLParserAFTER, DorisSQLParserCOMMENT, DorisSQLParserFIRST, DorisSQLParserFROM, DorisSQLParserIN, DorisSQLParserPROPERTIES, DorisSQLParserTO, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserT__2, StarRocksSQLParserT__3, StarRocksSQLParserAFTER, StarRocksSQLParserCOMMENT, StarRocksSQLParserFIRST, StarRocksSQLParserFROM, StarRocksSQLParserIN, StarRocksSQLParserPROPERTIES, StarRocksSQLParserTO, StarRocksSQLParserSEMICOLON: default: } @@ -16326,7 +16326,7 @@ func (p *DorisSQLParser) ColumnDesc() (localctx IColumnDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(1572) p.Comment() @@ -16373,13 +16373,13 @@ type CharsetNameContext struct { func NewEmptyCharsetNameContext() *CharsetNameContext { var p = new(CharsetNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_charsetName + p.RuleIndex = StarRocksSQLParserRULE_charsetName return p } func InitEmptyCharsetNameContext(p *CharsetNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_charsetName + p.RuleIndex = StarRocksSQLParserRULE_charsetName } func (*CharsetNameContext) IsCharsetNameContext() {} @@ -16390,7 +16390,7 @@ func NewCharsetNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_charsetName + p.RuleIndex = StarRocksSQLParserRULE_charsetName return p } @@ -16398,11 +16398,11 @@ func NewCharsetNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *CharsetNameContext) GetParser() antlr.Parser { return s.parser } func (s *CharsetNameContext) CHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAR, 0) + return s.GetToken(StarRocksSQLParserCHAR, 0) } func (s *CharsetNameContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *CharsetNameContext) Identifier() IIdentifierContext { @@ -16422,11 +16422,11 @@ func (s *CharsetNameContext) Identifier() IIdentifierContext { } func (s *CharsetNameContext) CHARSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARSET, 0) + return s.GetToken(StarRocksSQLParserCHARSET, 0) } func (s *CharsetNameContext) CHARACTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARACTER, 0) + return s.GetToken(StarRocksSQLParserCHARACTER, 0) } func (s *CharsetNameContext) GetRuleContext() antlr.RuleContext { @@ -16438,20 +16438,20 @@ func (s *CharsetNameContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *CharsetNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCharsetName(s) } } func (s *CharsetNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCharsetName(s) } } func (s *CharsetNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCharsetName(s) default: @@ -16459,9 +16459,9 @@ func (s *CharsetNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) CharsetName() (localctx ICharsetNameContext) { +func (p *StarRocksSQLParser) CharsetName() (localctx ICharsetNameContext) { localctx = NewCharsetNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 34, DorisSQLParserRULE_charsetName) + p.EnterRule(localctx, 34, StarRocksSQLParserRULE_charsetName) p.SetState(1583) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -16469,11 +16469,11 @@ func (p *DorisSQLParser) CharsetName() (localctx ICharsetNameContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCHAR: + case StarRocksSQLParserCHAR: p.EnterOuterAlt(localctx, 1) { p.SetState(1575) - p.Match(DorisSQLParserCHAR) + p.Match(StarRocksSQLParserCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16481,7 +16481,7 @@ func (p *DorisSQLParser) CharsetName() (localctx ICharsetNameContext) { } { p.SetState(1576) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16492,11 +16492,11 @@ func (p *DorisSQLParser) CharsetName() (localctx ICharsetNameContext) { p.Identifier() } - case DorisSQLParserCHARSET: + case StarRocksSQLParserCHARSET: p.EnterOuterAlt(localctx, 2) { p.SetState(1578) - p.Match(DorisSQLParserCHARSET) + p.Match(StarRocksSQLParserCHARSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16507,11 +16507,11 @@ func (p *DorisSQLParser) CharsetName() (localctx ICharsetNameContext) { p.Identifier() } - case DorisSQLParserCHARACTER: + case StarRocksSQLParserCHARACTER: p.EnterOuterAlt(localctx, 3) { p.SetState(1580) - p.Match(DorisSQLParserCHARACTER) + p.Match(StarRocksSQLParserCHARACTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16519,7 +16519,7 @@ func (p *DorisSQLParser) CharsetName() (localctx ICharsetNameContext) { } { p.SetState(1581) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16574,13 +16574,13 @@ type DefaultDescContext struct { func NewEmptyDefaultDescContext() *DefaultDescContext { var p = new(DefaultDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_defaultDesc + p.RuleIndex = StarRocksSQLParserRULE_defaultDesc return p } func InitEmptyDefaultDescContext(p *DefaultDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_defaultDesc + p.RuleIndex = StarRocksSQLParserRULE_defaultDesc } func (*DefaultDescContext) IsDefaultDescContext() {} @@ -16591,7 +16591,7 @@ func NewDefaultDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_defaultDesc + p.RuleIndex = StarRocksSQLParserRULE_defaultDesc return p } @@ -16599,7 +16599,7 @@ func NewDefaultDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *DefaultDescContext) GetParser() antlr.Parser { return s.parser } func (s *DefaultDescContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *DefaultDescContext) String_() IStringContext { @@ -16619,11 +16619,11 @@ func (s *DefaultDescContext) String_() IStringContext { } func (s *DefaultDescContext) NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULL, 0) + return s.GetToken(StarRocksSQLParserNULL, 0) } func (s *DefaultDescContext) CURRENT_TIMESTAMP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_TIMESTAMP, 0) + return s.GetToken(StarRocksSQLParserCURRENT_TIMESTAMP, 0) } func (s *DefaultDescContext) QualifiedName() IQualifiedNameContext { @@ -16651,20 +16651,20 @@ func (s *DefaultDescContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *DefaultDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDefaultDesc(s) } } func (s *DefaultDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDefaultDesc(s) } } func (s *DefaultDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDefaultDesc(s) default: @@ -16672,13 +16672,13 @@ func (s *DefaultDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) DefaultDesc() (localctx IDefaultDescContext) { +func (p *StarRocksSQLParser) DefaultDesc() (localctx IDefaultDescContext) { localctx = NewDefaultDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 36, DorisSQLParserRULE_defaultDesc) + p.EnterRule(localctx, 36, StarRocksSQLParserRULE_defaultDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(1585) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16691,36 +16691,36 @@ func (p *DorisSQLParser) DefaultDesc() (localctx IDefaultDescContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(1586) p.String_() } - case DorisSQLParserNULL: + case StarRocksSQLParserNULL: { p.SetState(1587) - p.Match(DorisSQLParserNULL) + p.Match(StarRocksSQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCURRENT_TIMESTAMP: + case StarRocksSQLParserCURRENT_TIMESTAMP: { p.SetState(1588) - p.Match(DorisSQLParserCURRENT_TIMESTAMP) + p.Match(StarRocksSQLParserCURRENT_TIMESTAMP) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(1589) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16732,7 +16732,7 @@ func (p *DorisSQLParser) DefaultDesc() (localctx IDefaultDescContext) { } { p.SetState(1591) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16740,7 +16740,7 @@ func (p *DorisSQLParser) DefaultDesc() (localctx IDefaultDescContext) { } { p.SetState(1592) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16748,7 +16748,7 @@ func (p *DorisSQLParser) DefaultDesc() (localctx IDefaultDescContext) { } { p.SetState(1593) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16796,13 +16796,13 @@ type GeneratedColumnDescContext struct { func NewEmptyGeneratedColumnDescContext() *GeneratedColumnDescContext { var p = new(GeneratedColumnDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_generatedColumnDesc + p.RuleIndex = StarRocksSQLParserRULE_generatedColumnDesc return p } func InitEmptyGeneratedColumnDescContext(p *GeneratedColumnDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_generatedColumnDesc + p.RuleIndex = StarRocksSQLParserRULE_generatedColumnDesc } func (*GeneratedColumnDescContext) IsGeneratedColumnDescContext() {} @@ -16813,7 +16813,7 @@ func NewGeneratedColumnDescContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_generatedColumnDesc + p.RuleIndex = StarRocksSQLParserRULE_generatedColumnDesc return p } @@ -16821,7 +16821,7 @@ func NewGeneratedColumnDescContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *GeneratedColumnDescContext) GetParser() antlr.Parser { return s.parser } func (s *GeneratedColumnDescContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *GeneratedColumnDescContext) Expression() IExpressionContext { @@ -16849,20 +16849,20 @@ func (s *GeneratedColumnDescContext) ToStringTree(ruleNames []string, recog antl } func (s *GeneratedColumnDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGeneratedColumnDesc(s) } } func (s *GeneratedColumnDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGeneratedColumnDesc(s) } } func (s *GeneratedColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGeneratedColumnDesc(s) default: @@ -16870,13 +16870,13 @@ func (s *GeneratedColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) GeneratedColumnDesc() (localctx IGeneratedColumnDescContext) { +func (p *StarRocksSQLParser) GeneratedColumnDesc() (localctx IGeneratedColumnDescContext) { localctx = NewGeneratedColumnDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 38, DorisSQLParserRULE_generatedColumnDesc) + p.EnterRule(localctx, 38, StarRocksSQLParserRULE_generatedColumnDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(1597) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -16934,13 +16934,13 @@ type IndexDescContext struct { func NewEmptyIndexDescContext() *IndexDescContext { var p = new(IndexDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_indexDesc + p.RuleIndex = StarRocksSQLParserRULE_indexDesc return p } func InitEmptyIndexDescContext(p *IndexDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_indexDesc + p.RuleIndex = StarRocksSQLParserRULE_indexDesc } func (*IndexDescContext) IsIndexDescContext() {} @@ -16951,7 +16951,7 @@ func NewIndexDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_indexDesc + p.RuleIndex = StarRocksSQLParserRULE_indexDesc return p } @@ -16963,7 +16963,7 @@ func (s *IndexDescContext) GetIndexName() IIdentifierContext { return s.indexNam func (s *IndexDescContext) SetIndexName(v IIdentifierContext) { s.indexName = v } func (s *IndexDescContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *IndexDescContext) IdentifierList() IIdentifierListContext { @@ -17055,20 +17055,20 @@ func (s *IndexDescContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *IndexDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIndexDesc(s) } } func (s *IndexDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIndexDesc(s) } } func (s *IndexDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIndexDesc(s) default: @@ -17076,15 +17076,15 @@ func (s *IndexDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) IndexDesc() (localctx IIndexDescContext) { +func (p *StarRocksSQLParser) IndexDesc() (localctx IIndexDescContext) { localctx = NewIndexDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 40, DorisSQLParserRULE_indexDesc) + p.EnterRule(localctx, 40, StarRocksSQLParserRULE_indexDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1600) - p.Match(DorisSQLParserINDEX) + p.Match(StarRocksSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17108,7 +17108,7 @@ func (p *DorisSQLParser) IndexDesc() (localctx IIndexDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserUSING { + if _la == StarRocksSQLParserUSING { { p.SetState(1603) p.IndexType() @@ -17120,7 +17120,7 @@ func (p *DorisSQLParser) IndexDesc() (localctx IIndexDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(1604) p.PropertyList() @@ -17136,7 +17136,7 @@ func (p *DorisSQLParser) IndexDesc() (localctx IIndexDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(1609) p.Comment() @@ -17181,13 +17181,13 @@ type EngineDescContext struct { func NewEmptyEngineDescContext() *EngineDescContext { var p = new(EngineDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_engineDesc + p.RuleIndex = StarRocksSQLParserRULE_engineDesc return p } func InitEmptyEngineDescContext(p *EngineDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_engineDesc + p.RuleIndex = StarRocksSQLParserRULE_engineDesc } func (*EngineDescContext) IsEngineDescContext() {} @@ -17198,7 +17198,7 @@ func NewEngineDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_engineDesc + p.RuleIndex = StarRocksSQLParserRULE_engineDesc return p } @@ -17206,11 +17206,11 @@ func NewEngineDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *EngineDescContext) GetParser() antlr.Parser { return s.parser } func (s *EngineDescContext) ENGINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENGINE, 0) + return s.GetToken(StarRocksSQLParserENGINE, 0) } func (s *EngineDescContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *EngineDescContext) Identifier() IIdentifierContext { @@ -17238,20 +17238,20 @@ func (s *EngineDescContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *EngineDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterEngineDesc(s) } } func (s *EngineDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitEngineDesc(s) } } func (s *EngineDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitEngineDesc(s) default: @@ -17259,13 +17259,13 @@ func (s *EngineDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) EngineDesc() (localctx IEngineDescContext) { +func (p *StarRocksSQLParser) EngineDesc() (localctx IEngineDescContext) { localctx = NewEngineDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 42, DorisSQLParserRULE_engineDesc) + p.EnterRule(localctx, 42, StarRocksSQLParserRULE_engineDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(1612) - p.Match(DorisSQLParserENGINE) + p.Match(StarRocksSQLParserENGINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17273,7 +17273,7 @@ func (p *DorisSQLParser) EngineDesc() (localctx IEngineDescContext) { } { p.SetState(1613) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17325,13 +17325,13 @@ type CharsetDescContext struct { func NewEmptyCharsetDescContext() *CharsetDescContext { var p = new(CharsetDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_charsetDesc + p.RuleIndex = StarRocksSQLParserRULE_charsetDesc return p } func InitEmptyCharsetDescContext(p *CharsetDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_charsetDesc + p.RuleIndex = StarRocksSQLParserRULE_charsetDesc } func (*CharsetDescContext) IsCharsetDescContext() {} @@ -17342,7 +17342,7 @@ func NewCharsetDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_charsetDesc + p.RuleIndex = StarRocksSQLParserRULE_charsetDesc return p } @@ -17366,27 +17366,27 @@ func (s *CharsetDescContext) IdentifierOrString() IIdentifierOrStringContext { } func (s *CharsetDescContext) CHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAR, 0) + return s.GetToken(StarRocksSQLParserCHAR, 0) } func (s *CharsetDescContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *CharsetDescContext) CHARSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARSET, 0) + return s.GetToken(StarRocksSQLParserCHARSET, 0) } func (s *CharsetDescContext) CHARACTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARACTER, 0) + return s.GetToken(StarRocksSQLParserCHARACTER, 0) } func (s *CharsetDescContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *CharsetDescContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *CharsetDescContext) GetRuleContext() antlr.RuleContext { @@ -17398,20 +17398,20 @@ func (s *CharsetDescContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *CharsetDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCharsetDesc(s) } } func (s *CharsetDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCharsetDesc(s) } } func (s *CharsetDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCharsetDesc(s) default: @@ -17419,9 +17419,9 @@ func (s *CharsetDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) CharsetDesc() (localctx ICharsetDescContext) { +func (p *StarRocksSQLParser) CharsetDesc() (localctx ICharsetDescContext) { localctx = NewCharsetDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 44, DorisSQLParserRULE_charsetDesc) + p.EnterRule(localctx, 44, StarRocksSQLParserRULE_charsetDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -17432,10 +17432,10 @@ func (p *DorisSQLParser) CharsetDesc() (localctx ICharsetDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDEFAULT { + if _la == StarRocksSQLParserDEFAULT { { p.SetState(1616) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17450,10 +17450,10 @@ func (p *DorisSQLParser) CharsetDesc() (localctx ICharsetDescContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCHAR: + case StarRocksSQLParserCHAR: { p.SetState(1619) - p.Match(DorisSQLParserCHAR) + p.Match(StarRocksSQLParserCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17461,27 +17461,27 @@ func (p *DorisSQLParser) CharsetDesc() (localctx ICharsetDescContext) { } { p.SetState(1620) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCHARSET: + case StarRocksSQLParserCHARSET: { p.SetState(1621) - p.Match(DorisSQLParserCHARSET) + p.Match(StarRocksSQLParserCHARSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCHARACTER: + case StarRocksSQLParserCHARACTER: { p.SetState(1622) - p.Match(DorisSQLParserCHARACTER) + p.Match(StarRocksSQLParserCHARACTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17489,7 +17489,7 @@ func (p *DorisSQLParser) CharsetDesc() (localctx ICharsetDescContext) { } { p.SetState(1623) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17507,10 +17507,10 @@ func (p *DorisSQLParser) CharsetDesc() (localctx ICharsetDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEQ { + if _la == StarRocksSQLParserEQ { { p.SetState(1626) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17561,13 +17561,13 @@ type CollateDescContext struct { func NewEmptyCollateDescContext() *CollateDescContext { var p = new(CollateDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_collateDesc + p.RuleIndex = StarRocksSQLParserRULE_collateDesc return p } func InitEmptyCollateDescContext(p *CollateDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_collateDesc + p.RuleIndex = StarRocksSQLParserRULE_collateDesc } func (*CollateDescContext) IsCollateDescContext() {} @@ -17578,7 +17578,7 @@ func NewCollateDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_collateDesc + p.RuleIndex = StarRocksSQLParserRULE_collateDesc return p } @@ -17586,7 +17586,7 @@ func NewCollateDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *CollateDescContext) GetParser() antlr.Parser { return s.parser } func (s *CollateDescContext) COLLATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLLATE, 0) + return s.GetToken(StarRocksSQLParserCOLLATE, 0) } func (s *CollateDescContext) IdentifierOrString() IIdentifierOrStringContext { @@ -17606,11 +17606,11 @@ func (s *CollateDescContext) IdentifierOrString() IIdentifierOrStringContext { } func (s *CollateDescContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *CollateDescContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *CollateDescContext) GetRuleContext() antlr.RuleContext { @@ -17622,20 +17622,20 @@ func (s *CollateDescContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *CollateDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCollateDesc(s) } } func (s *CollateDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCollateDesc(s) } } func (s *CollateDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCollateDesc(s) default: @@ -17643,9 +17643,9 @@ func (s *CollateDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) CollateDesc() (localctx ICollateDescContext) { +func (p *StarRocksSQLParser) CollateDesc() (localctx ICollateDescContext) { localctx = NewCollateDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 46, DorisSQLParserRULE_collateDesc) + p.EnterRule(localctx, 46, StarRocksSQLParserRULE_collateDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -17656,10 +17656,10 @@ func (p *DorisSQLParser) CollateDesc() (localctx ICollateDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDEFAULT { + if _la == StarRocksSQLParserDEFAULT { { p.SetState(1631) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17669,7 +17669,7 @@ func (p *DorisSQLParser) CollateDesc() (localctx ICollateDescContext) { } { p.SetState(1634) - p.Match(DorisSQLParserCOLLATE) + p.Match(StarRocksSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17682,10 +17682,10 @@ func (p *DorisSQLParser) CollateDesc() (localctx ICollateDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEQ { + if _la == StarRocksSQLParserEQ { { p.SetState(1635) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17738,13 +17738,13 @@ type KeyDescContext struct { func NewEmptyKeyDescContext() *KeyDescContext { var p = new(KeyDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_keyDesc + p.RuleIndex = StarRocksSQLParserRULE_keyDesc return p } func InitEmptyKeyDescContext(p *KeyDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_keyDesc + p.RuleIndex = StarRocksSQLParserRULE_keyDesc } func (*KeyDescContext) IsKeyDescContext() {} @@ -17755,7 +17755,7 @@ func NewKeyDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_keyDesc + p.RuleIndex = StarRocksSQLParserRULE_keyDesc return p } @@ -17763,7 +17763,7 @@ func NewKeyDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *KeyDescContext) GetParser() antlr.Parser { return s.parser } func (s *KeyDescContext) KEY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEY, 0) + return s.GetToken(StarRocksSQLParserKEY, 0) } func (s *KeyDescContext) IdentifierList() IIdentifierListContext { @@ -17783,19 +17783,19 @@ func (s *KeyDescContext) IdentifierList() IIdentifierListContext { } func (s *KeyDescContext) AGGREGATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAGGREGATE, 0) + return s.GetToken(StarRocksSQLParserAGGREGATE, 0) } func (s *KeyDescContext) UNIQUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNIQUE, 0) + return s.GetToken(StarRocksSQLParserUNIQUE, 0) } func (s *KeyDescContext) PRIMARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIMARY, 0) + return s.GetToken(StarRocksSQLParserPRIMARY, 0) } func (s *KeyDescContext) DUPLICATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDUPLICATE, 0) + return s.GetToken(StarRocksSQLParserDUPLICATE, 0) } func (s *KeyDescContext) GetRuleContext() antlr.RuleContext { @@ -17807,20 +17807,20 @@ func (s *KeyDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *KeyDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterKeyDesc(s) } } func (s *KeyDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitKeyDesc(s) } } func (s *KeyDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitKeyDesc(s) default: @@ -17828,9 +17828,9 @@ func (s *KeyDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) KeyDesc() (localctx IKeyDescContext) { +func (p *StarRocksSQLParser) KeyDesc() (localctx IKeyDescContext) { localctx = NewKeyDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 48, DorisSQLParserRULE_keyDesc) + p.EnterRule(localctx, 48, StarRocksSQLParserRULE_keyDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -17838,7 +17838,7 @@ func (p *DorisSQLParser) KeyDesc() (localctx IKeyDescContext) { p.SetState(1640) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserAGGREGATE || _la == DorisSQLParserDUPLICATE || _la == DorisSQLParserPRIMARY || _la == DorisSQLParserUNIQUE) { + if !(_la == StarRocksSQLParserAGGREGATE || _la == StarRocksSQLParserDUPLICATE || _la == StarRocksSQLParserPRIMARY || _la == StarRocksSQLParserUNIQUE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -17847,7 +17847,7 @@ func (p *DorisSQLParser) KeyDesc() (localctx IKeyDescContext) { } { p.SetState(1641) - p.Match(DorisSQLParserKEY) + p.Match(StarRocksSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17895,13 +17895,13 @@ type OrderByDescContext struct { func NewEmptyOrderByDescContext() *OrderByDescContext { var p = new(OrderByDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_orderByDesc + p.RuleIndex = StarRocksSQLParserRULE_orderByDesc return p } func InitEmptyOrderByDescContext(p *OrderByDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_orderByDesc + p.RuleIndex = StarRocksSQLParserRULE_orderByDesc } func (*OrderByDescContext) IsOrderByDescContext() {} @@ -17912,7 +17912,7 @@ func NewOrderByDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_orderByDesc + p.RuleIndex = StarRocksSQLParserRULE_orderByDesc return p } @@ -17920,11 +17920,11 @@ func NewOrderByDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *OrderByDescContext) GetParser() antlr.Parser { return s.parser } func (s *OrderByDescContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *OrderByDescContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *OrderByDescContext) IdentifierList() IIdentifierListContext { @@ -17952,20 +17952,20 @@ func (s *OrderByDescContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *OrderByDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOrderByDesc(s) } } func (s *OrderByDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOrderByDesc(s) } } func (s *OrderByDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOrderByDesc(s) default: @@ -17973,13 +17973,13 @@ func (s *OrderByDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) OrderByDesc() (localctx IOrderByDescContext) { +func (p *StarRocksSQLParser) OrderByDesc() (localctx IOrderByDescContext) { localctx = NewOrderByDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 50, DorisSQLParserRULE_orderByDesc) + p.EnterRule(localctx, 50, StarRocksSQLParserRULE_orderByDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(1644) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -17987,7 +17987,7 @@ func (p *DorisSQLParser) OrderByDesc() (localctx IOrderByDescContext) { } { p.SetState(1645) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18034,13 +18034,13 @@ type ColumnNullableContext struct { func NewEmptyColumnNullableContext() *ColumnNullableContext { var p = new(ColumnNullableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnNullable + p.RuleIndex = StarRocksSQLParserRULE_columnNullable return p } func InitEmptyColumnNullableContext(p *ColumnNullableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnNullable + p.RuleIndex = StarRocksSQLParserRULE_columnNullable } func (*ColumnNullableContext) IsColumnNullableContext() {} @@ -18051,7 +18051,7 @@ func NewColumnNullableContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnNullable + p.RuleIndex = StarRocksSQLParserRULE_columnNullable return p } @@ -18059,11 +18059,11 @@ func NewColumnNullableContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *ColumnNullableContext) GetParser() antlr.Parser { return s.parser } func (s *ColumnNullableContext) NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULL, 0) + return s.GetToken(StarRocksSQLParserNULL, 0) } func (s *ColumnNullableContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *ColumnNullableContext) GetRuleContext() antlr.RuleContext { @@ -18075,20 +18075,20 @@ func (s *ColumnNullableContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *ColumnNullableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnNullable(s) } } func (s *ColumnNullableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnNullable(s) } } func (s *ColumnNullableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnNullable(s) default: @@ -18096,9 +18096,9 @@ func (s *ColumnNullableContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) ColumnNullable() (localctx IColumnNullableContext) { +func (p *StarRocksSQLParser) ColumnNullable() (localctx IColumnNullableContext) { localctx = NewColumnNullableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 52, DorisSQLParserRULE_columnNullable) + p.EnterRule(localctx, 52, StarRocksSQLParserRULE_columnNullable) p.SetState(1651) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -18106,22 +18106,22 @@ func (p *DorisSQLParser) ColumnNullable() (localctx IColumnNullableContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserNULL: + case StarRocksSQLParserNULL: p.EnterOuterAlt(localctx, 1) { p.SetState(1648) - p.Match(DorisSQLParserNULL) + p.Match(StarRocksSQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserNOT: + case StarRocksSQLParserNOT: p.EnterOuterAlt(localctx, 2) { p.SetState(1649) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18129,7 +18129,7 @@ func (p *DorisSQLParser) ColumnNullable() (localctx IColumnNullableContext) { } { p.SetState(1650) - p.Match(DorisSQLParserNULL) + p.Match(StarRocksSQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18177,13 +18177,13 @@ type TypeWithNullableContext struct { func NewEmptyTypeWithNullableContext() *TypeWithNullableContext { var p = new(TypeWithNullableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeWithNullable + p.RuleIndex = StarRocksSQLParserRULE_typeWithNullable return p } func InitEmptyTypeWithNullableContext(p *TypeWithNullableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeWithNullable + p.RuleIndex = StarRocksSQLParserRULE_typeWithNullable } func (*TypeWithNullableContext) IsTypeWithNullableContext() {} @@ -18194,7 +18194,7 @@ func NewTypeWithNullableContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_typeWithNullable + p.RuleIndex = StarRocksSQLParserRULE_typeWithNullable return p } @@ -18242,20 +18242,20 @@ func (s *TypeWithNullableContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *TypeWithNullableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTypeWithNullable(s) } } func (s *TypeWithNullableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTypeWithNullable(s) } } func (s *TypeWithNullableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTypeWithNullable(s) default: @@ -18263,9 +18263,9 @@ func (s *TypeWithNullableContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) TypeWithNullable() (localctx ITypeWithNullableContext) { +func (p *StarRocksSQLParser) TypeWithNullable() (localctx ITypeWithNullableContext) { localctx = NewTypeWithNullableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 54, DorisSQLParserRULE_typeWithNullable) + p.EnterRule(localctx, 54, StarRocksSQLParserRULE_typeWithNullable) var _la int p.EnterOuterAlt(localctx, 1) @@ -18280,7 +18280,7 @@ func (p *DorisSQLParser) TypeWithNullable() (localctx ITypeWithNullableContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT || _la == DorisSQLParserNULL { + if _la == StarRocksSQLParserNOT || _la == StarRocksSQLParserNULL { { p.SetState(1654) p.ColumnNullable() @@ -18325,13 +18325,13 @@ type AggStateDescContext struct { func NewEmptyAggStateDescContext() *AggStateDescContext { var p = new(AggStateDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_aggStateDesc + p.RuleIndex = StarRocksSQLParserRULE_aggStateDesc return p } func InitEmptyAggStateDescContext(p *AggStateDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_aggStateDesc + p.RuleIndex = StarRocksSQLParserRULE_aggStateDesc } func (*AggStateDescContext) IsAggStateDescContext() {} @@ -18342,7 +18342,7 @@ func NewAggStateDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_aggStateDesc + p.RuleIndex = StarRocksSQLParserRULE_aggStateDesc return p } @@ -18415,20 +18415,20 @@ func (s *AggStateDescContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *AggStateDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAggStateDesc(s) } } func (s *AggStateDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAggStateDesc(s) } } func (s *AggStateDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAggStateDesc(s) default: @@ -18436,9 +18436,9 @@ func (s *AggStateDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) AggStateDesc() (localctx IAggStateDescContext) { +func (p *StarRocksSQLParser) AggStateDesc() (localctx IAggStateDescContext) { localctx = NewAggStateDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 56, DorisSQLParserRULE_aggStateDesc) + p.EnterRule(localctx, 56, StarRocksSQLParserRULE_aggStateDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -18448,7 +18448,7 @@ func (p *DorisSQLParser) AggStateDesc() (localctx IAggStateDescContext) { } { p.SetState(1658) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18465,10 +18465,10 @@ func (p *DorisSQLParser) AggStateDesc() (localctx IAggStateDescContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1660) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18488,7 +18488,7 @@ func (p *DorisSQLParser) AggStateDesc() (localctx IAggStateDescContext) { } { p.SetState(1667) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18538,13 +18538,13 @@ type AggDescContext struct { func NewEmptyAggDescContext() *AggDescContext { var p = new(AggDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_aggDesc + p.RuleIndex = StarRocksSQLParserRULE_aggDesc return p } func InitEmptyAggDescContext(p *AggDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_aggDesc + p.RuleIndex = StarRocksSQLParserRULE_aggDesc } func (*AggDescContext) IsAggDescContext() {} @@ -18555,7 +18555,7 @@ func NewAggDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_aggDesc + p.RuleIndex = StarRocksSQLParserRULE_aggDesc return p } @@ -18563,35 +18563,35 @@ func NewAggDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *AggDescContext) GetParser() antlr.Parser { return s.parser } func (s *AggDescContext) SUM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUM, 0) + return s.GetToken(StarRocksSQLParserSUM, 0) } func (s *AggDescContext) MAX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAX, 0) + return s.GetToken(StarRocksSQLParserMAX, 0) } func (s *AggDescContext) MIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMIN, 0) + return s.GetToken(StarRocksSQLParserMIN, 0) } func (s *AggDescContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *AggDescContext) HLL_UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHLL_UNION, 0) + return s.GetToken(StarRocksSQLParserHLL_UNION, 0) } func (s *AggDescContext) BITMAP_UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITMAP_UNION, 0) + return s.GetToken(StarRocksSQLParserBITMAP_UNION, 0) } func (s *AggDescContext) PERCENTILE_UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERCENTILE_UNION, 0) + return s.GetToken(StarRocksSQLParserPERCENTILE_UNION, 0) } func (s *AggDescContext) REPLACE_IF_NOT_NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE_IF_NOT_NULL, 0) + return s.GetToken(StarRocksSQLParserREPLACE_IF_NOT_NULL, 0) } func (s *AggDescContext) AggStateDesc() IAggStateDescContext { @@ -18619,20 +18619,20 @@ func (s *AggDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *AggDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAggDesc(s) } } func (s *AggDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAggDesc(s) } } func (s *AggDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAggDesc(s) default: @@ -18640,9 +18640,9 @@ func (s *AggDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { +func (p *StarRocksSQLParser) AggDesc() (localctx IAggDescContext) { localctx = NewAggDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 58, DorisSQLParserRULE_aggDesc) + p.EnterRule(localctx, 58, StarRocksSQLParserRULE_aggDesc) p.SetState(1678) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -18654,7 +18654,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(1669) - p.Match(DorisSQLParserSUM) + p.Match(StarRocksSQLParserSUM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18665,7 +18665,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(1670) - p.Match(DorisSQLParserMAX) + p.Match(StarRocksSQLParserMAX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18676,7 +18676,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(1671) - p.Match(DorisSQLParserMIN) + p.Match(StarRocksSQLParserMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18687,7 +18687,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(1672) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18698,7 +18698,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 5) { p.SetState(1673) - p.Match(DorisSQLParserHLL_UNION) + p.Match(StarRocksSQLParserHLL_UNION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18709,7 +18709,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 6) { p.SetState(1674) - p.Match(DorisSQLParserBITMAP_UNION) + p.Match(StarRocksSQLParserBITMAP_UNION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18720,7 +18720,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 7) { p.SetState(1675) - p.Match(DorisSQLParserPERCENTILE_UNION) + p.Match(StarRocksSQLParserPERCENTILE_UNION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18731,7 +18731,7 @@ func (p *DorisSQLParser) AggDesc() (localctx IAggDescContext) { p.EnterOuterAlt(localctx, 8) { p.SetState(1676) - p.Match(DorisSQLParserREPLACE_IF_NOT_NULL) + p.Match(StarRocksSQLParserREPLACE_IF_NOT_NULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18786,13 +18786,13 @@ type RollupDescContext struct { func NewEmptyRollupDescContext() *RollupDescContext { var p = new(RollupDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollupDesc + p.RuleIndex = StarRocksSQLParserRULE_rollupDesc return p } func InitEmptyRollupDescContext(p *RollupDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollupDesc + p.RuleIndex = StarRocksSQLParserRULE_rollupDesc } func (*RollupDescContext) IsRollupDescContext() {} @@ -18803,7 +18803,7 @@ func NewRollupDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rollupDesc + p.RuleIndex = StarRocksSQLParserRULE_rollupDesc return p } @@ -18811,7 +18811,7 @@ func NewRollupDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *RollupDescContext) GetParser() antlr.Parser { return s.parser } func (s *RollupDescContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *RollupDescContext) AllRollupItem() []IRollupItemContext { @@ -18864,20 +18864,20 @@ func (s *RollupDescContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *RollupDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRollupDesc(s) } } func (s *RollupDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRollupDesc(s) } } func (s *RollupDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRollupDesc(s) default: @@ -18885,15 +18885,15 @@ func (s *RollupDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) RollupDesc() (localctx IRollupDescContext) { +func (p *StarRocksSQLParser) RollupDesc() (localctx IRollupDescContext) { localctx = NewRollupDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 60, DorisSQLParserRULE_rollupDesc) + p.EnterRule(localctx, 60, StarRocksSQLParserRULE_rollupDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1680) - p.Match(DorisSQLParserROLLUP) + p.Match(StarRocksSQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18901,7 +18901,7 @@ func (p *DorisSQLParser) RollupDesc() (localctx IRollupDescContext) { } { p.SetState(1681) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18918,10 +18918,10 @@ func (p *DorisSQLParser) RollupDesc() (localctx IRollupDescContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1683) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18941,7 +18941,7 @@ func (p *DorisSQLParser) RollupDesc() (localctx IRollupDescContext) { } { p.SetState(1690) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -18994,13 +18994,13 @@ type RollupItemContext struct { func NewEmptyRollupItemContext() *RollupItemContext { var p = new(RollupItemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollupItem + p.RuleIndex = StarRocksSQLParserRULE_rollupItem return p } func InitEmptyRollupItemContext(p *RollupItemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollupItem + p.RuleIndex = StarRocksSQLParserRULE_rollupItem } func (*RollupItemContext) IsRollupItemContext() {} @@ -19011,7 +19011,7 @@ func NewRollupItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rollupItem + p.RuleIndex = StarRocksSQLParserRULE_rollupItem return p } @@ -19111,20 +19111,20 @@ func (s *RollupItemContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *RollupItemContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRollupItem(s) } } func (s *RollupItemContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRollupItem(s) } } func (s *RollupItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRollupItem(s) default: @@ -19132,9 +19132,9 @@ func (s *RollupItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) RollupItem() (localctx IRollupItemContext) { +func (p *StarRocksSQLParser) RollupItem() (localctx IRollupItemContext) { localctx = NewRollupItemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 62, DorisSQLParserRULE_rollupItem) + p.EnterRule(localctx, 62, StarRocksSQLParserRULE_rollupItem) var _la int p.EnterOuterAlt(localctx, 1) @@ -19156,7 +19156,7 @@ func (p *DorisSQLParser) RollupItem() (localctx IRollupItemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDUPLICATE { + if _la == StarRocksSQLParserDUPLICATE { { p.SetState(1694) p.DupKeys() @@ -19170,7 +19170,7 @@ func (p *DorisSQLParser) RollupItem() (localctx IRollupItemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(1697) p.FromRollup() @@ -19184,7 +19184,7 @@ func (p *DorisSQLParser) RollupItem() (localctx IRollupItemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(1700) p.Properties() @@ -19229,13 +19229,13 @@ type DupKeysContext struct { func NewEmptyDupKeysContext() *DupKeysContext { var p = new(DupKeysContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dupKeys + p.RuleIndex = StarRocksSQLParserRULE_dupKeys return p } func InitEmptyDupKeysContext(p *DupKeysContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dupKeys + p.RuleIndex = StarRocksSQLParserRULE_dupKeys } func (*DupKeysContext) IsDupKeysContext() {} @@ -19246,7 +19246,7 @@ func NewDupKeysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dupKeys + p.RuleIndex = StarRocksSQLParserRULE_dupKeys return p } @@ -19254,11 +19254,11 @@ func NewDupKeysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *DupKeysContext) GetParser() antlr.Parser { return s.parser } func (s *DupKeysContext) DUPLICATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDUPLICATE, 0) + return s.GetToken(StarRocksSQLParserDUPLICATE, 0) } func (s *DupKeysContext) KEY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEY, 0) + return s.GetToken(StarRocksSQLParserKEY, 0) } func (s *DupKeysContext) IdentifierList() IIdentifierListContext { @@ -19286,20 +19286,20 @@ func (s *DupKeysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *DupKeysContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDupKeys(s) } } func (s *DupKeysContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDupKeys(s) } } func (s *DupKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDupKeys(s) default: @@ -19307,13 +19307,13 @@ func (s *DupKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) DupKeys() (localctx IDupKeysContext) { +func (p *StarRocksSQLParser) DupKeys() (localctx IDupKeysContext) { localctx = NewDupKeysContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 64, DorisSQLParserRULE_dupKeys) + p.EnterRule(localctx, 64, StarRocksSQLParserRULE_dupKeys) p.EnterOuterAlt(localctx, 1) { p.SetState(1703) - p.Match(DorisSQLParserDUPLICATE) + p.Match(StarRocksSQLParserDUPLICATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19321,7 +19321,7 @@ func (p *DorisSQLParser) DupKeys() (localctx IDupKeysContext) { } { p.SetState(1704) - p.Match(DorisSQLParserKEY) + p.Match(StarRocksSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19368,13 +19368,13 @@ type FromRollupContext struct { func NewEmptyFromRollupContext() *FromRollupContext { var p = new(FromRollupContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_fromRollup + p.RuleIndex = StarRocksSQLParserRULE_fromRollup return p } func InitEmptyFromRollupContext(p *FromRollupContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_fromRollup + p.RuleIndex = StarRocksSQLParserRULE_fromRollup } func (*FromRollupContext) IsFromRollupContext() {} @@ -19385,7 +19385,7 @@ func NewFromRollupContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_fromRollup + p.RuleIndex = StarRocksSQLParserRULE_fromRollup return p } @@ -19393,7 +19393,7 @@ func NewFromRollupContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *FromRollupContext) GetParser() antlr.Parser { return s.parser } func (s *FromRollupContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *FromRollupContext) Identifier() IIdentifierContext { @@ -19421,20 +19421,20 @@ func (s *FromRollupContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *FromRollupContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterFromRollup(s) } } func (s *FromRollupContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitFromRollup(s) } } func (s *FromRollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitFromRollup(s) default: @@ -19442,13 +19442,13 @@ func (s *FromRollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) FromRollup() (localctx IFromRollupContext) { +func (p *StarRocksSQLParser) FromRollup() (localctx IFromRollupContext) { localctx = NewFromRollupContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 66, DorisSQLParserRULE_fromRollup) + p.EnterRule(localctx, 66, StarRocksSQLParserRULE_fromRollup) p.EnterOuterAlt(localctx, 1) { p.SetState(1707) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19495,13 +19495,13 @@ type OrReplaceContext struct { func NewEmptyOrReplaceContext() *OrReplaceContext { var p = new(OrReplaceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_orReplace + p.RuleIndex = StarRocksSQLParserRULE_orReplace return p } func InitEmptyOrReplaceContext(p *OrReplaceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_orReplace + p.RuleIndex = StarRocksSQLParserRULE_orReplace } func (*OrReplaceContext) IsOrReplaceContext() {} @@ -19512,7 +19512,7 @@ func NewOrReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_orReplace + p.RuleIndex = StarRocksSQLParserRULE_orReplace return p } @@ -19520,11 +19520,11 @@ func NewOrReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *OrReplaceContext) GetParser() antlr.Parser { return s.parser } func (s *OrReplaceContext) OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOR, 0) + return s.GetToken(StarRocksSQLParserOR, 0) } func (s *OrReplaceContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *OrReplaceContext) GetRuleContext() antlr.RuleContext { @@ -19536,20 +19536,20 @@ func (s *OrReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *OrReplaceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOrReplace(s) } } func (s *OrReplaceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOrReplace(s) } } func (s *OrReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOrReplace(s) default: @@ -19557,9 +19557,9 @@ func (s *OrReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) OrReplace() (localctx IOrReplaceContext) { +func (p *StarRocksSQLParser) OrReplace() (localctx IOrReplaceContext) { localctx = NewOrReplaceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 68, DorisSQLParserRULE_orReplace) + p.EnterRule(localctx, 68, StarRocksSQLParserRULE_orReplace) var _la int p.EnterOuterAlt(localctx, 1) @@ -19570,10 +19570,10 @@ func (p *DorisSQLParser) OrReplace() (localctx IOrReplaceContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserOR { + if _la == StarRocksSQLParserOR { { p.SetState(1710) - p.Match(DorisSQLParserOR) + p.Match(StarRocksSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19581,7 +19581,7 @@ func (p *DorisSQLParser) OrReplace() (localctx IOrReplaceContext) { } { p.SetState(1711) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19627,13 +19627,13 @@ type IfNotExistsContext struct { func NewEmptyIfNotExistsContext() *IfNotExistsContext { var p = new(IfNotExistsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_ifNotExists + p.RuleIndex = StarRocksSQLParserRULE_ifNotExists return p } func InitEmptyIfNotExistsContext(p *IfNotExistsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_ifNotExists + p.RuleIndex = StarRocksSQLParserRULE_ifNotExists } func (*IfNotExistsContext) IsIfNotExistsContext() {} @@ -19644,7 +19644,7 @@ func NewIfNotExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_ifNotExists + p.RuleIndex = StarRocksSQLParserRULE_ifNotExists return p } @@ -19652,15 +19652,15 @@ func NewIfNotExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *IfNotExistsContext) GetParser() antlr.Parser { return s.parser } func (s *IfNotExistsContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *IfNotExistsContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *IfNotExistsContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *IfNotExistsContext) GetRuleContext() antlr.RuleContext { @@ -19672,20 +19672,20 @@ func (s *IfNotExistsContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *IfNotExistsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIfNotExists(s) } } func (s *IfNotExistsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIfNotExists(s) } } func (s *IfNotExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIfNotExists(s) default: @@ -19693,9 +19693,9 @@ func (s *IfNotExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) IfNotExists() (localctx IIfNotExistsContext) { +func (p *StarRocksSQLParser) IfNotExists() (localctx IIfNotExistsContext) { localctx = NewIfNotExistsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 70, DorisSQLParserRULE_ifNotExists) + p.EnterRule(localctx, 70, StarRocksSQLParserRULE_ifNotExists) var _la int p.EnterOuterAlt(localctx, 1) @@ -19706,10 +19706,10 @@ func (p *DorisSQLParser) IfNotExists() (localctx IIfNotExistsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(1714) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19717,7 +19717,7 @@ func (p *DorisSQLParser) IfNotExists() (localctx IIfNotExistsContext) { } { p.SetState(1715) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19725,7 +19725,7 @@ func (p *DorisSQLParser) IfNotExists() (localctx IIfNotExistsContext) { } { p.SetState(1716) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -19787,13 +19787,13 @@ type CreateTableAsSelectStatementContext struct { func NewEmptyCreateTableAsSelectStatementContext() *CreateTableAsSelectStatementContext { var p = new(CreateTableAsSelectStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createTableAsSelectStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableAsSelectStatement return p } func InitEmptyCreateTableAsSelectStatementContext(p *CreateTableAsSelectStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createTableAsSelectStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableAsSelectStatement } func (*CreateTableAsSelectStatementContext) IsCreateTableAsSelectStatementContext() {} @@ -19804,7 +19804,7 @@ func NewCreateTableAsSelectStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createTableAsSelectStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableAsSelectStatement return p } @@ -19812,11 +19812,11 @@ func NewCreateTableAsSelectStatementContext(parser antlr.Parser, parent antlr.Pa func (s *CreateTableAsSelectStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateTableAsSelectStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateTableAsSelectStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CreateTableAsSelectStatementContext) QualifiedName() IQualifiedNameContext { @@ -19836,7 +19836,7 @@ func (s *CreateTableAsSelectStatementContext) QualifiedName() IQualifiedNameCont } func (s *CreateTableAsSelectStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *CreateTableAsSelectStatementContext) QueryStatement() IQueryStatementContext { @@ -19856,19 +19856,19 @@ func (s *CreateTableAsSelectStatementContext) QueryStatement() IQueryStatementCo } func (s *CreateTableAsSelectStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *CreateTableAsSelectStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateTableAsSelectStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateTableAsSelectStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateTableAsSelectStatementContext) KeyDesc() IKeyDescContext { @@ -20058,20 +20058,20 @@ func (s *CreateTableAsSelectStatementContext) ToStringTree(ruleNames []string, r } func (s *CreateTableAsSelectStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateTableAsSelectStatement(s) } } func (s *CreateTableAsSelectStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateTableAsSelectStatement(s) } } func (s *CreateTableAsSelectStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateTableAsSelectStatement(s) default: @@ -20079,9 +20079,9 @@ func (s *CreateTableAsSelectStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAsSelectStatementContext) { +func (p *StarRocksSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAsSelectStatementContext) { localctx = NewCreateTableAsSelectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 72, DorisSQLParserRULE_createTableAsSelectStatement) + p.EnterRule(localctx, 72, StarRocksSQLParserRULE_createTableAsSelectStatement) var _la int var _alt int @@ -20089,7 +20089,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs p.EnterOuterAlt(localctx, 1) { p.SetState(1719) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20102,10 +20102,10 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(1720) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20115,7 +20115,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } { p.SetState(1723) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20128,10 +20128,10 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(1724) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20139,7 +20139,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } { p.SetState(1725) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20147,7 +20147,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } { p.SetState(1726) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20166,10 +20166,10 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(1730) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20182,7 +20182,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(1731) p.Identifier() @@ -20200,7 +20200,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs if _alt == 1 { { p.SetState(1732) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20229,10 +20229,10 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1739) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20251,7 +20251,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs _la = p.GetTokenStream().LA(1) } - case DorisSQLParserINDEX: + case StarRocksSQLParserINDEX: { p.SetState(1746) p.IndexDesc() @@ -20263,10 +20263,10 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1747) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20291,7 +20291,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } { p.SetState(1756) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20306,7 +20306,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAGGREGATE || _la == DorisSQLParserDUPLICATE || _la == DorisSQLParserPRIMARY || _la == DorisSQLParserUNIQUE { + if _la == StarRocksSQLParserAGGREGATE || _la == StarRocksSQLParserDUPLICATE || _la == StarRocksSQLParserPRIMARY || _la == StarRocksSQLParserUNIQUE { { p.SetState(1760) p.KeyDesc() @@ -20320,7 +20320,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(1763) p.Comment() @@ -20334,7 +20334,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(1766) p.PartitionDesc() @@ -20348,7 +20348,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDISTRIBUTED { + if _la == StarRocksSQLParserDISTRIBUTED { { p.SetState(1769) p.DistributionDesc() @@ -20362,7 +20362,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(1772) p.OrderByDesc() @@ -20376,7 +20376,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(1775) p.Properties() @@ -20385,7 +20385,7 @@ func (p *DorisSQLParser) CreateTableAsSelectStatement() (localctx ICreateTableAs } { p.SetState(1778) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20437,13 +20437,13 @@ type DropTableStatementContext struct { func NewEmptyDropTableStatementContext() *DropTableStatementContext { var p = new(DropTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropTableStatement + p.RuleIndex = StarRocksSQLParserRULE_dropTableStatement return p } func InitEmptyDropTableStatementContext(p *DropTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropTableStatement + p.RuleIndex = StarRocksSQLParserRULE_dropTableStatement } func (*DropTableStatementContext) IsDropTableStatementContext() {} @@ -20454,7 +20454,7 @@ func NewDropTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropTableStatement + p.RuleIndex = StarRocksSQLParserRULE_dropTableStatement return p } @@ -20462,11 +20462,11 @@ func NewDropTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *DropTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropTableStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *DropTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -20486,19 +20486,19 @@ func (s *DropTableStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropTableStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *DropTableStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropTableStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropTableStatementContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *DropTableStatementContext) GetRuleContext() antlr.RuleContext { @@ -20510,20 +20510,20 @@ func (s *DropTableStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *DropTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropTableStatement(s) } } func (s *DropTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropTableStatement(s) } } func (s *DropTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropTableStatement(s) default: @@ -20531,15 +20531,15 @@ func (s *DropTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) DropTableStatement() (localctx IDropTableStatementContext) { +func (p *StarRocksSQLParser) DropTableStatement() (localctx IDropTableStatementContext) { localctx = NewDropTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 74, DorisSQLParserRULE_dropTableStatement) + p.EnterRule(localctx, 74, StarRocksSQLParserRULE_dropTableStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1781) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20552,10 +20552,10 @@ func (p *DorisSQLParser) DropTableStatement() (localctx IDropTableStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(1782) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20565,7 +20565,7 @@ func (p *DorisSQLParser) DropTableStatement() (localctx IDropTableStatementConte } { p.SetState(1785) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20578,10 +20578,10 @@ func (p *DorisSQLParser) DropTableStatement() (localctx IDropTableStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(1786) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20589,7 +20589,7 @@ func (p *DorisSQLParser) DropTableStatement() (localctx IDropTableStatementConte } { p.SetState(1787) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20608,10 +20608,10 @@ func (p *DorisSQLParser) DropTableStatement() (localctx IDropTableStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(1791) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20660,13 +20660,13 @@ type CleanTemporaryTableStatementContext struct { func NewEmptyCleanTemporaryTableStatementContext() *CleanTemporaryTableStatementContext { var p = new(CleanTemporaryTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cleanTemporaryTableStatement + p.RuleIndex = StarRocksSQLParserRULE_cleanTemporaryTableStatement return p } func InitEmptyCleanTemporaryTableStatementContext(p *CleanTemporaryTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cleanTemporaryTableStatement + p.RuleIndex = StarRocksSQLParserRULE_cleanTemporaryTableStatement } func (*CleanTemporaryTableStatementContext) IsCleanTemporaryTableStatementContext() {} @@ -20677,7 +20677,7 @@ func NewCleanTemporaryTableStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cleanTemporaryTableStatement + p.RuleIndex = StarRocksSQLParserRULE_cleanTemporaryTableStatement return p } @@ -20685,23 +20685,23 @@ func NewCleanTemporaryTableStatementContext(parser antlr.Parser, parent antlr.Pa func (s *CleanTemporaryTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CleanTemporaryTableStatementContext) CLEAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLEAN, 0) + return s.GetToken(StarRocksSQLParserCLEAN, 0) } func (s *CleanTemporaryTableStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *CleanTemporaryTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CleanTemporaryTableStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CleanTemporaryTableStatementContext) SESSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSESSION, 0) + return s.GetToken(StarRocksSQLParserSESSION, 0) } func (s *CleanTemporaryTableStatementContext) String_() IStringContext { @@ -20729,20 +20729,20 @@ func (s *CleanTemporaryTableStatementContext) ToStringTree(ruleNames []string, r } func (s *CleanTemporaryTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCleanTemporaryTableStatement(s) } } func (s *CleanTemporaryTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCleanTemporaryTableStatement(s) } } func (s *CleanTemporaryTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCleanTemporaryTableStatement(s) default: @@ -20750,13 +20750,13 @@ func (s *CleanTemporaryTableStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CleanTemporaryTableStatement() (localctx ICleanTemporaryTableStatementContext) { +func (p *StarRocksSQLParser) CleanTemporaryTableStatement() (localctx ICleanTemporaryTableStatementContext) { localctx = NewCleanTemporaryTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 76, DorisSQLParserRULE_cleanTemporaryTableStatement) + p.EnterRule(localctx, 76, StarRocksSQLParserRULE_cleanTemporaryTableStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1794) - p.Match(DorisSQLParserCLEAN) + p.Match(StarRocksSQLParserCLEAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20764,7 +20764,7 @@ func (p *DorisSQLParser) CleanTemporaryTableStatement() (localctx ICleanTemporar } { p.SetState(1795) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20772,7 +20772,7 @@ func (p *DorisSQLParser) CleanTemporaryTableStatement() (localctx ICleanTemporar } { p.SetState(1796) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20780,7 +20780,7 @@ func (p *DorisSQLParser) CleanTemporaryTableStatement() (localctx ICleanTemporar } { p.SetState(1797) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20788,7 +20788,7 @@ func (p *DorisSQLParser) CleanTemporaryTableStatement() (localctx ICleanTemporar } { p.SetState(1798) - p.Match(DorisSQLParserSESSION) + p.Match(StarRocksSQLParserSESSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -20845,13 +20845,13 @@ type AlterTableStatementContext struct { func NewEmptyAlterTableStatementContext() *AlterTableStatementContext { var p = new(AlterTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterTableStatement + p.RuleIndex = StarRocksSQLParserRULE_alterTableStatement return p } func InitEmptyAlterTableStatementContext(p *AlterTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterTableStatement + p.RuleIndex = StarRocksSQLParserRULE_alterTableStatement } func (*AlterTableStatementContext) IsAlterTableStatementContext() {} @@ -20862,7 +20862,7 @@ func NewAlterTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterTableStatement + p.RuleIndex = StarRocksSQLParserRULE_alterTableStatement return p } @@ -20870,11 +20870,11 @@ func NewAlterTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *AlterTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterTableStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *AlterTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -20935,11 +20935,11 @@ func (s *AlterTableStatementContext) AlterClause(i int) IAlterClauseContext { } func (s *AlterTableStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AlterTableStatementContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *AlterTableStatementContext) AllRollupItem() []IRollupItemContext { @@ -20984,7 +20984,7 @@ func (s *AlterTableStatementContext) RollupItem(i int) IRollupItemContext { } func (s *AlterTableStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *AlterTableStatementContext) AllIdentifier() []IIdentifierContext { @@ -21037,20 +21037,20 @@ func (s *AlterTableStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *AlterTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterTableStatement(s) } } func (s *AlterTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterTableStatement(s) } } func (s *AlterTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterTableStatement(s) default: @@ -21058,9 +21058,9 @@ func (s *AlterTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementContext) { +func (p *StarRocksSQLParser) AlterTableStatement() (localctx IAlterTableStatementContext) { localctx = NewAlterTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 78, DorisSQLParserRULE_alterTableStatement) + p.EnterRule(localctx, 78, StarRocksSQLParserRULE_alterTableStatement) var _la int p.SetState(1838) @@ -21074,7 +21074,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon p.EnterOuterAlt(localctx, 1) { p.SetState(1801) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21082,7 +21082,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1802) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21103,10 +21103,10 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1805) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21129,7 +21129,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon p.EnterOuterAlt(localctx, 2) { p.SetState(1812) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21137,7 +21137,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1813) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21149,7 +21149,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1815) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21157,7 +21157,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1816) - p.Match(DorisSQLParserROLLUP) + p.Match(StarRocksSQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21174,10 +21174,10 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1818) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21200,7 +21200,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon p.EnterOuterAlt(localctx, 3) { p.SetState(1825) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21208,7 +21208,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1826) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21220,7 +21220,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1828) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21228,7 +21228,7 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } { p.SetState(1829) - p.Match(DorisSQLParserROLLUP) + p.Match(StarRocksSQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21245,10 +21245,10 @@ func (p *DorisSQLParser) AlterTableStatement() (localctx IAlterTableStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1831) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21321,13 +21321,13 @@ type CreateIndexStatementContext struct { func NewEmptyCreateIndexStatementContext() *CreateIndexStatementContext { var p = new(CreateIndexStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_createIndexStatement return p } func InitEmptyCreateIndexStatementContext(p *CreateIndexStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_createIndexStatement } func (*CreateIndexStatementContext) IsCreateIndexStatementContext() {} @@ -21338,7 +21338,7 @@ func NewCreateIndexStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_createIndexStatement return p } @@ -21350,15 +21350,15 @@ func (s *CreateIndexStatementContext) GetIndexName() IIdentifierContext { return func (s *CreateIndexStatementContext) SetIndexName(v IIdentifierContext) { s.indexName = v } func (s *CreateIndexStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateIndexStatementContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *CreateIndexStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CreateIndexStatementContext) QualifiedName() IQualifiedNameContext { @@ -21466,20 +21466,20 @@ func (s *CreateIndexStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *CreateIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateIndexStatement(s) } } func (s *CreateIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateIndexStatement(s) } } func (s *CreateIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateIndexStatement(s) default: @@ -21487,15 +21487,15 @@ func (s *CreateIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementContext) { +func (p *StarRocksSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementContext) { localctx = NewCreateIndexStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 80, DorisSQLParserRULE_createIndexStatement) + p.EnterRule(localctx, 80, StarRocksSQLParserRULE_createIndexStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1840) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21503,7 +21503,7 @@ func (p *DorisSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementC } { p.SetState(1841) - p.Match(DorisSQLParserINDEX) + p.Match(StarRocksSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21518,7 +21518,7 @@ func (p *DorisSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementC } { p.SetState(1843) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21539,7 +21539,7 @@ func (p *DorisSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserUSING { + if _la == StarRocksSQLParserUSING { { p.SetState(1846) p.IndexType() @@ -21551,7 +21551,7 @@ func (p *DorisSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(1847) p.PropertyList() @@ -21567,7 +21567,7 @@ func (p *DorisSQLParser) CreateIndexStatement() (localctx ICreateIndexStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(1852) p.Comment() @@ -21621,13 +21621,13 @@ type DropIndexStatementContext struct { func NewEmptyDropIndexStatementContext() *DropIndexStatementContext { var p = new(DropIndexStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_dropIndexStatement return p } func InitEmptyDropIndexStatementContext(p *DropIndexStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_dropIndexStatement } func (*DropIndexStatementContext) IsDropIndexStatementContext() {} @@ -21638,7 +21638,7 @@ func NewDropIndexStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_dropIndexStatement return p } @@ -21650,15 +21650,15 @@ func (s *DropIndexStatementContext) GetIndexName() IIdentifierContext { return s func (s *DropIndexStatementContext) SetIndexName(v IIdentifierContext) { s.indexName = v } func (s *DropIndexStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropIndexStatementContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *DropIndexStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *DropIndexStatementContext) QualifiedName() IQualifiedNameContext { @@ -21702,20 +21702,20 @@ func (s *DropIndexStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *DropIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropIndexStatement(s) } } func (s *DropIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropIndexStatement(s) } } func (s *DropIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropIndexStatement(s) default: @@ -21723,13 +21723,13 @@ func (s *DropIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) DropIndexStatement() (localctx IDropIndexStatementContext) { +func (p *StarRocksSQLParser) DropIndexStatement() (localctx IDropIndexStatementContext) { localctx = NewDropIndexStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 82, DorisSQLParserRULE_dropIndexStatement) + p.EnterRule(localctx, 82, StarRocksSQLParserRULE_dropIndexStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1855) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21737,7 +21737,7 @@ func (p *DorisSQLParser) DropIndexStatement() (localctx IDropIndexStatementConte } { p.SetState(1856) - p.Match(DorisSQLParserINDEX) + p.Match(StarRocksSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21752,7 +21752,7 @@ func (p *DorisSQLParser) DropIndexStatement() (localctx IDropIndexStatementConte } { p.SetState(1858) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21802,13 +21802,13 @@ type IndexTypeContext struct { func NewEmptyIndexTypeContext() *IndexTypeContext { var p = new(IndexTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_indexType + p.RuleIndex = StarRocksSQLParserRULE_indexType return p } func InitEmptyIndexTypeContext(p *IndexTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_indexType + p.RuleIndex = StarRocksSQLParserRULE_indexType } func (*IndexTypeContext) IsIndexTypeContext() {} @@ -21819,7 +21819,7 @@ func NewIndexTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_indexType + p.RuleIndex = StarRocksSQLParserRULE_indexType return p } @@ -21827,23 +21827,23 @@ func NewIndexTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *IndexTypeContext) GetParser() antlr.Parser { return s.parser } func (s *IndexTypeContext) USING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSING, 0) + return s.GetToken(StarRocksSQLParserUSING, 0) } func (s *IndexTypeContext) BITMAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITMAP, 0) + return s.GetToken(StarRocksSQLParserBITMAP, 0) } func (s *IndexTypeContext) GIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGIN, 0) + return s.GetToken(StarRocksSQLParserGIN, 0) } func (s *IndexTypeContext) NGRAMBF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNGRAMBF, 0) + return s.GetToken(StarRocksSQLParserNGRAMBF, 0) } func (s *IndexTypeContext) VECTOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVECTOR, 0) + return s.GetToken(StarRocksSQLParserVECTOR, 0) } func (s *IndexTypeContext) GetRuleContext() antlr.RuleContext { @@ -21855,20 +21855,20 @@ func (s *IndexTypeContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *IndexTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIndexType(s) } } func (s *IndexTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIndexType(s) } } func (s *IndexTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIndexType(s) default: @@ -21876,15 +21876,15 @@ func (s *IndexTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) IndexType() (localctx IIndexTypeContext) { +func (p *StarRocksSQLParser) IndexType() (localctx IIndexTypeContext) { localctx = NewIndexTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 84, DorisSQLParserRULE_indexType) + p.EnterRule(localctx, 84, StarRocksSQLParserRULE_indexType) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1861) - p.Match(DorisSQLParserUSING) + p.Match(StarRocksSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -21894,7 +21894,7 @@ func (p *DorisSQLParser) IndexType() (localctx IIndexTypeContext) { p.SetState(1862) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserBITMAP || _la == DorisSQLParserGIN || _la == DorisSQLParserNGRAMBF || _la == DorisSQLParserVECTOR) { + if !(_la == StarRocksSQLParserBITMAP || _la == StarRocksSQLParserGIN || _la == StarRocksSQLParserNGRAMBF || _la == StarRocksSQLParserVECTOR) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -21960,13 +21960,13 @@ type ShowTableStatementContext struct { func NewEmptyShowTableStatementContext() *ShowTableStatementContext { var p = new(ShowTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatement return p } func InitEmptyShowTableStatementContext(p *ShowTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatement } func (*ShowTableStatementContext) IsShowTableStatementContext() {} @@ -21977,7 +21977,7 @@ func NewShowTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatement return p } @@ -21993,23 +21993,23 @@ func (s *ShowTableStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowTableStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowTableStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTableStatementContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *ShowTableStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *ShowTableStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowTableStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -22029,11 +22029,11 @@ func (s *ShowTableStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowTableStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowTableStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowTableStatementContext) Expression() IExpressionContext { @@ -22077,20 +22077,20 @@ func (s *ShowTableStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ShowTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTableStatement(s) } } func (s *ShowTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTableStatement(s) } } func (s *ShowTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTableStatement(s) default: @@ -22098,15 +22098,15 @@ func (s *ShowTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementContext) { +func (p *StarRocksSQLParser) ShowTableStatement() (localctx IShowTableStatementContext) { localctx = NewShowTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 86, DorisSQLParserRULE_showTableStatement) + p.EnterRule(localctx, 86, StarRocksSQLParserRULE_showTableStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1864) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22119,10 +22119,10 @@ func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL { + if _la == StarRocksSQLParserFULL { { p.SetState(1865) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22132,7 +22132,7 @@ func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementConte } { p.SetState(1868) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22145,12 +22145,12 @@ func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1869) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -22172,10 +22172,10 @@ func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementConte goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(1873) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22189,10 +22189,10 @@ func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementConte localctx.(*ShowTableStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(1875) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22203,7 +22203,7 @@ func (p *DorisSQLParser) ShowTableStatement() (localctx IShowTableStatementConte p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -22266,13 +22266,13 @@ type ShowTemporaryTablesStatementContext struct { func NewEmptyShowTemporaryTablesStatementContext() *ShowTemporaryTablesStatementContext { var p = new(ShowTemporaryTablesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTemporaryTablesStatement + p.RuleIndex = StarRocksSQLParserRULE_showTemporaryTablesStatement return p } func InitEmptyShowTemporaryTablesStatementContext(p *ShowTemporaryTablesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTemporaryTablesStatement + p.RuleIndex = StarRocksSQLParserRULE_showTemporaryTablesStatement } func (*ShowTemporaryTablesStatementContext) IsShowTemporaryTablesStatementContext() {} @@ -22283,7 +22283,7 @@ func NewShowTemporaryTablesStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTemporaryTablesStatement + p.RuleIndex = StarRocksSQLParserRULE_showTemporaryTablesStatement return p } @@ -22299,23 +22299,23 @@ func (s *ShowTemporaryTablesStatementContext) SetDb(v IQualifiedNameContext) { s func (s *ShowTemporaryTablesStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowTemporaryTablesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTemporaryTablesStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *ShowTemporaryTablesStatementContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *ShowTemporaryTablesStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowTemporaryTablesStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowTemporaryTablesStatementContext) QualifiedName() IQualifiedNameContext { @@ -22335,11 +22335,11 @@ func (s *ShowTemporaryTablesStatementContext) QualifiedName() IQualifiedNameCont } func (s *ShowTemporaryTablesStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowTemporaryTablesStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowTemporaryTablesStatementContext) Expression() IExpressionContext { @@ -22383,20 +22383,20 @@ func (s *ShowTemporaryTablesStatementContext) ToStringTree(ruleNames []string, r } func (s *ShowTemporaryTablesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTemporaryTablesStatement(s) } } func (s *ShowTemporaryTablesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTemporaryTablesStatement(s) } } func (s *ShowTemporaryTablesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTemporaryTablesStatement(s) default: @@ -22404,15 +22404,15 @@ func (s *ShowTemporaryTablesStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporaryTablesStatementContext) { +func (p *StarRocksSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporaryTablesStatementContext) { localctx = NewShowTemporaryTablesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 88, DorisSQLParserRULE_showTemporaryTablesStatement) + p.EnterRule(localctx, 88, StarRocksSQLParserRULE_showTemporaryTablesStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1879) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22420,7 +22420,7 @@ func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporary } { p.SetState(1880) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22428,7 +22428,7 @@ func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporary } { p.SetState(1881) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22441,12 +22441,12 @@ func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporary } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1882) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -22468,10 +22468,10 @@ func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporary goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(1886) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22485,10 +22485,10 @@ func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporary localctx.(*ShowTemporaryTablesStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(1888) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22499,7 +22499,7 @@ func (p *DorisSQLParser) ShowTemporaryTablesStatement() (localctx IShowTemporary p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -22551,13 +22551,13 @@ type ShowCreateTableStatementContext struct { func NewEmptyShowCreateTableStatementContext() *ShowCreateTableStatementContext { var p = new(ShowCreateTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateTableStatement return p } func InitEmptyShowCreateTableStatementContext(p *ShowCreateTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateTableStatement } func (*ShowCreateTableStatementContext) IsShowCreateTableStatementContext() {} @@ -22568,7 +22568,7 @@ func NewShowCreateTableStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateTableStatement return p } @@ -22580,11 +22580,11 @@ func (s *ShowCreateTableStatementContext) GetTable() IQualifiedNameContext { ret func (s *ShowCreateTableStatementContext) SetTable(v IQualifiedNameContext) { s.table = v } func (s *ShowCreateTableStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateTableStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -22604,15 +22604,15 @@ func (s *ShowCreateTableStatementContext) QualifiedName() IQualifiedNameContext } func (s *ShowCreateTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *ShowCreateTableStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *ShowCreateTableStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *ShowCreateTableStatementContext) GetRuleContext() antlr.RuleContext { @@ -22624,20 +22624,20 @@ func (s *ShowCreateTableStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowCreateTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateTableStatement(s) } } func (s *ShowCreateTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateTableStatement(s) } } func (s *ShowCreateTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateTableStatement(s) default: @@ -22645,13 +22645,13 @@ func (s *ShowCreateTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowCreateTableStatement() (localctx IShowCreateTableStatementContext) { +func (p *StarRocksSQLParser) ShowCreateTableStatement() (localctx IShowCreateTableStatementContext) { localctx = NewShowCreateTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 90, DorisSQLParserRULE_showCreateTableStatement) + p.EnterRule(localctx, 90, StarRocksSQLParserRULE_showCreateTableStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(1892) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22659,7 +22659,7 @@ func (p *DorisSQLParser) ShowCreateTableStatement() (localctx IShowCreateTableSt } { p.SetState(1893) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22672,30 +22672,30 @@ func (p *DorisSQLParser) ShowCreateTableStatement() (localctx IShowCreateTableSt } switch p.GetTokenStream().LA(1) { - case DorisSQLParserTABLE: + case StarRocksSQLParserTABLE: { p.SetState(1894) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserVIEW: + case StarRocksSQLParserVIEW: { p.SetState(1895) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserMATERIALIZED: + case StarRocksSQLParserMATERIALIZED: { p.SetState(1896) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22703,7 +22703,7 @@ func (p *DorisSQLParser) ShowCreateTableStatement() (localctx IShowCreateTableSt } { p.SetState(1897) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22791,13 +22791,13 @@ type ShowColumnStatementContext struct { func NewEmptyShowColumnStatementContext() *ShowColumnStatementContext { var p = new(ShowColumnStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showColumnStatement + p.RuleIndex = StarRocksSQLParserRULE_showColumnStatement return p } func InitEmptyShowColumnStatementContext(p *ShowColumnStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showColumnStatement + p.RuleIndex = StarRocksSQLParserRULE_showColumnStatement } func (*ShowColumnStatementContext) IsShowColumnStatementContext() {} @@ -22808,7 +22808,7 @@ func NewShowColumnStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showColumnStatement + p.RuleIndex = StarRocksSQLParserRULE_showColumnStatement return p } @@ -22828,35 +22828,35 @@ func (s *ShowColumnStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowColumnStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowColumnStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowColumnStatementContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *ShowColumnStatementContext) FIELDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIELDS, 0) + return s.GetToken(StarRocksSQLParserFIELDS, 0) } func (s *ShowColumnStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *ShowColumnStatementContext) AllFROM() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserFROM) + return s.GetTokens(StarRocksSQLParserFROM) } func (s *ShowColumnStatementContext) FROM(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, i) + return s.GetToken(StarRocksSQLParserFROM, i) } func (s *ShowColumnStatementContext) AllIN() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserIN) + return s.GetTokens(StarRocksSQLParserIN) } func (s *ShowColumnStatementContext) IN(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, i) + return s.GetToken(StarRocksSQLParserIN, i) } func (s *ShowColumnStatementContext) AllQualifiedName() []IQualifiedNameContext { @@ -22901,11 +22901,11 @@ func (s *ShowColumnStatementContext) QualifiedName(i int) IQualifiedNameContext } func (s *ShowColumnStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowColumnStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowColumnStatementContext) Expression() IExpressionContext { @@ -22949,20 +22949,20 @@ func (s *ShowColumnStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowColumnStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowColumnStatement(s) } } func (s *ShowColumnStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowColumnStatement(s) } } func (s *ShowColumnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowColumnStatement(s) default: @@ -22970,15 +22970,15 @@ func (s *ShowColumnStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementContext) { +func (p *StarRocksSQLParser) ShowColumnStatement() (localctx IShowColumnStatementContext) { localctx = NewShowColumnStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 92, DorisSQLParserRULE_showColumnStatement) + p.EnterRule(localctx, 92, StarRocksSQLParserRULE_showColumnStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1902) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -22991,10 +22991,10 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL { + if _la == StarRocksSQLParserFULL { { p.SetState(1903) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23006,7 +23006,7 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon p.SetState(1906) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCOLUMNS || _la == DorisSQLParserFIELDS) { + if !(_la == StarRocksSQLParserCOLUMNS || _la == StarRocksSQLParserFIELDS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -23018,7 +23018,7 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon p.SetState(1907) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -23040,12 +23040,12 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1910) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -23067,10 +23067,10 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(1914) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23084,10 +23084,10 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon localctx.(*ShowColumnStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(1916) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23098,7 +23098,7 @@ func (p *DorisSQLParser) ShowColumnStatement() (localctx IShowColumnStatementCon p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -23161,13 +23161,13 @@ type ShowTableStatusStatementContext struct { func NewEmptyShowTableStatusStatementContext() *ShowTableStatusStatementContext { var p = new(ShowTableStatusStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatusStatement return p } func InitEmptyShowTableStatusStatementContext(p *ShowTableStatusStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatusStatement } func (*ShowTableStatusStatementContext) IsShowTableStatusStatementContext() {} @@ -23178,7 +23178,7 @@ func NewShowTableStatusStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTableStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatusStatement return p } @@ -23194,23 +23194,23 @@ func (s *ShowTableStatusStatementContext) SetDb(v IQualifiedNameContext) { s.db func (s *ShowTableStatusStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowTableStatusStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTableStatusStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *ShowTableStatusStatementContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *ShowTableStatusStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowTableStatusStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowTableStatusStatementContext) QualifiedName() IQualifiedNameContext { @@ -23230,11 +23230,11 @@ func (s *ShowTableStatusStatementContext) QualifiedName() IQualifiedNameContext } func (s *ShowTableStatusStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowTableStatusStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowTableStatusStatementContext) Expression() IExpressionContext { @@ -23278,20 +23278,20 @@ func (s *ShowTableStatusStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowTableStatusStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTableStatusStatement(s) } } func (s *ShowTableStatusStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTableStatusStatement(s) } } func (s *ShowTableStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTableStatusStatement(s) default: @@ -23299,15 +23299,15 @@ func (s *ShowTableStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusStatementContext) { +func (p *StarRocksSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusStatementContext) { localctx = NewShowTableStatusStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 94, DorisSQLParserRULE_showTableStatusStatement) + p.EnterRule(localctx, 94, StarRocksSQLParserRULE_showTableStatusStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1920) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23315,7 +23315,7 @@ func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusSt } { p.SetState(1921) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23323,7 +23323,7 @@ func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusSt } { p.SetState(1922) - p.Match(DorisSQLParserSTATUS) + p.Match(StarRocksSQLParserSTATUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23336,12 +23336,12 @@ func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1923) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -23363,10 +23363,10 @@ func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusSt goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(1927) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23380,10 +23380,10 @@ func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusSt localctx.(*ShowTableStatusStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(1929) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23394,7 +23394,7 @@ func (p *DorisSQLParser) ShowTableStatusStatement() (localctx IShowTableStatusSt p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -23440,13 +23440,13 @@ type RefreshTableStatementContext struct { func NewEmptyRefreshTableStatementContext() *RefreshTableStatementContext { var p = new(RefreshTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshTableStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshTableStatement return p } func InitEmptyRefreshTableStatementContext(p *RefreshTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshTableStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshTableStatement } func (*RefreshTableStatementContext) IsRefreshTableStatementContext() {} @@ -23457,7 +23457,7 @@ func NewRefreshTableStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_refreshTableStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshTableStatement return p } @@ -23465,15 +23465,15 @@ func NewRefreshTableStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *RefreshTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *RefreshTableStatementContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *RefreshTableStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *RefreshTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *RefreshTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -23493,7 +23493,7 @@ func (s *RefreshTableStatementContext) QualifiedName() IQualifiedNameContext { } func (s *RefreshTableStatementContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *RefreshTableStatementContext) AllString_() []IStringContext { @@ -23546,20 +23546,20 @@ func (s *RefreshTableStatementContext) ToStringTree(ruleNames []string, recog an } func (s *RefreshTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRefreshTableStatement(s) } } func (s *RefreshTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRefreshTableStatement(s) } } func (s *RefreshTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRefreshTableStatement(s) default: @@ -23567,15 +23567,15 @@ func (s *RefreshTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatementContext) { +func (p *StarRocksSQLParser) RefreshTableStatement() (localctx IRefreshTableStatementContext) { localctx = NewRefreshTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 96, DorisSQLParserRULE_refreshTableStatement) + p.EnterRule(localctx, 96, StarRocksSQLParserRULE_refreshTableStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(1933) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23583,7 +23583,7 @@ func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatemen } { p.SetState(1934) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23591,7 +23591,7 @@ func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatemen } { p.SetState(1935) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23608,10 +23608,10 @@ func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(1937) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23619,7 +23619,7 @@ func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatemen } { p.SetState(1938) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23636,10 +23636,10 @@ func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatemen } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1940) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23659,7 +23659,7 @@ func (p *DorisSQLParser) RefreshTableStatement() (localctx IRefreshTableStatemen } { p.SetState(1947) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23727,13 +23727,13 @@ type ShowAlterStatementContext struct { func NewEmptyShowAlterStatementContext() *ShowAlterStatementContext { var p = new(ShowAlterStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAlterStatement + p.RuleIndex = StarRocksSQLParserRULE_showAlterStatement return p } func InitEmptyShowAlterStatementContext(p *ShowAlterStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAlterStatement + p.RuleIndex = StarRocksSQLParserRULE_showAlterStatement } func (*ShowAlterStatementContext) IsShowAlterStatementContext() {} @@ -23744,7 +23744,7 @@ func NewShowAlterStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showAlterStatement + p.RuleIndex = StarRocksSQLParserRULE_showAlterStatement return p } @@ -23756,31 +23756,31 @@ func (s *ShowAlterStatementContext) GetDb() IQualifiedNameContext { return s.db func (s *ShowAlterStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowAlterStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowAlterStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *ShowAlterStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *ShowAlterStatementContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *ShowAlterStatementContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *ShowAlterStatementContext) OPTIMIZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTIMIZE, 0) + return s.GetToken(StarRocksSQLParserOPTIMIZE, 0) } func (s *ShowAlterStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowAlterStatementContext) Expression() IExpressionContext { @@ -23800,11 +23800,11 @@ func (s *ShowAlterStatementContext) Expression() IExpressionContext { } func (s *ShowAlterStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowAlterStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowAlterStatementContext) AllSortItem() []ISortItemContext { @@ -23865,11 +23865,11 @@ func (s *ShowAlterStatementContext) LimitElement() ILimitElementContext { } func (s *ShowAlterStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowAlterStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowAlterStatementContext) QualifiedName() IQualifiedNameContext { @@ -23889,11 +23889,11 @@ func (s *ShowAlterStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowAlterStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *ShowAlterStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *ShowAlterStatementContext) GetRuleContext() antlr.RuleContext { @@ -23905,20 +23905,20 @@ func (s *ShowAlterStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ShowAlterStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowAlterStatement(s) } } func (s *ShowAlterStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowAlterStatement(s) } } func (s *ShowAlterStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowAlterStatement(s) default: @@ -23926,9 +23926,9 @@ func (s *ShowAlterStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementContext) { +func (p *StarRocksSQLParser) ShowAlterStatement() (localctx IShowAlterStatementContext) { localctx = NewShowAlterStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 98, DorisSQLParserRULE_showAlterStatement) + p.EnterRule(localctx, 98, StarRocksSQLParserRULE_showAlterStatement) var _la int p.SetState(2005) @@ -23942,7 +23942,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte p.EnterOuterAlt(localctx, 1) { p.SetState(1951) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23950,7 +23950,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1952) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23958,7 +23958,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1953) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -23968,7 +23968,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte p.SetState(1954) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCOLUMN || _la == DorisSQLParserOPTIMIZE || _la == DorisSQLParserROLLUP) { + if !(_la == StarRocksSQLParserCOLUMN || _la == StarRocksSQLParserOPTIMIZE || _la == StarRocksSQLParserROLLUP) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -23982,12 +23982,12 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1955) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -24010,10 +24010,10 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(1959) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24032,10 +24032,10 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(1963) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24043,7 +24043,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1964) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24060,10 +24060,10 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1966) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24090,7 +24090,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(1975) p.LimitElement() @@ -24102,7 +24102,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte p.EnterOuterAlt(localctx, 2) { p.SetState(1978) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24110,7 +24110,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1979) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24118,7 +24118,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1980) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24126,7 +24126,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1981) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24139,12 +24139,12 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(1982) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -24167,10 +24167,10 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(1986) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24189,10 +24189,10 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(1990) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24200,7 +24200,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } { p.SetState(1991) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24217,10 +24217,10 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(1993) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24247,7 +24247,7 @@ func (p *DorisSQLParser) ShowAlterStatement() (localctx IShowAlterStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(2002) p.LimitElement() @@ -24306,13 +24306,13 @@ type DescTableStatementContext struct { func NewEmptyDescTableStatementContext() *DescTableStatementContext { var p = new(DescTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_descTableStatement + p.RuleIndex = StarRocksSQLParserRULE_descTableStatement return p } func InitEmptyDescTableStatementContext(p *DescTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_descTableStatement + p.RuleIndex = StarRocksSQLParserRULE_descTableStatement } func (*DescTableStatementContext) IsDescTableStatementContext() {} @@ -24323,7 +24323,7 @@ func NewDescTableStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_descTableStatement + p.RuleIndex = StarRocksSQLParserRULE_descTableStatement return p } @@ -24335,15 +24335,15 @@ func (s *DescTableStatementContext) GetTable() IQualifiedNameContext { return s. func (s *DescTableStatementContext) SetTable(v IQualifiedNameContext) { s.table = v } func (s *DescTableStatementContext) DESC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESC, 0) + return s.GetToken(StarRocksSQLParserDESC, 0) } func (s *DescTableStatementContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESCRIBE, 0) + return s.GetToken(StarRocksSQLParserDESCRIBE, 0) } func (s *DescTableStatementContext) FILES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILES, 0) + return s.GetToken(StarRocksSQLParserFILES, 0) } func (s *DescTableStatementContext) PropertyList() IPropertyListContext { @@ -24379,7 +24379,7 @@ func (s *DescTableStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DescTableStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *DescTableStatementContext) GetRuleContext() antlr.RuleContext { @@ -24391,20 +24391,20 @@ func (s *DescTableStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *DescTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDescTableStatement(s) } } func (s *DescTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDescTableStatement(s) } } func (s *DescTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDescTableStatement(s) default: @@ -24412,9 +24412,9 @@ func (s *DescTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) DescTableStatement() (localctx IDescTableStatementContext) { +func (p *StarRocksSQLParser) DescTableStatement() (localctx IDescTableStatementContext) { localctx = NewDescTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 100, DorisSQLParserRULE_descTableStatement) + p.EnterRule(localctx, 100, StarRocksSQLParserRULE_descTableStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -24422,7 +24422,7 @@ func (p *DorisSQLParser) DescTableStatement() (localctx IDescTableStatementConte p.SetState(2007) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDESC || _la == DorisSQLParserDESCRIBE) { + if !(_la == StarRocksSQLParserDESC || _la == StarRocksSQLParserDESCRIBE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -24436,7 +24436,7 @@ func (p *DorisSQLParser) DescTableStatement() (localctx IDescTableStatementConte } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(2008) @@ -24451,10 +24451,10 @@ func (p *DorisSQLParser) DescTableStatement() (localctx IDescTableStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL { + if _la == StarRocksSQLParserALL { { p.SetState(2009) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24463,10 +24463,10 @@ func (p *DorisSQLParser) DescTableStatement() (localctx IDescTableStatementConte } - case DorisSQLParserFILES: + case StarRocksSQLParserFILES: { p.SetState(2012) - p.Match(DorisSQLParserFILES) + p.Match(StarRocksSQLParserFILES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24529,13 +24529,13 @@ type CreateTableLikeStatementContext struct { func NewEmptyCreateTableLikeStatementContext() *CreateTableLikeStatementContext { var p = new(CreateTableLikeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createTableLikeStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableLikeStatement return p } func InitEmptyCreateTableLikeStatementContext(p *CreateTableLikeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createTableLikeStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableLikeStatement } func (*CreateTableLikeStatementContext) IsCreateTableLikeStatementContext() {} @@ -24546,7 +24546,7 @@ func NewCreateTableLikeStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createTableLikeStatement + p.RuleIndex = StarRocksSQLParserRULE_createTableLikeStatement return p } @@ -24554,11 +24554,11 @@ func NewCreateTableLikeStatementContext(parser antlr.Parser, parent antlr.Parser func (s *CreateTableLikeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateTableLikeStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateTableLikeStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CreateTableLikeStatementContext) AllQualifiedName() []IQualifiedNameContext { @@ -24603,19 +24603,19 @@ func (s *CreateTableLikeStatementContext) QualifiedName(i int) IQualifiedNameCon } func (s *CreateTableLikeStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *CreateTableLikeStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateTableLikeStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateTableLikeStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateTableLikeStatementContext) PartitionDesc() IPartitionDescContext { @@ -24667,11 +24667,11 @@ func (s *CreateTableLikeStatementContext) Properties() IPropertiesContext { } func (s *CreateTableLikeStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *CreateTableLikeStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *CreateTableLikeStatementContext) GetRuleContext() antlr.RuleContext { @@ -24683,20 +24683,20 @@ func (s *CreateTableLikeStatementContext) ToStringTree(ruleNames []string, recog } func (s *CreateTableLikeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateTableLikeStatement(s) } } func (s *CreateTableLikeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateTableLikeStatement(s) } } func (s *CreateTableLikeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateTableLikeStatement(s) default: @@ -24704,15 +24704,15 @@ func (s *CreateTableLikeStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeStatementContext) { +func (p *StarRocksSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeStatementContext) { localctx = NewCreateTableLikeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 102, DorisSQLParserRULE_createTableLikeStatement) + p.EnterRule(localctx, 102, StarRocksSQLParserRULE_createTableLikeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2016) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24725,12 +24725,12 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEXTERNAL || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserEXTERNAL || _la == StarRocksSQLParserTEMPORARY { { p.SetState(2017) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserEXTERNAL || _la == DorisSQLParserTEMPORARY) { + if !(_la == StarRocksSQLParserEXTERNAL || _la == StarRocksSQLParserTEMPORARY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -24741,7 +24741,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } { p.SetState(2020) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24754,10 +24754,10 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2021) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24765,7 +24765,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } { p.SetState(2022) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24773,7 +24773,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } { p.SetState(2023) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24792,7 +24792,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(2027) p.PartitionDesc() @@ -24806,7 +24806,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDISTRIBUTED { + if _la == StarRocksSQLParserDISTRIBUTED { { p.SetState(2030) p.DistributionDesc() @@ -24820,7 +24820,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(2033) p.Properties() @@ -24829,7 +24829,7 @@ func (p *DorisSQLParser) CreateTableLikeStatement() (localctx ICreateTableLikeSt } { p.SetState(2036) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -24899,13 +24899,13 @@ type ShowIndexStatementContext struct { func NewEmptyShowIndexStatementContext() *ShowIndexStatementContext { var p = new(ShowIndexStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_showIndexStatement return p } func InitEmptyShowIndexStatementContext(p *ShowIndexStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_showIndexStatement } func (*ShowIndexStatementContext) IsShowIndexStatementContext() {} @@ -24916,7 +24916,7 @@ func NewShowIndexStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showIndexStatement + p.RuleIndex = StarRocksSQLParserRULE_showIndexStatement return p } @@ -24932,39 +24932,39 @@ func (s *ShowIndexStatementContext) SetTable(v IQualifiedNameContext) { s.table func (s *ShowIndexStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowIndexStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowIndexStatementContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *ShowIndexStatementContext) INDEXES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEXES, 0) + return s.GetToken(StarRocksSQLParserINDEXES, 0) } func (s *ShowIndexStatementContext) KEY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEY, 0) + return s.GetToken(StarRocksSQLParserKEY, 0) } func (s *ShowIndexStatementContext) KEYS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEYS, 0) + return s.GetToken(StarRocksSQLParserKEYS, 0) } func (s *ShowIndexStatementContext) AllFROM() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserFROM) + return s.GetTokens(StarRocksSQLParserFROM) } func (s *ShowIndexStatementContext) FROM(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, i) + return s.GetToken(StarRocksSQLParserFROM, i) } func (s *ShowIndexStatementContext) AllIN() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserIN) + return s.GetTokens(StarRocksSQLParserIN) } func (s *ShowIndexStatementContext) IN(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, i) + return s.GetToken(StarRocksSQLParserIN, i) } func (s *ShowIndexStatementContext) AllQualifiedName() []IQualifiedNameContext { @@ -25017,20 +25017,20 @@ func (s *ShowIndexStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ShowIndexStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowIndexStatement(s) } } func (s *ShowIndexStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowIndexStatement(s) } } func (s *ShowIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowIndexStatement(s) default: @@ -25038,15 +25038,15 @@ func (s *ShowIndexStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ShowIndexStatement() (localctx IShowIndexStatementContext) { +func (p *StarRocksSQLParser) ShowIndexStatement() (localctx IShowIndexStatementContext) { localctx = NewShowIndexStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 104, DorisSQLParserRULE_showIndexStatement) + p.EnterRule(localctx, 104, StarRocksSQLParserRULE_showIndexStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2039) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25068,7 +25068,7 @@ func (p *DorisSQLParser) ShowIndexStatement() (localctx IShowIndexStatementConte p.SetState(2041) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -25090,12 +25090,12 @@ func (p *DorisSQLParser) ShowIndexStatement() (localctx IShowIndexStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(2044) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -25149,13 +25149,13 @@ type RecoverTableStatementContext struct { func NewEmptyRecoverTableStatementContext() *RecoverTableStatementContext { var p = new(RecoverTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_recoverTableStatement + p.RuleIndex = StarRocksSQLParserRULE_recoverTableStatement return p } func InitEmptyRecoverTableStatementContext(p *RecoverTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_recoverTableStatement + p.RuleIndex = StarRocksSQLParserRULE_recoverTableStatement } func (*RecoverTableStatementContext) IsRecoverTableStatementContext() {} @@ -25166,7 +25166,7 @@ func NewRecoverTableStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_recoverTableStatement + p.RuleIndex = StarRocksSQLParserRULE_recoverTableStatement return p } @@ -25174,11 +25174,11 @@ func NewRecoverTableStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *RecoverTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *RecoverTableStatementContext) RECOVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRECOVER, 0) + return s.GetToken(StarRocksSQLParserRECOVER, 0) } func (s *RecoverTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *RecoverTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -25206,20 +25206,20 @@ func (s *RecoverTableStatementContext) ToStringTree(ruleNames []string, recog an } func (s *RecoverTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRecoverTableStatement(s) } } func (s *RecoverTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRecoverTableStatement(s) } } func (s *RecoverTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRecoverTableStatement(s) default: @@ -25227,13 +25227,13 @@ func (s *RecoverTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) RecoverTableStatement() (localctx IRecoverTableStatementContext) { +func (p *StarRocksSQLParser) RecoverTableStatement() (localctx IRecoverTableStatementContext) { localctx = NewRecoverTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 106, DorisSQLParserRULE_recoverTableStatement) + p.EnterRule(localctx, 106, StarRocksSQLParserRULE_recoverTableStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2048) - p.Match(DorisSQLParserRECOVER) + p.Match(StarRocksSQLParserRECOVER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25241,7 +25241,7 @@ func (p *DorisSQLParser) RecoverTableStatement() (localctx IRecoverTableStatemen } { p.SetState(2049) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25290,13 +25290,13 @@ type TruncateTableStatementContext struct { func NewEmptyTruncateTableStatementContext() *TruncateTableStatementContext { var p = new(TruncateTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_truncateTableStatement + p.RuleIndex = StarRocksSQLParserRULE_truncateTableStatement return p } func InitEmptyTruncateTableStatementContext(p *TruncateTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_truncateTableStatement + p.RuleIndex = StarRocksSQLParserRULE_truncateTableStatement } func (*TruncateTableStatementContext) IsTruncateTableStatementContext() {} @@ -25307,7 +25307,7 @@ func NewTruncateTableStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_truncateTableStatement + p.RuleIndex = StarRocksSQLParserRULE_truncateTableStatement return p } @@ -25315,11 +25315,11 @@ func NewTruncateTableStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *TruncateTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *TruncateTableStatementContext) TRUNCATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRUNCATE, 0) + return s.GetToken(StarRocksSQLParserTRUNCATE, 0) } func (s *TruncateTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *TruncateTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -25363,20 +25363,20 @@ func (s *TruncateTableStatementContext) ToStringTree(ruleNames []string, recog a } func (s *TruncateTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTruncateTableStatement(s) } } func (s *TruncateTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTruncateTableStatement(s) } } func (s *TruncateTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTruncateTableStatement(s) default: @@ -25384,15 +25384,15 @@ func (s *TruncateTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) TruncateTableStatement() (localctx ITruncateTableStatementContext) { +func (p *StarRocksSQLParser) TruncateTableStatement() (localctx ITruncateTableStatementContext) { localctx = NewTruncateTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 108, DorisSQLParserRULE_truncateTableStatement) + p.EnterRule(localctx, 108, StarRocksSQLParserRULE_truncateTableStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2052) - p.Match(DorisSQLParserTRUNCATE) + p.Match(StarRocksSQLParserTRUNCATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25400,7 +25400,7 @@ func (p *DorisSQLParser) TruncateTableStatement() (localctx ITruncateTableStatem } { p.SetState(2053) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25417,7 +25417,7 @@ func (p *DorisSQLParser) TruncateTableStatement() (localctx ITruncateTableStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(2055) p.PartitionNames() @@ -25471,13 +25471,13 @@ type CancelAlterTableStatementContext struct { func NewEmptyCancelAlterTableStatementContext() *CancelAlterTableStatementContext { var p = new(CancelAlterTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelAlterTableStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelAlterTableStatement return p } func InitEmptyCancelAlterTableStatementContext(p *CancelAlterTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelAlterTableStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelAlterTableStatement } func (*CancelAlterTableStatementContext) IsCancelAlterTableStatementContext() {} @@ -25488,7 +25488,7 @@ func NewCancelAlterTableStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelAlterTableStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelAlterTableStatement return p } @@ -25496,19 +25496,19 @@ func NewCancelAlterTableStatementContext(parser antlr.Parser, parent antlr.Parse func (s *CancelAlterTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelAlterTableStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelAlterTableStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *CancelAlterTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CancelAlterTableStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CancelAlterTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -25528,31 +25528,31 @@ func (s *CancelAlterTableStatementContext) QualifiedName() IQualifiedNameContext } func (s *CancelAlterTableStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *CancelAlterTableStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *CancelAlterTableStatementContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *CancelAlterTableStatementContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *CancelAlterTableStatementContext) OPTIMIZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTIMIZE, 0) + return s.GetToken(StarRocksSQLParserOPTIMIZE, 0) } func (s *CancelAlterTableStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *CancelAlterTableStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *CancelAlterTableStatementContext) GetRuleContext() antlr.RuleContext { @@ -25564,20 +25564,20 @@ func (s *CancelAlterTableStatementContext) ToStringTree(ruleNames []string, reco } func (s *CancelAlterTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelAlterTableStatement(s) } } func (s *CancelAlterTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelAlterTableStatement(s) } } func (s *CancelAlterTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelAlterTableStatement(s) default: @@ -25585,9 +25585,9 @@ func (s *CancelAlterTableStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTableStatementContext) { +func (p *StarRocksSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTableStatementContext) { localctx = NewCancelAlterTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 110, DorisSQLParserRULE_cancelAlterTableStatement) + p.EnterRule(localctx, 110, StarRocksSQLParserRULE_cancelAlterTableStatement) var _la int p.SetState(2084) @@ -25601,7 +25601,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable p.EnterOuterAlt(localctx, 1) { p.SetState(2058) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25609,7 +25609,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2059) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25617,7 +25617,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2060) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25630,12 +25630,12 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOLUMN || _la == DorisSQLParserOPTIMIZE || _la == DorisSQLParserROLLUP { + if _la == StarRocksSQLParserCOLUMN || _la == StarRocksSQLParserOPTIMIZE || _la == StarRocksSQLParserROLLUP { { p.SetState(2061) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCOLUMN || _la == DorisSQLParserOPTIMIZE || _la == DorisSQLParserROLLUP) { + if !(_la == StarRocksSQLParserCOLUMN || _la == StarRocksSQLParserOPTIMIZE || _la == StarRocksSQLParserROLLUP) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -25646,7 +25646,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2064) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25663,10 +25663,10 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(2066) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25674,7 +25674,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2067) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25687,10 +25687,10 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2068) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25698,7 +25698,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2069) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25714,7 +25714,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2075) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25727,7 +25727,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable p.EnterOuterAlt(localctx, 2) { p.SetState(2078) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25735,7 +25735,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2079) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25743,7 +25743,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2080) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25751,7 +25751,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2081) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25759,7 +25759,7 @@ func (p *DorisSQLParser) CancelAlterTableStatement() (localctx ICancelAlterTable } { p.SetState(2082) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -25827,13 +25827,13 @@ type ShowPartitionsStatementContext struct { func NewEmptyShowPartitionsStatementContext() *ShowPartitionsStatementContext { var p = new(ShowPartitionsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPartitionsStatement + p.RuleIndex = StarRocksSQLParserRULE_showPartitionsStatement return p } func InitEmptyShowPartitionsStatementContext(p *ShowPartitionsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPartitionsStatement + p.RuleIndex = StarRocksSQLParserRULE_showPartitionsStatement } func (*ShowPartitionsStatementContext) IsShowPartitionsStatementContext() {} @@ -25844,7 +25844,7 @@ func NewShowPartitionsStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPartitionsStatement + p.RuleIndex = StarRocksSQLParserRULE_showPartitionsStatement return p } @@ -25856,15 +25856,15 @@ func (s *ShowPartitionsStatementContext) GetTable() IQualifiedNameContext { retu func (s *ShowPartitionsStatementContext) SetTable(v IQualifiedNameContext) { s.table = v } func (s *ShowPartitionsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPartitionsStatementContext) PARTITIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITIONS, 0) + return s.GetToken(StarRocksSQLParserPARTITIONS, 0) } func (s *ShowPartitionsStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowPartitionsStatementContext) QualifiedName() IQualifiedNameContext { @@ -25884,11 +25884,11 @@ func (s *ShowPartitionsStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowPartitionsStatementContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *ShowPartitionsStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowPartitionsStatementContext) Expression() IExpressionContext { @@ -25908,11 +25908,11 @@ func (s *ShowPartitionsStatementContext) Expression() IExpressionContext { } func (s *ShowPartitionsStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowPartitionsStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowPartitionsStatementContext) AllSortItem() []ISortItemContext { @@ -25981,20 +25981,20 @@ func (s *ShowPartitionsStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowPartitionsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPartitionsStatement(s) } } func (s *ShowPartitionsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPartitionsStatement(s) } } func (s *ShowPartitionsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPartitionsStatement(s) default: @@ -26002,15 +26002,15 @@ func (s *ShowPartitionsStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStatementContext) { +func (p *StarRocksSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStatementContext) { localctx = NewShowPartitionsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 112, DorisSQLParserRULE_showPartitionsStatement) + p.EnterRule(localctx, 112, StarRocksSQLParserRULE_showPartitionsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2086) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26023,10 +26023,10 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(2087) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26036,7 +26036,7 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } { p.SetState(2090) - p.Match(DorisSQLParserPARTITIONS) + p.Match(StarRocksSQLParserPARTITIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26044,7 +26044,7 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } { p.SetState(2091) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26064,10 +26064,10 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(2093) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26086,10 +26086,10 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(2097) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26097,7 +26097,7 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } { p.SetState(2098) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26114,10 +26114,10 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2100) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26144,7 +26144,7 @@ func (p *DorisSQLParser) ShowPartitionsStatement() (localctx IShowPartitionsStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(2109) p.LimitElement() @@ -26198,13 +26198,13 @@ type RecoverPartitionStatementContext struct { func NewEmptyRecoverPartitionStatementContext() *RecoverPartitionStatementContext { var p = new(RecoverPartitionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_recoverPartitionStatement + p.RuleIndex = StarRocksSQLParserRULE_recoverPartitionStatement return p } func InitEmptyRecoverPartitionStatementContext(p *RecoverPartitionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_recoverPartitionStatement + p.RuleIndex = StarRocksSQLParserRULE_recoverPartitionStatement } func (*RecoverPartitionStatementContext) IsRecoverPartitionStatementContext() {} @@ -26215,7 +26215,7 @@ func NewRecoverPartitionStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_recoverPartitionStatement + p.RuleIndex = StarRocksSQLParserRULE_recoverPartitionStatement return p } @@ -26227,11 +26227,11 @@ func (s *RecoverPartitionStatementContext) GetTable() IQualifiedNameContext { re func (s *RecoverPartitionStatementContext) SetTable(v IQualifiedNameContext) { s.table = v } func (s *RecoverPartitionStatementContext) RECOVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRECOVER, 0) + return s.GetToken(StarRocksSQLParserRECOVER, 0) } func (s *RecoverPartitionStatementContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *RecoverPartitionStatementContext) Identifier() IIdentifierContext { @@ -26251,7 +26251,7 @@ func (s *RecoverPartitionStatementContext) Identifier() IIdentifierContext { } func (s *RecoverPartitionStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RecoverPartitionStatementContext) QualifiedName() IQualifiedNameContext { @@ -26279,20 +26279,20 @@ func (s *RecoverPartitionStatementContext) ToStringTree(ruleNames []string, reco } func (s *RecoverPartitionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRecoverPartitionStatement(s) } } func (s *RecoverPartitionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRecoverPartitionStatement(s) } } func (s *RecoverPartitionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRecoverPartitionStatement(s) default: @@ -26300,13 +26300,13 @@ func (s *RecoverPartitionStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) RecoverPartitionStatement() (localctx IRecoverPartitionStatementContext) { +func (p *StarRocksSQLParser) RecoverPartitionStatement() (localctx IRecoverPartitionStatementContext) { localctx = NewRecoverPartitionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 114, DorisSQLParserRULE_recoverPartitionStatement) + p.EnterRule(localctx, 114, StarRocksSQLParserRULE_recoverPartitionStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2112) - p.Match(DorisSQLParserRECOVER) + p.Match(StarRocksSQLParserRECOVER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26314,7 +26314,7 @@ func (p *DorisSQLParser) RecoverPartitionStatement() (localctx IRecoverPartition } { p.SetState(2113) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26326,7 +26326,7 @@ func (p *DorisSQLParser) RecoverPartitionStatement() (localctx IRecoverPartition } { p.SetState(2115) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26390,13 +26390,13 @@ type CreateViewStatementContext struct { func NewEmptyCreateViewStatementContext() *CreateViewStatementContext { var p = new(CreateViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createViewStatement + p.RuleIndex = StarRocksSQLParserRULE_createViewStatement return p } func InitEmptyCreateViewStatementContext(p *CreateViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createViewStatement + p.RuleIndex = StarRocksSQLParserRULE_createViewStatement } func (*CreateViewStatementContext) IsCreateViewStatementContext() {} @@ -26407,7 +26407,7 @@ func NewCreateViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createViewStatement + p.RuleIndex = StarRocksSQLParserRULE_createViewStatement return p } @@ -26415,11 +26415,11 @@ func NewCreateViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *CreateViewStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateViewStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *CreateViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -26439,7 +26439,7 @@ func (s *CreateViewStatementContext) QualifiedName() IQualifiedNameContext { } func (s *CreateViewStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *CreateViewStatementContext) QueryStatement() IQueryStatementContext { @@ -26459,23 +26459,23 @@ func (s *CreateViewStatementContext) QueryStatement() IQueryStatementContext { } func (s *CreateViewStatementContext) OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOR, 0) + return s.GetToken(StarRocksSQLParserOR, 0) } func (s *CreateViewStatementContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *CreateViewStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateViewStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateViewStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateViewStatementContext) AllColumnNameWithComment() []IColumnNameWithCommentContext { @@ -26536,15 +26536,15 @@ func (s *CreateViewStatementContext) Comment() ICommentContext { } func (s *CreateViewStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *CreateViewStatementContext) NONE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNONE, 0) + return s.GetToken(StarRocksSQLParserNONE, 0) } func (s *CreateViewStatementContext) INVOKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINVOKER, 0) + return s.GetToken(StarRocksSQLParserINVOKER, 0) } func (s *CreateViewStatementContext) GetRuleContext() antlr.RuleContext { @@ -26556,20 +26556,20 @@ func (s *CreateViewStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *CreateViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateViewStatement(s) } } func (s *CreateViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateViewStatement(s) } } func (s *CreateViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateViewStatement(s) default: @@ -26577,15 +26577,15 @@ func (s *CreateViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementContext) { +func (p *StarRocksSQLParser) CreateViewStatement() (localctx ICreateViewStatementContext) { localctx = NewCreateViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 116, DorisSQLParserRULE_createViewStatement) + p.EnterRule(localctx, 116, StarRocksSQLParserRULE_createViewStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2118) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26598,10 +26598,10 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserOR { + if _la == StarRocksSQLParserOR { { p.SetState(2119) - p.Match(DorisSQLParserOR) + p.Match(StarRocksSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26609,7 +26609,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } { p.SetState(2120) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26619,7 +26619,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } { p.SetState(2123) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26632,10 +26632,10 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2124) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26643,7 +26643,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } { p.SetState(2125) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26651,7 +26651,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } { p.SetState(2126) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26670,10 +26670,10 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(2130) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26690,10 +26690,10 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2132) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26713,7 +26713,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } { p.SetState(2139) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26728,7 +26728,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(2143) p.Comment() @@ -26742,10 +26742,10 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSECURITY { + if _la == StarRocksSQLParserSECURITY { { p.SetState(2146) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26755,7 +26755,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon p.SetState(2147) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserINVOKER || _la == DorisSQLParserNONE) { + if !(_la == StarRocksSQLParserINVOKER || _la == StarRocksSQLParserNONE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -26766,7 +26766,7 @@ func (p *DorisSQLParser) CreateViewStatement() (localctx ICreateViewStatementCon } { p.SetState(2150) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -26826,13 +26826,13 @@ type AlterViewStatementContext struct { func NewEmptyAlterViewStatementContext() *AlterViewStatementContext { var p = new(AlterViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterViewStatement + p.RuleIndex = StarRocksSQLParserRULE_alterViewStatement return p } func InitEmptyAlterViewStatementContext(p *AlterViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterViewStatement + p.RuleIndex = StarRocksSQLParserRULE_alterViewStatement } func (*AlterViewStatementContext) IsAlterViewStatementContext() {} @@ -26843,7 +26843,7 @@ func NewAlterViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterViewStatement + p.RuleIndex = StarRocksSQLParserRULE_alterViewStatement return p } @@ -26851,11 +26851,11 @@ func NewAlterViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *AlterViewStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterViewStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *AlterViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -26875,7 +26875,7 @@ func (s *AlterViewStatementContext) QualifiedName() IQualifiedNameContext { } func (s *AlterViewStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *AlterViewStatementContext) QueryStatement() IQueryStatementContext { @@ -26936,19 +26936,19 @@ func (s *AlterViewStatementContext) ColumnNameWithComment(i int) IColumnNameWith } func (s *AlterViewStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterViewStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *AlterViewStatementContext) NONE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNONE, 0) + return s.GetToken(StarRocksSQLParserNONE, 0) } func (s *AlterViewStatementContext) INVOKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINVOKER, 0) + return s.GetToken(StarRocksSQLParserINVOKER, 0) } func (s *AlterViewStatementContext) Properties() IPropertiesContext { @@ -26968,15 +26968,15 @@ func (s *AlterViewStatementContext) Properties() IPropertiesContext { } func (s *AlterViewStatementContext) DIALECT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDIALECT, 0) + return s.GetToken(StarRocksSQLParserDIALECT, 0) } func (s *AlterViewStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AlterViewStatementContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *AlterViewStatementContext) GetRuleContext() antlr.RuleContext { @@ -26988,20 +26988,20 @@ func (s *AlterViewStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *AlterViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterViewStatement(s) } } func (s *AlterViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterViewStatement(s) } } func (s *AlterViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterViewStatement(s) default: @@ -27009,9 +27009,9 @@ func (s *AlterViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementContext) { +func (p *StarRocksSQLParser) AlterViewStatement() (localctx IAlterViewStatementContext) { localctx = NewAlterViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 118, DorisSQLParserRULE_alterViewStatement) + p.EnterRule(localctx, 118, StarRocksSQLParserRULE_alterViewStatement) var _la int p.SetState(2192) @@ -27025,7 +27025,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte p.EnterOuterAlt(localctx, 1) { p.SetState(2153) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27033,7 +27033,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2154) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27050,10 +27050,10 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(2156) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27070,10 +27070,10 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2158) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27093,7 +27093,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2165) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27103,7 +27103,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2169) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27118,7 +27118,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte p.EnterOuterAlt(localctx, 2) { p.SetState(2172) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27126,7 +27126,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2173) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27138,7 +27138,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2175) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27146,7 +27146,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2176) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27156,7 +27156,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte p.SetState(2177) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserINVOKER || _la == DorisSQLParserNONE) { + if !(_la == StarRocksSQLParserINVOKER || _la == StarRocksSQLParserNONE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -27168,7 +27168,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte p.EnterOuterAlt(localctx, 3) { p.SetState(2179) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27176,7 +27176,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2180) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27188,7 +27188,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2182) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27203,7 +27203,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte p.EnterOuterAlt(localctx, 4) { p.SetState(2185) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27211,7 +27211,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2186) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27225,7 +27225,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte p.SetState(2188) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserADD || _la == DorisSQLParserMODIFY) { + if !(_la == StarRocksSQLParserADD || _la == StarRocksSQLParserMODIFY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -27234,7 +27234,7 @@ func (p *DorisSQLParser) AlterViewStatement() (localctx IAlterViewStatementConte } { p.SetState(2189) - p.Match(DorisSQLParserDIALECT) + p.Match(StarRocksSQLParserDIALECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27288,13 +27288,13 @@ type DropViewStatementContext struct { func NewEmptyDropViewStatementContext() *DropViewStatementContext { var p = new(DropViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropViewStatement + p.RuleIndex = StarRocksSQLParserRULE_dropViewStatement return p } func InitEmptyDropViewStatementContext(p *DropViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropViewStatement + p.RuleIndex = StarRocksSQLParserRULE_dropViewStatement } func (*DropViewStatementContext) IsDropViewStatementContext() {} @@ -27305,7 +27305,7 @@ func NewDropViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropViewStatement + p.RuleIndex = StarRocksSQLParserRULE_dropViewStatement return p } @@ -27313,11 +27313,11 @@ func NewDropViewStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DropViewStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropViewStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *DropViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -27337,11 +27337,11 @@ func (s *DropViewStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropViewStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropViewStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropViewStatementContext) GetRuleContext() antlr.RuleContext { @@ -27353,20 +27353,20 @@ func (s *DropViewStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropViewStatement(s) } } func (s *DropViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropViewStatement(s) } } func (s *DropViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropViewStatement(s) default: @@ -27374,15 +27374,15 @@ func (s *DropViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropViewStatement() (localctx IDropViewStatementContext) { +func (p *StarRocksSQLParser) DropViewStatement() (localctx IDropViewStatementContext) { localctx = NewDropViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 120, DorisSQLParserRULE_dropViewStatement) + p.EnterRule(localctx, 120, StarRocksSQLParserRULE_dropViewStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2194) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27390,7 +27390,7 @@ func (p *DorisSQLParser) DropViewStatement() (localctx IDropViewStatementContext } { p.SetState(2195) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27403,10 +27403,10 @@ func (p *DorisSQLParser) DropViewStatement() (localctx IDropViewStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2196) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27414,7 +27414,7 @@ func (p *DorisSQLParser) DropViewStatement() (localctx IDropViewStatementContext } { p.SetState(2197) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27470,13 +27470,13 @@ type ColumnNameWithCommentContext struct { func NewEmptyColumnNameWithCommentContext() *ColumnNameWithCommentContext { var p = new(ColumnNameWithCommentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnNameWithComment + p.RuleIndex = StarRocksSQLParserRULE_columnNameWithComment return p } func InitEmptyColumnNameWithCommentContext(p *ColumnNameWithCommentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnNameWithComment + p.RuleIndex = StarRocksSQLParserRULE_columnNameWithComment } func (*ColumnNameWithCommentContext) IsColumnNameWithCommentContext() {} @@ -27487,7 +27487,7 @@ func NewColumnNameWithCommentContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnNameWithComment + p.RuleIndex = StarRocksSQLParserRULE_columnNameWithComment return p } @@ -27539,20 +27539,20 @@ func (s *ColumnNameWithCommentContext) ToStringTree(ruleNames []string, recog an } func (s *ColumnNameWithCommentContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnNameWithComment(s) } } func (s *ColumnNameWithCommentContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnNameWithComment(s) } } func (s *ColumnNameWithCommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnNameWithComment(s) default: @@ -27560,9 +27560,9 @@ func (s *ColumnNameWithCommentContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ColumnNameWithComment() (localctx IColumnNameWithCommentContext) { +func (p *StarRocksSQLParser) ColumnNameWithComment() (localctx IColumnNameWithCommentContext) { localctx = NewColumnNameWithCommentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 122, DorisSQLParserRULE_columnNameWithComment) + p.EnterRule(localctx, 122, StarRocksSQLParserRULE_columnNameWithComment) var _la int p.EnterOuterAlt(localctx, 1) @@ -27580,7 +27580,7 @@ func (p *DorisSQLParser) ColumnNameWithComment() (localctx IColumnNameWithCommen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(2203) p.Comment() @@ -27631,13 +27631,13 @@ type SubmitTaskStatementContext struct { func NewEmptySubmitTaskStatementContext() *SubmitTaskStatementContext { var p = new(SubmitTaskStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_submitTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_submitTaskStatement return p } func InitEmptySubmitTaskStatementContext(p *SubmitTaskStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_submitTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_submitTaskStatement } func (*SubmitTaskStatementContext) IsSubmitTaskStatementContext() {} @@ -27648,7 +27648,7 @@ func NewSubmitTaskStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_submitTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_submitTaskStatement return p } @@ -27656,15 +27656,15 @@ func NewSubmitTaskStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *SubmitTaskStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SubmitTaskStatementContext) SUBMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUBMIT, 0) + return s.GetToken(StarRocksSQLParserSUBMIT, 0) } func (s *SubmitTaskStatementContext) TASK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTASK, 0) + return s.GetToken(StarRocksSQLParserTASK, 0) } func (s *SubmitTaskStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *SubmitTaskStatementContext) CreateTableAsSelectStatement() ICreateTableAsSelectStatementContext { @@ -27781,20 +27781,20 @@ func (s *SubmitTaskStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *SubmitTaskStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubmitTaskStatement(s) } } func (s *SubmitTaskStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubmitTaskStatement(s) } } func (s *SubmitTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubmitTaskStatement(s) default: @@ -27802,15 +27802,15 @@ func (s *SubmitTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) SubmitTaskStatement() (localctx ISubmitTaskStatementContext) { +func (p *StarRocksSQLParser) SubmitTaskStatement() (localctx ISubmitTaskStatementContext) { localctx = NewSubmitTaskStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 124, DorisSQLParserRULE_submitTaskStatement) + p.EnterRule(localctx, 124, StarRocksSQLParserRULE_submitTaskStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2206) - p.Match(DorisSQLParserSUBMIT) + p.Match(StarRocksSQLParserSUBMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27818,7 +27818,7 @@ func (p *DorisSQLParser) SubmitTaskStatement() (localctx ISubmitTaskStatementCon } { p.SetState(2207) - p.Match(DorisSQLParserTASK) + p.Match(StarRocksSQLParserTASK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27843,7 +27843,7 @@ func (p *DorisSQLParser) SubmitTaskStatement() (localctx ISubmitTaskStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserPROPERTIES || _la == DorisSQLParserSCHEDULE { + for _la == StarRocksSQLParserPROPERTIES || _la == StarRocksSQLParserSCHEDULE { { p.SetState(2211) p.TaskClause() @@ -27858,7 +27858,7 @@ func (p *DorisSQLParser) SubmitTaskStatement() (localctx ISubmitTaskStatementCon } { p.SetState(2217) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -27871,19 +27871,19 @@ func (p *DorisSQLParser) SubmitTaskStatement() (localctx ISubmitTaskStatementCon } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCREATE: + case StarRocksSQLParserCREATE: { p.SetState(2218) p.CreateTableAsSelectStatement() } - case DorisSQLParserDESC, DorisSQLParserDESCRIBE, DorisSQLParserEXPLAIN, DorisSQLParserINSERT: + case StarRocksSQLParserDESC, StarRocksSQLParserDESCRIBE, StarRocksSQLParserEXPLAIN, StarRocksSQLParserINSERT: { p.SetState(2219) p.InsertStatement() } - case DorisSQLParserCACHE: + case StarRocksSQLParserCACHE: { p.SetState(2220) p.DataCacheSelectStatement() @@ -27930,13 +27930,13 @@ type TaskClauseContext struct { func NewEmptyTaskClauseContext() *TaskClauseContext { var p = new(TaskClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskClause + p.RuleIndex = StarRocksSQLParserRULE_taskClause return p } func InitEmptyTaskClauseContext(p *TaskClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskClause + p.RuleIndex = StarRocksSQLParserRULE_taskClause } func (*TaskClauseContext) IsTaskClauseContext() {} @@ -27947,7 +27947,7 @@ func NewTaskClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_taskClause + p.RuleIndex = StarRocksSQLParserRULE_taskClause return p } @@ -27995,20 +27995,20 @@ func (s *TaskClauseContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *TaskClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTaskClause(s) } } func (s *TaskClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTaskClause(s) } } func (s *TaskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTaskClause(s) default: @@ -28016,9 +28016,9 @@ func (s *TaskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TaskClause() (localctx ITaskClauseContext) { +func (p *StarRocksSQLParser) TaskClause() (localctx ITaskClauseContext) { localctx = NewTaskClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 126, DorisSQLParserRULE_taskClause) + p.EnterRule(localctx, 126, StarRocksSQLParserRULE_taskClause) p.SetState(2225) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -28026,14 +28026,14 @@ func (p *DorisSQLParser) TaskClause() (localctx ITaskClauseContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserPROPERTIES: + case StarRocksSQLParserPROPERTIES: p.EnterOuterAlt(localctx, 1) { p.SetState(2223) p.Properties() } - case DorisSQLParserSCHEDULE: + case StarRocksSQLParserSCHEDULE: p.EnterOuterAlt(localctx, 2) { p.SetState(2224) @@ -28083,13 +28083,13 @@ type DropTaskStatementContext struct { func NewEmptyDropTaskStatementContext() *DropTaskStatementContext { var p = new(DropTaskStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_dropTaskStatement return p } func InitEmptyDropTaskStatementContext(p *DropTaskStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_dropTaskStatement } func (*DropTaskStatementContext) IsDropTaskStatementContext() {} @@ -28100,7 +28100,7 @@ func NewDropTaskStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_dropTaskStatement return p } @@ -28108,11 +28108,11 @@ func NewDropTaskStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DropTaskStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropTaskStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropTaskStatementContext) TASK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTASK, 0) + return s.GetToken(StarRocksSQLParserTASK, 0) } func (s *DropTaskStatementContext) QualifiedName() IQualifiedNameContext { @@ -28132,7 +28132,7 @@ func (s *DropTaskStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropTaskStatementContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *DropTaskStatementContext) GetRuleContext() antlr.RuleContext { @@ -28144,20 +28144,20 @@ func (s *DropTaskStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropTaskStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropTaskStatement(s) } } func (s *DropTaskStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropTaskStatement(s) } } func (s *DropTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropTaskStatement(s) default: @@ -28165,15 +28165,15 @@ func (s *DropTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropTaskStatement() (localctx IDropTaskStatementContext) { +func (p *StarRocksSQLParser) DropTaskStatement() (localctx IDropTaskStatementContext) { localctx = NewDropTaskStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 128, DorisSQLParserRULE_dropTaskStatement) + p.EnterRule(localctx, 128, StarRocksSQLParserRULE_dropTaskStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2227) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28181,7 +28181,7 @@ func (p *DorisSQLParser) DropTaskStatement() (localctx IDropTaskStatementContext } { p.SetState(2228) - p.Match(DorisSQLParserTASK) + p.Match(StarRocksSQLParserTASK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28198,10 +28198,10 @@ func (p *DorisSQLParser) DropTaskStatement() (localctx IDropTaskStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(2230) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28249,13 +28249,13 @@ type TaskScheduleDescContext struct { func NewEmptyTaskScheduleDescContext() *TaskScheduleDescContext { var p = new(TaskScheduleDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskScheduleDesc + p.RuleIndex = StarRocksSQLParserRULE_taskScheduleDesc return p } func InitEmptyTaskScheduleDescContext(p *TaskScheduleDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskScheduleDesc + p.RuleIndex = StarRocksSQLParserRULE_taskScheduleDesc } func (*TaskScheduleDescContext) IsTaskScheduleDescContext() {} @@ -28266,7 +28266,7 @@ func NewTaskScheduleDescContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_taskScheduleDesc + p.RuleIndex = StarRocksSQLParserRULE_taskScheduleDesc return p } @@ -28274,11 +28274,11 @@ func NewTaskScheduleDescContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *TaskScheduleDescContext) GetParser() antlr.Parser { return s.parser } func (s *TaskScheduleDescContext) SCHEDULE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEDULE, 0) + return s.GetToken(StarRocksSQLParserSCHEDULE, 0) } func (s *TaskScheduleDescContext) EVERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEVERY, 0) + return s.GetToken(StarRocksSQLParserEVERY, 0) } func (s *TaskScheduleDescContext) TaskInterval() ITaskIntervalContext { @@ -28298,7 +28298,7 @@ func (s *TaskScheduleDescContext) TaskInterval() ITaskIntervalContext { } func (s *TaskScheduleDescContext) START() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTART, 0) + return s.GetToken(StarRocksSQLParserSTART, 0) } func (s *TaskScheduleDescContext) String_() IStringContext { @@ -28326,20 +28326,20 @@ func (s *TaskScheduleDescContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *TaskScheduleDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTaskScheduleDesc(s) } } func (s *TaskScheduleDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTaskScheduleDesc(s) } } func (s *TaskScheduleDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTaskScheduleDesc(s) default: @@ -28347,15 +28347,15 @@ func (s *TaskScheduleDescContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) { +func (p *StarRocksSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) { localctx = NewTaskScheduleDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 130, DorisSQLParserRULE_taskScheduleDesc) + p.EnterRule(localctx, 130, StarRocksSQLParserRULE_taskScheduleDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2233) - p.Match(DorisSQLParserSCHEDULE) + p.Match(StarRocksSQLParserSCHEDULE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28368,10 +28368,10 @@ func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSTART { + if _la == StarRocksSQLParserSTART { { p.SetState(2234) - p.Match(DorisSQLParserSTART) + p.Match(StarRocksSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28379,7 +28379,7 @@ func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) } { p.SetState(2235) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28391,7 +28391,7 @@ func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) } { p.SetState(2237) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28401,7 +28401,7 @@ func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) } { p.SetState(2241) - p.Match(DorisSQLParserEVERY) + p.Match(StarRocksSQLParserEVERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28409,7 +28409,7 @@ func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) } { p.SetState(2242) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28421,7 +28421,7 @@ func (p *DorisSQLParser) TaskScheduleDesc() (localctx ITaskScheduleDescContext) } { p.SetState(2244) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28485,13 +28485,13 @@ type CreateMaterializedViewStatementContext struct { func NewEmptyCreateMaterializedViewStatementContext() *CreateMaterializedViewStatementContext { var p = new(CreateMaterializedViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_createMaterializedViewStatement return p } func InitEmptyCreateMaterializedViewStatementContext(p *CreateMaterializedViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_createMaterializedViewStatement } func (*CreateMaterializedViewStatementContext) IsCreateMaterializedViewStatementContext() {} @@ -28502,7 +28502,7 @@ func NewCreateMaterializedViewStatementContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_createMaterializedViewStatement return p } @@ -28514,19 +28514,19 @@ func (s *CreateMaterializedViewStatementContext) GetMvName() IQualifiedNameConte func (s *CreateMaterializedViewStatementContext) SetMvName(v IQualifiedNameContext) { s.mvName = v } func (s *CreateMaterializedViewStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateMaterializedViewStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *CreateMaterializedViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *CreateMaterializedViewStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *CreateMaterializedViewStatementContext) QueryStatement() IQueryStatementContext { @@ -28562,15 +28562,15 @@ func (s *CreateMaterializedViewStatementContext) QualifiedName() IQualifiedNameC } func (s *CreateMaterializedViewStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateMaterializedViewStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateMaterializedViewStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateMaterializedViewStatementContext) AllColumnNameWithComment() []IColumnNameWithCommentContext { @@ -28721,20 +28721,20 @@ func (s *CreateMaterializedViewStatementContext) ToStringTree(ruleNames []string } func (s *CreateMaterializedViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateMaterializedViewStatement(s) } } func (s *CreateMaterializedViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateMaterializedViewStatement(s) } } func (s *CreateMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateMaterializedViewStatement(s) default: @@ -28742,9 +28742,9 @@ func (s *CreateMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeV } } -func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMaterializedViewStatementContext) { +func (p *StarRocksSQLParser) CreateMaterializedViewStatement() (localctx ICreateMaterializedViewStatementContext) { localctx = NewCreateMaterializedViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 132, DorisSQLParserRULE_createMaterializedViewStatement) + p.EnterRule(localctx, 132, StarRocksSQLParserRULE_createMaterializedViewStatement) var _la int var _alt int @@ -28752,7 +28752,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate p.EnterOuterAlt(localctx, 1) { p.SetState(2246) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28760,7 +28760,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } { p.SetState(2247) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28768,7 +28768,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } { p.SetState(2248) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28781,10 +28781,10 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2249) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28792,7 +28792,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } { p.SetState(2250) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28800,7 +28800,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } { p.SetState(2251) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28822,10 +28822,10 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(2255) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28848,7 +28848,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate if _alt == 1 { { p.SetState(2257) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28877,10 +28877,10 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2264) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28900,7 +28900,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } { p.SetState(2271) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28915,7 +28915,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(2275) p.Comment() @@ -28929,7 +28929,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserDISTRIBUTED || ((int64((_la-300)) & ^0x3f) == 0 && ((int64(1)<<(_la-300))&1125917086711841) != 0) { + for _la == StarRocksSQLParserDISTRIBUTED || ((int64((_la-300)) & ^0x3f) == 0 && ((int64(1)<<(_la-300))&1125917086711841) != 0) { { p.SetState(2278) p.MaterializedViewDesc() @@ -28944,7 +28944,7 @@ func (p *DorisSQLParser) CreateMaterializedViewStatement() (localctx ICreateMate } { p.SetState(2284) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -28991,13 +28991,13 @@ type MvPartitionExprsContext struct { func NewEmptyMvPartitionExprsContext() *MvPartitionExprsContext { var p = new(MvPartitionExprsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mvPartitionExprs + p.RuleIndex = StarRocksSQLParserRULE_mvPartitionExprs return p } func InitEmptyMvPartitionExprsContext(p *MvPartitionExprsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mvPartitionExprs + p.RuleIndex = StarRocksSQLParserRULE_mvPartitionExprs } func (*MvPartitionExprsContext) IsMvPartitionExprsContext() {} @@ -29008,7 +29008,7 @@ func NewMvPartitionExprsContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_mvPartitionExprs + p.RuleIndex = StarRocksSQLParserRULE_mvPartitionExprs return p } @@ -29065,20 +29065,20 @@ func (s *MvPartitionExprsContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *MvPartitionExprsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMvPartitionExprs(s) } } func (s *MvPartitionExprsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMvPartitionExprs(s) } } func (s *MvPartitionExprsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMvPartitionExprs(s) default: @@ -29086,9 +29086,9 @@ func (s *MvPartitionExprsContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) MvPartitionExprs() (localctx IMvPartitionExprsContext) { +func (p *StarRocksSQLParser) MvPartitionExprs() (localctx IMvPartitionExprsContext) { localctx = NewMvPartitionExprsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 134, DorisSQLParserRULE_mvPartitionExprs) + p.EnterRule(localctx, 134, StarRocksSQLParserRULE_mvPartitionExprs) var _la int p.SetState(2299) @@ -29109,7 +29109,7 @@ func (p *DorisSQLParser) MvPartitionExprs() (localctx IMvPartitionExprsContext) p.EnterOuterAlt(localctx, 2) { p.SetState(2288) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29126,10 +29126,10 @@ func (p *DorisSQLParser) MvPartitionExprs() (localctx IMvPartitionExprsContext) } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2290) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29149,7 +29149,7 @@ func (p *DorisSQLParser) MvPartitionExprs() (localctx IMvPartitionExprsContext) } { p.SetState(2297) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29201,13 +29201,13 @@ type MaterializedViewDescContext struct { func NewEmptyMaterializedViewDescContext() *MaterializedViewDescContext { var p = new(MaterializedViewDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_materializedViewDesc + p.RuleIndex = StarRocksSQLParserRULE_materializedViewDesc return p } func InitEmptyMaterializedViewDescContext(p *MaterializedViewDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_materializedViewDesc + p.RuleIndex = StarRocksSQLParserRULE_materializedViewDesc } func (*MaterializedViewDescContext) IsMaterializedViewDescContext() {} @@ -29218,7 +29218,7 @@ func NewMaterializedViewDescContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_materializedViewDesc + p.RuleIndex = StarRocksSQLParserRULE_materializedViewDesc return p } @@ -29226,11 +29226,11 @@ func NewMaterializedViewDescContext(parser antlr.Parser, parent antlr.ParserRule func (s *MaterializedViewDescContext) GetParser() antlr.Parser { return s.parser } func (s *MaterializedViewDescContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *MaterializedViewDescContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *MaterializedViewDescContext) MvPartitionExprs() IMvPartitionExprsContext { @@ -29322,20 +29322,20 @@ func (s *MaterializedViewDescContext) ToStringTree(ruleNames []string, recog ant } func (s *MaterializedViewDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMaterializedViewDesc(s) } } func (s *MaterializedViewDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMaterializedViewDesc(s) } } func (s *MaterializedViewDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMaterializedViewDesc(s) default: @@ -29343,9 +29343,9 @@ func (s *MaterializedViewDescContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) MaterializedViewDesc() (localctx IMaterializedViewDescContext) { +func (p *StarRocksSQLParser) MaterializedViewDesc() (localctx IMaterializedViewDescContext) { localctx = NewMaterializedViewDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 136, DorisSQLParserRULE_materializedViewDesc) + p.EnterRule(localctx, 136, StarRocksSQLParserRULE_materializedViewDesc) p.SetState(2308) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -29353,11 +29353,11 @@ func (p *DorisSQLParser) MaterializedViewDesc() (localctx IMaterializedViewDescC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserPARTITION: + case StarRocksSQLParserPARTITION: p.EnterOuterAlt(localctx, 1) { p.SetState(2301) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29365,7 +29365,7 @@ func (p *DorisSQLParser) MaterializedViewDesc() (localctx IMaterializedViewDescC } { p.SetState(2302) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29376,28 +29376,28 @@ func (p *DorisSQLParser) MaterializedViewDesc() (localctx IMaterializedViewDescC p.MvPartitionExprs() } - case DorisSQLParserDISTRIBUTED: + case StarRocksSQLParserDISTRIBUTED: p.EnterOuterAlt(localctx, 2) { p.SetState(2304) p.DistributionDesc() } - case DorisSQLParserORDER: + case StarRocksSQLParserORDER: p.EnterOuterAlt(localctx, 3) { p.SetState(2305) p.OrderByDesc() } - case DorisSQLParserREFRESH: + case StarRocksSQLParserREFRESH: p.EnterOuterAlt(localctx, 4) { p.SetState(2306) p.RefreshSchemeDesc() } - case DorisSQLParserPROPERTIES: + case StarRocksSQLParserPROPERTIES: p.EnterOuterAlt(localctx, 5) { p.SetState(2307) @@ -29467,13 +29467,13 @@ type ShowMaterializedViewsStatementContext struct { func NewEmptyShowMaterializedViewsStatementContext() *ShowMaterializedViewsStatementContext { var p = new(ShowMaterializedViewsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showMaterializedViewsStatement + p.RuleIndex = StarRocksSQLParserRULE_showMaterializedViewsStatement return p } func InitEmptyShowMaterializedViewsStatementContext(p *ShowMaterializedViewsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showMaterializedViewsStatement + p.RuleIndex = StarRocksSQLParserRULE_showMaterializedViewsStatement } func (*ShowMaterializedViewsStatementContext) IsShowMaterializedViewsStatementContext() {} @@ -29484,7 +29484,7 @@ func NewShowMaterializedViewsStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showMaterializedViewsStatement + p.RuleIndex = StarRocksSQLParserRULE_showMaterializedViewsStatement return p } @@ -29500,23 +29500,23 @@ func (s *ShowMaterializedViewsStatementContext) SetDb(v IQualifiedNameContext) { func (s *ShowMaterializedViewsStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowMaterializedViewsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowMaterializedViewsStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *ShowMaterializedViewsStatementContext) VIEWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEWS, 0) + return s.GetToken(StarRocksSQLParserVIEWS, 0) } func (s *ShowMaterializedViewsStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowMaterializedViewsStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowMaterializedViewsStatementContext) QualifiedName() IQualifiedNameContext { @@ -29536,11 +29536,11 @@ func (s *ShowMaterializedViewsStatementContext) QualifiedName() IQualifiedNameCo } func (s *ShowMaterializedViewsStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowMaterializedViewsStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowMaterializedViewsStatementContext) Expression() IExpressionContext { @@ -29584,20 +29584,20 @@ func (s *ShowMaterializedViewsStatementContext) ToStringTree(ruleNames []string, } func (s *ShowMaterializedViewsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowMaterializedViewsStatement(s) } } func (s *ShowMaterializedViewsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowMaterializedViewsStatement(s) } } func (s *ShowMaterializedViewsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowMaterializedViewsStatement(s) default: @@ -29605,15 +29605,15 @@ func (s *ShowMaterializedViewsStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMaterializedViewsStatementContext) { +func (p *StarRocksSQLParser) ShowMaterializedViewsStatement() (localctx IShowMaterializedViewsStatementContext) { localctx = NewShowMaterializedViewsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 138, DorisSQLParserRULE_showMaterializedViewsStatement) + p.EnterRule(localctx, 138, StarRocksSQLParserRULE_showMaterializedViewsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2310) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29621,7 +29621,7 @@ func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMateria } { p.SetState(2311) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29629,7 +29629,7 @@ func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMateria } { p.SetState(2312) - p.Match(DorisSQLParserVIEWS) + p.Match(StarRocksSQLParserVIEWS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29642,12 +29642,12 @@ func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMateria } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(2313) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -29669,10 +29669,10 @@ func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMateria goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(2317) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29686,10 +29686,10 @@ func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMateria localctx.(*ShowMaterializedViewsStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(2319) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29700,7 +29700,7 @@ func (p *DorisSQLParser) ShowMaterializedViewsStatement() (localctx IShowMateria p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -29752,13 +29752,13 @@ type DropMaterializedViewStatementContext struct { func NewEmptyDropMaterializedViewStatementContext() *DropMaterializedViewStatementContext { var p = new(DropMaterializedViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_dropMaterializedViewStatement return p } func InitEmptyDropMaterializedViewStatementContext(p *DropMaterializedViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_dropMaterializedViewStatement } func (*DropMaterializedViewStatementContext) IsDropMaterializedViewStatementContext() {} @@ -29769,7 +29769,7 @@ func NewDropMaterializedViewStatementContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_dropMaterializedViewStatement return p } @@ -29781,15 +29781,15 @@ func (s *DropMaterializedViewStatementContext) GetMvName() IQualifiedNameContext func (s *DropMaterializedViewStatementContext) SetMvName(v IQualifiedNameContext) { s.mvName = v } func (s *DropMaterializedViewStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropMaterializedViewStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *DropMaterializedViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *DropMaterializedViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -29809,11 +29809,11 @@ func (s *DropMaterializedViewStatementContext) QualifiedName() IQualifiedNameCon } func (s *DropMaterializedViewStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropMaterializedViewStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropMaterializedViewStatementContext) GetRuleContext() antlr.RuleContext { @@ -29825,20 +29825,20 @@ func (s *DropMaterializedViewStatementContext) ToStringTree(ruleNames []string, } func (s *DropMaterializedViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropMaterializedViewStatement(s) } } func (s *DropMaterializedViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropMaterializedViewStatement(s) } } func (s *DropMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropMaterializedViewStatement(s) default: @@ -29846,15 +29846,15 @@ func (s *DropMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVis } } -func (p *DorisSQLParser) DropMaterializedViewStatement() (localctx IDropMaterializedViewStatementContext) { +func (p *StarRocksSQLParser) DropMaterializedViewStatement() (localctx IDropMaterializedViewStatementContext) { localctx = NewDropMaterializedViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 140, DorisSQLParserRULE_dropMaterializedViewStatement) + p.EnterRule(localctx, 140, StarRocksSQLParserRULE_dropMaterializedViewStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2323) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29862,7 +29862,7 @@ func (p *DorisSQLParser) DropMaterializedViewStatement() (localctx IDropMaterial } { p.SetState(2324) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29870,7 +29870,7 @@ func (p *DorisSQLParser) DropMaterializedViewStatement() (localctx IDropMaterial } { p.SetState(2325) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29883,10 +29883,10 @@ func (p *DorisSQLParser) DropMaterializedViewStatement() (localctx IDropMaterial } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2326) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29894,7 +29894,7 @@ func (p *DorisSQLParser) DropMaterializedViewStatement() (localctx IDropMaterial } { p.SetState(2327) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -29960,13 +29960,13 @@ type AlterMaterializedViewStatementContext struct { func NewEmptyAlterMaterializedViewStatementContext() *AlterMaterializedViewStatementContext { var p = new(AlterMaterializedViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_alterMaterializedViewStatement return p } func InitEmptyAlterMaterializedViewStatementContext(p *AlterMaterializedViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_alterMaterializedViewStatement } func (*AlterMaterializedViewStatementContext) IsAlterMaterializedViewStatementContext() {} @@ -29977,7 +29977,7 @@ func NewAlterMaterializedViewStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_alterMaterializedViewStatement return p } @@ -29989,15 +29989,15 @@ func (s *AlterMaterializedViewStatementContext) GetMvName() IQualifiedNameContex func (s *AlterMaterializedViewStatementContext) SetMvName(v IQualifiedNameContext) { s.mvName = v } func (s *AlterMaterializedViewStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterMaterializedViewStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *AlterMaterializedViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *AlterMaterializedViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -30105,20 +30105,20 @@ func (s *AlterMaterializedViewStatementContext) ToStringTree(ruleNames []string, } func (s *AlterMaterializedViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterMaterializedViewStatement(s) } } func (s *AlterMaterializedViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterMaterializedViewStatement(s) } } func (s *AlterMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterMaterializedViewStatement(s) default: @@ -30126,9 +30126,9 @@ func (s *AlterMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMaterializedViewStatementContext) { +func (p *StarRocksSQLParser) AlterMaterializedViewStatement() (localctx IAlterMaterializedViewStatementContext) { localctx = NewAlterMaterializedViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 142, DorisSQLParserRULE_alterMaterializedViewStatement) + p.EnterRule(localctx, 142, StarRocksSQLParserRULE_alterMaterializedViewStatement) p.SetState(2348) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -30140,7 +30140,7 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri p.EnterOuterAlt(localctx, 1) { p.SetState(2332) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30148,7 +30148,7 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri } { p.SetState(2333) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30156,7 +30156,7 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri } { p.SetState(2334) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30176,25 +30176,25 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri } switch p.GetTokenStream().LA(1) { - case DorisSQLParserREFRESH: + case StarRocksSQLParserREFRESH: { p.SetState(2336) p.RefreshSchemeDesc() } - case DorisSQLParserRENAME: + case StarRocksSQLParserRENAME: { p.SetState(2337) p.TableRenameClause() } - case DorisSQLParserSET: + case StarRocksSQLParserSET: { p.SetState(2338) p.ModifyPropertiesClause() } - case DorisSQLParserSWAP: + case StarRocksSQLParserSWAP: { p.SetState(2339) p.SwapTableClause() @@ -30209,7 +30209,7 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri p.EnterOuterAlt(localctx, 2) { p.SetState(2342) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30217,7 +30217,7 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri } { p.SetState(2343) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30225,7 +30225,7 @@ func (p *DorisSQLParser) AlterMaterializedViewStatement() (localctx IAlterMateri } { p.SetState(2344) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30310,13 +30310,13 @@ type RefreshMaterializedViewStatementContext struct { func NewEmptyRefreshMaterializedViewStatementContext() *RefreshMaterializedViewStatementContext { var p = new(RefreshMaterializedViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshMaterializedViewStatement return p } func InitEmptyRefreshMaterializedViewStatementContext(p *RefreshMaterializedViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshMaterializedViewStatement } func (*RefreshMaterializedViewStatementContext) IsRefreshMaterializedViewStatementContext() {} @@ -30327,7 +30327,7 @@ func NewRefreshMaterializedViewStatementContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_refreshMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshMaterializedViewStatement return p } @@ -30343,15 +30343,15 @@ func (s *RefreshMaterializedViewStatementContext) GetMvName() IQualifiedNameCont func (s *RefreshMaterializedViewStatementContext) SetMvName(v IQualifiedNameContext) { s.mvName = v } func (s *RefreshMaterializedViewStatementContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *RefreshMaterializedViewStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *RefreshMaterializedViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *RefreshMaterializedViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -30371,39 +30371,39 @@ func (s *RefreshMaterializedViewStatementContext) QualifiedName() IQualifiedName } func (s *RefreshMaterializedViewStatementContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *RefreshMaterializedViewStatementContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *RefreshMaterializedViewStatementContext) AllWITH() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserWITH) + return s.GetTokens(StarRocksSQLParserWITH) } func (s *RefreshMaterializedViewStatementContext) WITH(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, i) + return s.GetToken(StarRocksSQLParserWITH, i) } func (s *RefreshMaterializedViewStatementContext) MODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODE, 0) + return s.GetToken(StarRocksSQLParserMODE, 0) } func (s *RefreshMaterializedViewStatementContext) PRIORITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIORITY, 0) + return s.GetToken(StarRocksSQLParserPRIORITY, 0) } func (s *RefreshMaterializedViewStatementContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *RefreshMaterializedViewStatementContext) ASYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASYNC, 0) + return s.GetToken(StarRocksSQLParserASYNC, 0) } func (s *RefreshMaterializedViewStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *RefreshMaterializedViewStatementContext) PartitionRangeDesc() IPartitionRangeDescContext { @@ -30447,20 +30447,20 @@ func (s *RefreshMaterializedViewStatementContext) ToStringTree(ruleNames []strin } func (s *RefreshMaterializedViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRefreshMaterializedViewStatement(s) } } func (s *RefreshMaterializedViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRefreshMaterializedViewStatement(s) } } func (s *RefreshMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRefreshMaterializedViewStatement(s) default: @@ -30468,15 +30468,15 @@ func (s *RefreshMaterializedViewStatementContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMaterializedViewStatementContext) { +func (p *StarRocksSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMaterializedViewStatementContext) { localctx = NewRefreshMaterializedViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 144, DorisSQLParserRULE_refreshMaterializedViewStatement) + p.EnterRule(localctx, 144, StarRocksSQLParserRULE_refreshMaterializedViewStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2350) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30484,7 +30484,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } { p.SetState(2351) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30492,7 +30492,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } { p.SetState(2352) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30512,10 +30512,10 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(2354) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30528,13 +30528,13 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } switch p.GetTokenStream().LA(1) { - case DorisSQLParserSTART: + case StarRocksSQLParserSTART: { p.SetState(2355) p.PartitionRangeDesc() } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(2356) p.ListPartitionValues() @@ -30553,10 +30553,10 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(2361) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30570,7 +30570,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 158, p.GetParserRuleContext()) == 1 { { p.SetState(2364) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30580,7 +30580,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa p.SetState(2365) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserASYNC || _la == DorisSQLParserSYNC) { + if !(_la == StarRocksSQLParserASYNC || _la == StarRocksSQLParserSYNC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -30589,7 +30589,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } { p.SetState(2366) - p.Match(DorisSQLParserMODE) + p.Match(StarRocksSQLParserMODE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30606,10 +30606,10 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(2369) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30617,7 +30617,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa } { p.SetState(2370) - p.Match(DorisSQLParserPRIORITY) + p.Match(StarRocksSQLParserPRIORITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30626,7 +30626,7 @@ func (p *DorisSQLParser) RefreshMaterializedViewStatement() (localctx IRefreshMa { p.SetState(2371) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*RefreshMaterializedViewStatementContext).priority = _m if p.HasError() { @@ -30684,13 +30684,13 @@ type CancelRefreshMaterializedViewStatementContext struct { func NewEmptyCancelRefreshMaterializedViewStatementContext() *CancelRefreshMaterializedViewStatementContext { var p = new(CancelRefreshMaterializedViewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelRefreshMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRefreshMaterializedViewStatement return p } func InitEmptyCancelRefreshMaterializedViewStatementContext(p *CancelRefreshMaterializedViewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelRefreshMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRefreshMaterializedViewStatement } func (*CancelRefreshMaterializedViewStatementContext) IsCancelRefreshMaterializedViewStatementContext() { @@ -30702,7 +30702,7 @@ func NewCancelRefreshMaterializedViewStatementContext(parser antlr.Parser, paren antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelRefreshMaterializedViewStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRefreshMaterializedViewStatement return p } @@ -30718,19 +30718,19 @@ func (s *CancelRefreshMaterializedViewStatementContext) SetMvName(v IQualifiedNa } func (s *CancelRefreshMaterializedViewStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelRefreshMaterializedViewStatementContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *CancelRefreshMaterializedViewStatementContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *CancelRefreshMaterializedViewStatementContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *CancelRefreshMaterializedViewStatementContext) QualifiedName() IQualifiedNameContext { @@ -30750,7 +30750,7 @@ func (s *CancelRefreshMaterializedViewStatementContext) QualifiedName() IQualifi } func (s *CancelRefreshMaterializedViewStatementContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *CancelRefreshMaterializedViewStatementContext) GetRuleContext() antlr.RuleContext { @@ -30762,20 +30762,20 @@ func (s *CancelRefreshMaterializedViewStatementContext) ToStringTree(ruleNames [ } func (s *CancelRefreshMaterializedViewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelRefreshMaterializedViewStatement(s) } } func (s *CancelRefreshMaterializedViewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelRefreshMaterializedViewStatement(s) } } func (s *CancelRefreshMaterializedViewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelRefreshMaterializedViewStatement(s) default: @@ -30783,15 +30783,15 @@ func (s *CancelRefreshMaterializedViewStatementContext) Accept(visitor antlr.Par } } -func (p *DorisSQLParser) CancelRefreshMaterializedViewStatement() (localctx ICancelRefreshMaterializedViewStatementContext) { +func (p *StarRocksSQLParser) CancelRefreshMaterializedViewStatement() (localctx ICancelRefreshMaterializedViewStatementContext) { localctx = NewCancelRefreshMaterializedViewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 146, DorisSQLParserRULE_cancelRefreshMaterializedViewStatement) + p.EnterRule(localctx, 146, StarRocksSQLParserRULE_cancelRefreshMaterializedViewStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2374) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30799,7 +30799,7 @@ func (p *DorisSQLParser) CancelRefreshMaterializedViewStatement() (localctx ICan } { p.SetState(2375) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30807,7 +30807,7 @@ func (p *DorisSQLParser) CancelRefreshMaterializedViewStatement() (localctx ICan } { p.SetState(2376) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30815,7 +30815,7 @@ func (p *DorisSQLParser) CancelRefreshMaterializedViewStatement() (localctx ICan } { p.SetState(2377) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30835,10 +30835,10 @@ func (p *DorisSQLParser) CancelRefreshMaterializedViewStatement() (localctx ICan } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(2379) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30888,13 +30888,13 @@ type AdminSetConfigStatementContext struct { func NewEmptyAdminSetConfigStatementContext() *AdminSetConfigStatementContext { var p = new(AdminSetConfigStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetConfigStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetConfigStatement return p } func InitEmptyAdminSetConfigStatementContext(p *AdminSetConfigStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetConfigStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetConfigStatement } func (*AdminSetConfigStatementContext) IsAdminSetConfigStatementContext() {} @@ -30905,7 +30905,7 @@ func NewAdminSetConfigStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminSetConfigStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetConfigStatement return p } @@ -30913,19 +30913,19 @@ func NewAdminSetConfigStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *AdminSetConfigStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminSetConfigStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminSetConfigStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AdminSetConfigStatementContext) FRONTEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTEND, 0) + return s.GetToken(StarRocksSQLParserFRONTEND, 0) } func (s *AdminSetConfigStatementContext) CONFIG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONFIG, 0) + return s.GetToken(StarRocksSQLParserCONFIG, 0) } func (s *AdminSetConfigStatementContext) Property() IPropertyContext { @@ -30945,11 +30945,11 @@ func (s *AdminSetConfigStatementContext) Property() IPropertyContext { } func (s *AdminSetConfigStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *AdminSetConfigStatementContext) PERSISTENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERSISTENT, 0) + return s.GetToken(StarRocksSQLParserPERSISTENT, 0) } func (s *AdminSetConfigStatementContext) GetRuleContext() antlr.RuleContext { @@ -30961,20 +30961,20 @@ func (s *AdminSetConfigStatementContext) ToStringTree(ruleNames []string, recog } func (s *AdminSetConfigStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminSetConfigStatement(s) } } func (s *AdminSetConfigStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminSetConfigStatement(s) } } func (s *AdminSetConfigStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminSetConfigStatement(s) default: @@ -30982,15 +30982,15 @@ func (s *AdminSetConfigStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStatementContext) { +func (p *StarRocksSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStatementContext) { localctx = NewAdminSetConfigStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 148, DorisSQLParserRULE_adminSetConfigStatement) + p.EnterRule(localctx, 148, StarRocksSQLParserRULE_adminSetConfigStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2382) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -30998,7 +30998,7 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } { p.SetState(2383) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31006,7 +31006,7 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } { p.SetState(2384) - p.Match(DorisSQLParserFRONTEND) + p.Match(StarRocksSQLParserFRONTEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31014,7 +31014,7 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } { p.SetState(2385) - p.Match(DorisSQLParserCONFIG) + p.Match(StarRocksSQLParserCONFIG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31022,7 +31022,7 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } { p.SetState(2386) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31034,7 +31034,7 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } { p.SetState(2388) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31047,10 +31047,10 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(2389) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31058,7 +31058,7 @@ func (p *DorisSQLParser) AdminSetConfigStatement() (localctx IAdminSetConfigStat } { p.SetState(2390) - p.Match(DorisSQLParserPERSISTENT) + p.Match(StarRocksSQLParserPERSISTENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31106,13 +31106,13 @@ type AdminSetReplicaStatusStatementContext struct { func NewEmptyAdminSetReplicaStatusStatementContext() *AdminSetReplicaStatusStatementContext { var p = new(AdminSetReplicaStatusStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetReplicaStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetReplicaStatusStatement return p } func InitEmptyAdminSetReplicaStatusStatementContext(p *AdminSetReplicaStatusStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetReplicaStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetReplicaStatusStatement } func (*AdminSetReplicaStatusStatementContext) IsAdminSetReplicaStatusStatementContext() {} @@ -31123,7 +31123,7 @@ func NewAdminSetReplicaStatusStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminSetReplicaStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetReplicaStatusStatement return p } @@ -31131,19 +31131,19 @@ func NewAdminSetReplicaStatusStatementContext(parser antlr.Parser, parent antlr. func (s *AdminSetReplicaStatusStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminSetReplicaStatusStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminSetReplicaStatusStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AdminSetReplicaStatusStatementContext) REPLICA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLICA, 0) + return s.GetToken(StarRocksSQLParserREPLICA, 0) } func (s *AdminSetReplicaStatusStatementContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *AdminSetReplicaStatusStatementContext) Properties() IPropertiesContext { @@ -31171,20 +31171,20 @@ func (s *AdminSetReplicaStatusStatementContext) ToStringTree(ruleNames []string, } func (s *AdminSetReplicaStatusStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminSetReplicaStatusStatement(s) } } func (s *AdminSetReplicaStatusStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminSetReplicaStatusStatement(s) } } func (s *AdminSetReplicaStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminSetReplicaStatusStatement(s) default: @@ -31192,13 +31192,13 @@ func (s *AdminSetReplicaStatusStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) AdminSetReplicaStatusStatement() (localctx IAdminSetReplicaStatusStatementContext) { +func (p *StarRocksSQLParser) AdminSetReplicaStatusStatement() (localctx IAdminSetReplicaStatusStatementContext) { localctx = NewAdminSetReplicaStatusStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 150, DorisSQLParserRULE_adminSetReplicaStatusStatement) + p.EnterRule(localctx, 150, StarRocksSQLParserRULE_adminSetReplicaStatusStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2393) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31206,7 +31206,7 @@ func (p *DorisSQLParser) AdminSetReplicaStatusStatement() (localctx IAdminSetRep } { p.SetState(2394) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31214,7 +31214,7 @@ func (p *DorisSQLParser) AdminSetReplicaStatusStatement() (localctx IAdminSetRep } { p.SetState(2395) - p.Match(DorisSQLParserREPLICA) + p.Match(StarRocksSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31222,7 +31222,7 @@ func (p *DorisSQLParser) AdminSetReplicaStatusStatement() (localctx IAdminSetRep } { p.SetState(2396) - p.Match(DorisSQLParserSTATUS) + p.Match(StarRocksSQLParserSTATUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31280,13 +31280,13 @@ type AdminShowConfigStatementContext struct { func NewEmptyAdminShowConfigStatementContext() *AdminShowConfigStatementContext { var p = new(AdminShowConfigStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminShowConfigStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowConfigStatement return p } func InitEmptyAdminShowConfigStatementContext(p *AdminShowConfigStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminShowConfigStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowConfigStatement } func (*AdminShowConfigStatementContext) IsAdminShowConfigStatementContext() {} @@ -31297,7 +31297,7 @@ func NewAdminShowConfigStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminShowConfigStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowConfigStatement return p } @@ -31309,23 +31309,23 @@ func (s *AdminShowConfigStatementContext) GetPattern() IStringContext { return s func (s *AdminShowConfigStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *AdminShowConfigStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminShowConfigStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *AdminShowConfigStatementContext) FRONTEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTEND, 0) + return s.GetToken(StarRocksSQLParserFRONTEND, 0) } func (s *AdminShowConfigStatementContext) CONFIG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONFIG, 0) + return s.GetToken(StarRocksSQLParserCONFIG, 0) } func (s *AdminShowConfigStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *AdminShowConfigStatementContext) String_() IStringContext { @@ -31353,20 +31353,20 @@ func (s *AdminShowConfigStatementContext) ToStringTree(ruleNames []string, recog } func (s *AdminShowConfigStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminShowConfigStatement(s) } } func (s *AdminShowConfigStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminShowConfigStatement(s) } } func (s *AdminShowConfigStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminShowConfigStatement(s) default: @@ -31374,15 +31374,15 @@ func (s *AdminShowConfigStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AdminShowConfigStatement() (localctx IAdminShowConfigStatementContext) { +func (p *StarRocksSQLParser) AdminShowConfigStatement() (localctx IAdminShowConfigStatementContext) { localctx = NewAdminShowConfigStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 152, DorisSQLParserRULE_adminShowConfigStatement) + p.EnterRule(localctx, 152, StarRocksSQLParserRULE_adminShowConfigStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2399) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31390,7 +31390,7 @@ func (p *DorisSQLParser) AdminShowConfigStatement() (localctx IAdminShowConfigSt } { p.SetState(2400) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31398,7 +31398,7 @@ func (p *DorisSQLParser) AdminShowConfigStatement() (localctx IAdminShowConfigSt } { p.SetState(2401) - p.Match(DorisSQLParserFRONTEND) + p.Match(StarRocksSQLParserFRONTEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31406,7 +31406,7 @@ func (p *DorisSQLParser) AdminShowConfigStatement() (localctx IAdminShowConfigSt } { p.SetState(2402) - p.Match(DorisSQLParserCONFIG) + p.Match(StarRocksSQLParserCONFIG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31419,10 +31419,10 @@ func (p *DorisSQLParser) AdminShowConfigStatement() (localctx IAdminShowConfigSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(2403) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31479,13 +31479,13 @@ type AdminShowReplicaDistributionStatementContext struct { func NewEmptyAdminShowReplicaDistributionStatementContext() *AdminShowReplicaDistributionStatementContext { var p = new(AdminShowReplicaDistributionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminShowReplicaDistributionStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowReplicaDistributionStatement return p } func InitEmptyAdminShowReplicaDistributionStatementContext(p *AdminShowReplicaDistributionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminShowReplicaDistributionStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowReplicaDistributionStatement } func (*AdminShowReplicaDistributionStatementContext) IsAdminShowReplicaDistributionStatementContext() { @@ -31497,7 +31497,7 @@ func NewAdminShowReplicaDistributionStatementContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminShowReplicaDistributionStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowReplicaDistributionStatement return p } @@ -31505,23 +31505,23 @@ func NewAdminShowReplicaDistributionStatementContext(parser antlr.Parser, parent func (s *AdminShowReplicaDistributionStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminShowReplicaDistributionStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminShowReplicaDistributionStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *AdminShowReplicaDistributionStatementContext) REPLICA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLICA, 0) + return s.GetToken(StarRocksSQLParserREPLICA, 0) } func (s *AdminShowReplicaDistributionStatementContext) DISTRIBUTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTRIBUTION, 0) + return s.GetToken(StarRocksSQLParserDISTRIBUTION, 0) } func (s *AdminShowReplicaDistributionStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *AdminShowReplicaDistributionStatementContext) QualifiedName() IQualifiedNameContext { @@ -31565,20 +31565,20 @@ func (s *AdminShowReplicaDistributionStatementContext) ToStringTree(ruleNames [] } func (s *AdminShowReplicaDistributionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminShowReplicaDistributionStatement(s) } } func (s *AdminShowReplicaDistributionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminShowReplicaDistributionStatement(s) } } func (s *AdminShowReplicaDistributionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminShowReplicaDistributionStatement(s) default: @@ -31586,15 +31586,15 @@ func (s *AdminShowReplicaDistributionStatementContext) Accept(visitor antlr.Pars } } -func (p *DorisSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdminShowReplicaDistributionStatementContext) { +func (p *StarRocksSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdminShowReplicaDistributionStatementContext) { localctx = NewAdminShowReplicaDistributionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 154, DorisSQLParserRULE_adminShowReplicaDistributionStatement) + p.EnterRule(localctx, 154, StarRocksSQLParserRULE_adminShowReplicaDistributionStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2407) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31602,7 +31602,7 @@ func (p *DorisSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdmi } { p.SetState(2408) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31610,7 +31610,7 @@ func (p *DorisSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdmi } { p.SetState(2409) - p.Match(DorisSQLParserREPLICA) + p.Match(StarRocksSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31618,7 +31618,7 @@ func (p *DorisSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdmi } { p.SetState(2410) - p.Match(DorisSQLParserDISTRIBUTION) + p.Match(StarRocksSQLParserDISTRIBUTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31626,7 +31626,7 @@ func (p *DorisSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdmi } { p.SetState(2411) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31643,7 +31643,7 @@ func (p *DorisSQLParser) AdminShowReplicaDistributionStatement() (localctx IAdmi } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(2413) p.PartitionNames() @@ -31701,13 +31701,13 @@ type AdminShowReplicaStatusStatementContext struct { func NewEmptyAdminShowReplicaStatusStatementContext() *AdminShowReplicaStatusStatementContext { var p = new(AdminShowReplicaStatusStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminShowReplicaStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowReplicaStatusStatement return p } func InitEmptyAdminShowReplicaStatusStatementContext(p *AdminShowReplicaStatusStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminShowReplicaStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowReplicaStatusStatement } func (*AdminShowReplicaStatusStatementContext) IsAdminShowReplicaStatusStatementContext() {} @@ -31718,7 +31718,7 @@ func NewAdminShowReplicaStatusStatementContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminShowReplicaStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_adminShowReplicaStatusStatement return p } @@ -31730,23 +31730,23 @@ func (s *AdminShowReplicaStatusStatementContext) GetWhere() IExpressionContext { func (s *AdminShowReplicaStatusStatementContext) SetWhere(v IExpressionContext) { s.where = v } func (s *AdminShowReplicaStatusStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminShowReplicaStatusStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *AdminShowReplicaStatusStatementContext) REPLICA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLICA, 0) + return s.GetToken(StarRocksSQLParserREPLICA, 0) } func (s *AdminShowReplicaStatusStatementContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *AdminShowReplicaStatusStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *AdminShowReplicaStatusStatementContext) QualifiedName() IQualifiedNameContext { @@ -31782,7 +31782,7 @@ func (s *AdminShowReplicaStatusStatementContext) PartitionNames() IPartitionName } func (s *AdminShowReplicaStatusStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *AdminShowReplicaStatusStatementContext) Expression() IExpressionContext { @@ -31810,20 +31810,20 @@ func (s *AdminShowReplicaStatusStatementContext) ToStringTree(ruleNames []string } func (s *AdminShowReplicaStatusStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminShowReplicaStatusStatement(s) } } func (s *AdminShowReplicaStatusStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminShowReplicaStatusStatement(s) } } func (s *AdminShowReplicaStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminShowReplicaStatusStatement(s) default: @@ -31831,15 +31831,15 @@ func (s *AdminShowReplicaStatusStatementContext) Accept(visitor antlr.ParseTreeV } } -func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowReplicaStatusStatementContext) { +func (p *StarRocksSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowReplicaStatusStatementContext) { localctx = NewAdminShowReplicaStatusStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 156, DorisSQLParserRULE_adminShowReplicaStatusStatement) + p.EnterRule(localctx, 156, StarRocksSQLParserRULE_adminShowReplicaStatusStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2416) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31847,7 +31847,7 @@ func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowR } { p.SetState(2417) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31855,7 +31855,7 @@ func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowR } { p.SetState(2418) - p.Match(DorisSQLParserREPLICA) + p.Match(StarRocksSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31863,7 +31863,7 @@ func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowR } { p.SetState(2419) - p.Match(DorisSQLParserSTATUS) + p.Match(StarRocksSQLParserSTATUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31871,7 +31871,7 @@ func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowR } { p.SetState(2420) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31888,7 +31888,7 @@ func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowR } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(2422) p.PartitionNames() @@ -31902,10 +31902,10 @@ func (p *DorisSQLParser) AdminShowReplicaStatusStatement() (localctx IAdminShowR } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(2425) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -31960,13 +31960,13 @@ type AdminRepairTableStatementContext struct { func NewEmptyAdminRepairTableStatementContext() *AdminRepairTableStatementContext { var p = new(AdminRepairTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminRepairTableStatement + p.RuleIndex = StarRocksSQLParserRULE_adminRepairTableStatement return p } func InitEmptyAdminRepairTableStatementContext(p *AdminRepairTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminRepairTableStatement + p.RuleIndex = StarRocksSQLParserRULE_adminRepairTableStatement } func (*AdminRepairTableStatementContext) IsAdminRepairTableStatementContext() {} @@ -31977,7 +31977,7 @@ func NewAdminRepairTableStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminRepairTableStatement + p.RuleIndex = StarRocksSQLParserRULE_adminRepairTableStatement return p } @@ -31985,15 +31985,15 @@ func NewAdminRepairTableStatementContext(parser antlr.Parser, parent antlr.Parse func (s *AdminRepairTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminRepairTableStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminRepairTableStatementContext) REPAIR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPAIR, 0) + return s.GetToken(StarRocksSQLParserREPAIR, 0) } func (s *AdminRepairTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *AdminRepairTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -32037,20 +32037,20 @@ func (s *AdminRepairTableStatementContext) ToStringTree(ruleNames []string, reco } func (s *AdminRepairTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminRepairTableStatement(s) } } func (s *AdminRepairTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminRepairTableStatement(s) } } func (s *AdminRepairTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminRepairTableStatement(s) default: @@ -32058,15 +32058,15 @@ func (s *AdminRepairTableStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) AdminRepairTableStatement() (localctx IAdminRepairTableStatementContext) { +func (p *StarRocksSQLParser) AdminRepairTableStatement() (localctx IAdminRepairTableStatementContext) { localctx = NewAdminRepairTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 158, DorisSQLParserRULE_adminRepairTableStatement) + p.EnterRule(localctx, 158, StarRocksSQLParserRULE_adminRepairTableStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2429) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32074,7 +32074,7 @@ func (p *DorisSQLParser) AdminRepairTableStatement() (localctx IAdminRepairTable } { p.SetState(2430) - p.Match(DorisSQLParserREPAIR) + p.Match(StarRocksSQLParserREPAIR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32082,7 +32082,7 @@ func (p *DorisSQLParser) AdminRepairTableStatement() (localctx IAdminRepairTable } { p.SetState(2431) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32099,7 +32099,7 @@ func (p *DorisSQLParser) AdminRepairTableStatement() (localctx IAdminRepairTable } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(2433) p.PartitionNames() @@ -32147,13 +32147,13 @@ type AdminCancelRepairTableStatementContext struct { func NewEmptyAdminCancelRepairTableStatementContext() *AdminCancelRepairTableStatementContext { var p = new(AdminCancelRepairTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminCancelRepairTableStatement + p.RuleIndex = StarRocksSQLParserRULE_adminCancelRepairTableStatement return p } func InitEmptyAdminCancelRepairTableStatementContext(p *AdminCancelRepairTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminCancelRepairTableStatement + p.RuleIndex = StarRocksSQLParserRULE_adminCancelRepairTableStatement } func (*AdminCancelRepairTableStatementContext) IsAdminCancelRepairTableStatementContext() {} @@ -32164,7 +32164,7 @@ func NewAdminCancelRepairTableStatementContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminCancelRepairTableStatement + p.RuleIndex = StarRocksSQLParserRULE_adminCancelRepairTableStatement return p } @@ -32172,19 +32172,19 @@ func NewAdminCancelRepairTableStatementContext(parser antlr.Parser, parent antlr func (s *AdminCancelRepairTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminCancelRepairTableStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminCancelRepairTableStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *AdminCancelRepairTableStatementContext) REPAIR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPAIR, 0) + return s.GetToken(StarRocksSQLParserREPAIR, 0) } func (s *AdminCancelRepairTableStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *AdminCancelRepairTableStatementContext) QualifiedName() IQualifiedNameContext { @@ -32228,20 +32228,20 @@ func (s *AdminCancelRepairTableStatementContext) ToStringTree(ruleNames []string } func (s *AdminCancelRepairTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminCancelRepairTableStatement(s) } } func (s *AdminCancelRepairTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminCancelRepairTableStatement(s) } } func (s *AdminCancelRepairTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminCancelRepairTableStatement(s) default: @@ -32249,15 +32249,15 @@ func (s *AdminCancelRepairTableStatementContext) Accept(visitor antlr.ParseTreeV } } -func (p *DorisSQLParser) AdminCancelRepairTableStatement() (localctx IAdminCancelRepairTableStatementContext) { +func (p *StarRocksSQLParser) AdminCancelRepairTableStatement() (localctx IAdminCancelRepairTableStatementContext) { localctx = NewAdminCancelRepairTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 160, DorisSQLParserRULE_adminCancelRepairTableStatement) + p.EnterRule(localctx, 160, StarRocksSQLParserRULE_adminCancelRepairTableStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2436) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32265,7 +32265,7 @@ func (p *DorisSQLParser) AdminCancelRepairTableStatement() (localctx IAdminCance } { p.SetState(2437) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32273,7 +32273,7 @@ func (p *DorisSQLParser) AdminCancelRepairTableStatement() (localctx IAdminCance } { p.SetState(2438) - p.Match(DorisSQLParserREPAIR) + p.Match(StarRocksSQLParserREPAIR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32281,7 +32281,7 @@ func (p *DorisSQLParser) AdminCancelRepairTableStatement() (localctx IAdminCance } { p.SetState(2439) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32298,7 +32298,7 @@ func (p *DorisSQLParser) AdminCancelRepairTableStatement() (localctx IAdminCance } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(2441) p.PartitionNames() @@ -32345,13 +32345,13 @@ type AdminCheckTabletsStatementContext struct { func NewEmptyAdminCheckTabletsStatementContext() *AdminCheckTabletsStatementContext { var p = new(AdminCheckTabletsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminCheckTabletsStatement + p.RuleIndex = StarRocksSQLParserRULE_adminCheckTabletsStatement return p } func InitEmptyAdminCheckTabletsStatementContext(p *AdminCheckTabletsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminCheckTabletsStatement + p.RuleIndex = StarRocksSQLParserRULE_adminCheckTabletsStatement } func (*AdminCheckTabletsStatementContext) IsAdminCheckTabletsStatementContext() {} @@ -32362,7 +32362,7 @@ func NewAdminCheckTabletsStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminCheckTabletsStatement + p.RuleIndex = StarRocksSQLParserRULE_adminCheckTabletsStatement return p } @@ -32370,11 +32370,11 @@ func NewAdminCheckTabletsStatementContext(parser antlr.Parser, parent antlr.Pars func (s *AdminCheckTabletsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminCheckTabletsStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminCheckTabletsStatementContext) CHECK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHECK, 0) + return s.GetToken(StarRocksSQLParserCHECK, 0) } func (s *AdminCheckTabletsStatementContext) TabletList() ITabletListContext { @@ -32394,7 +32394,7 @@ func (s *AdminCheckTabletsStatementContext) TabletList() ITabletListContext { } func (s *AdminCheckTabletsStatementContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *AdminCheckTabletsStatementContext) Property() IPropertyContext { @@ -32422,20 +32422,20 @@ func (s *AdminCheckTabletsStatementContext) ToStringTree(ruleNames []string, rec } func (s *AdminCheckTabletsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminCheckTabletsStatement(s) } } func (s *AdminCheckTabletsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminCheckTabletsStatement(s) } } func (s *AdminCheckTabletsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminCheckTabletsStatement(s) default: @@ -32443,13 +32443,13 @@ func (s *AdminCheckTabletsStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) AdminCheckTabletsStatement() (localctx IAdminCheckTabletsStatementContext) { +func (p *StarRocksSQLParser) AdminCheckTabletsStatement() (localctx IAdminCheckTabletsStatementContext) { localctx = NewAdminCheckTabletsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 162, DorisSQLParserRULE_adminCheckTabletsStatement) + p.EnterRule(localctx, 162, StarRocksSQLParserRULE_adminCheckTabletsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2444) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32457,7 +32457,7 @@ func (p *DorisSQLParser) AdminCheckTabletsStatement() (localctx IAdminCheckTable } { p.SetState(2445) - p.Match(DorisSQLParserCHECK) + p.Match(StarRocksSQLParserCHECK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32469,7 +32469,7 @@ func (p *DorisSQLParser) AdminCheckTabletsStatement() (localctx IAdminCheckTable } { p.SetState(2447) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32477,7 +32477,7 @@ func (p *DorisSQLParser) AdminCheckTabletsStatement() (localctx IAdminCheckTable } { p.SetState(2448) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32489,7 +32489,7 @@ func (p *DorisSQLParser) AdminCheckTabletsStatement() (localctx IAdminCheckTable } { p.SetState(2450) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32561,13 +32561,13 @@ type AdminSetPartitionVersionContext struct { func NewEmptyAdminSetPartitionVersionContext() *AdminSetPartitionVersionContext { var p = new(AdminSetPartitionVersionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetPartitionVersion + p.RuleIndex = StarRocksSQLParserRULE_adminSetPartitionVersion return p } func InitEmptyAdminSetPartitionVersionContext(p *AdminSetPartitionVersionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetPartitionVersion + p.RuleIndex = StarRocksSQLParserRULE_adminSetPartitionVersion } func (*AdminSetPartitionVersionContext) IsAdminSetPartitionVersionContext() {} @@ -32578,7 +32578,7 @@ func NewAdminSetPartitionVersionContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminSetPartitionVersion + p.RuleIndex = StarRocksSQLParserRULE_adminSetPartitionVersion return p } @@ -32602,15 +32602,15 @@ func (s *AdminSetPartitionVersionContext) SetPartitionName(v IIdentifierOrString } func (s *AdminSetPartitionVersionContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminSetPartitionVersionContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AdminSetPartitionVersionContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *AdminSetPartitionVersionContext) QualifiedName() IQualifiedNameContext { @@ -32630,23 +32630,23 @@ func (s *AdminSetPartitionVersionContext) QualifiedName() IQualifiedNameContext } func (s *AdminSetPartitionVersionContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *AdminSetPartitionVersionContext) VERSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERSION, 0) + return s.GetToken(StarRocksSQLParserVERSION, 0) } func (s *AdminSetPartitionVersionContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *AdminSetPartitionVersionContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *AdminSetPartitionVersionContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *AdminSetPartitionVersionContext) IdentifierOrString() IIdentifierOrStringContext { @@ -32674,20 +32674,20 @@ func (s *AdminSetPartitionVersionContext) ToStringTree(ruleNames []string, recog } func (s *AdminSetPartitionVersionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminSetPartitionVersion(s) } } func (s *AdminSetPartitionVersionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminSetPartitionVersion(s) } } func (s *AdminSetPartitionVersionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminSetPartitionVersion(s) default: @@ -32695,13 +32695,13 @@ func (s *AdminSetPartitionVersionContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartitionVersionContext) { +func (p *StarRocksSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartitionVersionContext) { localctx = NewAdminSetPartitionVersionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 164, DorisSQLParserRULE_adminSetPartitionVersion) + p.EnterRule(localctx, 164, StarRocksSQLParserRULE_adminSetPartitionVersion) p.EnterOuterAlt(localctx, 1) { p.SetState(2452) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32709,7 +32709,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2453) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32717,7 +32717,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2454) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32729,7 +32729,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2456) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32737,7 +32737,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2457) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32750,7 +32750,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(2458) @@ -32759,11 +32759,11 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition localctx.(*AdminSetPartitionVersionContext).partitionName = _x } - case DorisSQLParserINTEGER_VALUE: + case StarRocksSQLParserINTEGER_VALUE: { p.SetState(2459) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*AdminSetPartitionVersionContext).partitionId = _m if p.HasError() { @@ -32778,7 +32778,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2462) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32786,7 +32786,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2463) - p.Match(DorisSQLParserVERSION) + p.Match(StarRocksSQLParserVERSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32794,7 +32794,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition } { p.SetState(2464) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32803,7 +32803,7 @@ func (p *DorisSQLParser) AdminSetPartitionVersion() (localctx IAdminSetPartition { p.SetState(2465) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*AdminSetPartitionVersionContext).version = _m if p.HasError() { @@ -32865,13 +32865,13 @@ type KillStatementContext struct { func NewEmptyKillStatementContext() *KillStatementContext { var p = new(KillStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_killStatement + p.RuleIndex = StarRocksSQLParserRULE_killStatement return p } func InitEmptyKillStatementContext(p *KillStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_killStatement + p.RuleIndex = StarRocksSQLParserRULE_killStatement } func (*KillStatementContext) IsKillStatementContext() {} @@ -32882,7 +32882,7 @@ func NewKillStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_killStatement + p.RuleIndex = StarRocksSQLParserRULE_killStatement return p } @@ -32898,15 +32898,15 @@ func (s *KillStatementContext) GetQueryId() IStringContext { return s.queryId } func (s *KillStatementContext) SetQueryId(v IStringContext) { s.queryId = v } func (s *KillStatementContext) KILL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKILL, 0) + return s.GetToken(StarRocksSQLParserKILL, 0) } func (s *KillStatementContext) QUERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUERY, 0) + return s.GetToken(StarRocksSQLParserQUERY, 0) } func (s *KillStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *KillStatementContext) String_() IStringContext { @@ -32926,7 +32926,7 @@ func (s *KillStatementContext) String_() IStringContext { } func (s *KillStatementContext) CONNECTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONNECTION, 0) + return s.GetToken(StarRocksSQLParserCONNECTION, 0) } func (s *KillStatementContext) GetRuleContext() antlr.RuleContext { @@ -32938,20 +32938,20 @@ func (s *KillStatementContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *KillStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterKillStatement(s) } } func (s *KillStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitKillStatement(s) } } func (s *KillStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitKillStatement(s) default: @@ -32959,15 +32959,15 @@ func (s *KillStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) KillStatement() (localctx IKillStatementContext) { +func (p *StarRocksSQLParser) KillStatement() (localctx IKillStatementContext) { localctx = NewKillStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 166, DorisSQLParserRULE_killStatement) + p.EnterRule(localctx, 166, StarRocksSQLParserRULE_killStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2467) - p.Match(DorisSQLParserKILL) + p.Match(StarRocksSQLParserKILL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -32980,7 +32980,7 @@ func (p *DorisSQLParser) KillStatement() (localctx IKillStatementContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCONNECTION, DorisSQLParserINTEGER_VALUE, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserCONNECTION, StarRocksSQLParserINTEGER_VALUE, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: p.SetState(2469) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -32988,10 +32988,10 @@ func (p *DorisSQLParser) KillStatement() (localctx IKillStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCONNECTION { + if _la == StarRocksSQLParserCONNECTION { { p.SetState(2468) - p.Match(DorisSQLParserCONNECTION) + p.Match(StarRocksSQLParserCONNECTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33000,10 +33000,10 @@ func (p *DorisSQLParser) KillStatement() (localctx IKillStatementContext) { } - case DorisSQLParserQUERY: + case StarRocksSQLParserQUERY: { p.SetState(2471) - p.Match(DorisSQLParserQUERY) + p.Match(StarRocksSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33021,11 +33021,11 @@ func (p *DorisSQLParser) KillStatement() (localctx IKillStatementContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserINTEGER_VALUE: + case StarRocksSQLParserINTEGER_VALUE: { p.SetState(2474) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*KillStatementContext).connId = _m if p.HasError() { @@ -33034,7 +33034,7 @@ func (p *DorisSQLParser) KillStatement() (localctx IKillStatementContext) { } } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(2475) @@ -33083,13 +33083,13 @@ type SyncStatementContext struct { func NewEmptySyncStatementContext() *SyncStatementContext { var p = new(SyncStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_syncStatement + p.RuleIndex = StarRocksSQLParserRULE_syncStatement return p } func InitEmptySyncStatementContext(p *SyncStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_syncStatement + p.RuleIndex = StarRocksSQLParserRULE_syncStatement } func (*SyncStatementContext) IsSyncStatementContext() {} @@ -33100,7 +33100,7 @@ func NewSyncStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_syncStatement + p.RuleIndex = StarRocksSQLParserRULE_syncStatement return p } @@ -33108,7 +33108,7 @@ func NewSyncStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *SyncStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SyncStatementContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *SyncStatementContext) GetRuleContext() antlr.RuleContext { @@ -33120,20 +33120,20 @@ func (s *SyncStatementContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *SyncStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSyncStatement(s) } } func (s *SyncStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSyncStatement(s) } } func (s *SyncStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSyncStatement(s) default: @@ -33141,13 +33141,13 @@ func (s *SyncStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) SyncStatement() (localctx ISyncStatementContext) { +func (p *StarRocksSQLParser) SyncStatement() (localctx ISyncStatementContext) { localctx = NewSyncStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 168, DorisSQLParserRULE_syncStatement) + p.EnterRule(localctx, 168, StarRocksSQLParserRULE_syncStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2478) - p.Match(DorisSQLParserSYNC) + p.Match(StarRocksSQLParserSYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33204,13 +33204,13 @@ type AdminSetAutomatedSnapshotOnStatementContext struct { func NewEmptyAdminSetAutomatedSnapshotOnStatementContext() *AdminSetAutomatedSnapshotOnStatementContext { var p = new(AdminSetAutomatedSnapshotOnStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetAutomatedSnapshotOnStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetAutomatedSnapshotOnStatement return p } func InitEmptyAdminSetAutomatedSnapshotOnStatementContext(p *AdminSetAutomatedSnapshotOnStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetAutomatedSnapshotOnStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetAutomatedSnapshotOnStatement } func (*AdminSetAutomatedSnapshotOnStatementContext) IsAdminSetAutomatedSnapshotOnStatementContext() {} @@ -33221,7 +33221,7 @@ func NewAdminSetAutomatedSnapshotOnStatementContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminSetAutomatedSnapshotOnStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetAutomatedSnapshotOnStatement return p } @@ -33233,35 +33233,35 @@ func (s *AdminSetAutomatedSnapshotOnStatementContext) GetSvName() IIdentifierCon func (s *AdminSetAutomatedSnapshotOnStatementContext) SetSvName(v IIdentifierContext) { s.svName = v } func (s *AdminSetAutomatedSnapshotOnStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) AUTOMATED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTOMATED, 0) + return s.GetToken(StarRocksSQLParserAUTOMATED, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) CLUSTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLUSTER, 0) + return s.GetToken(StarRocksSQLParserCLUSTER, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *AdminSetAutomatedSnapshotOnStatementContext) Identifier() IIdentifierContext { @@ -33289,20 +33289,20 @@ func (s *AdminSetAutomatedSnapshotOnStatementContext) ToStringTree(ruleNames []s } func (s *AdminSetAutomatedSnapshotOnStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminSetAutomatedSnapshotOnStatement(s) } } func (s *AdminSetAutomatedSnapshotOnStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminSetAutomatedSnapshotOnStatement(s) } } func (s *AdminSetAutomatedSnapshotOnStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminSetAutomatedSnapshotOnStatement(s) default: @@ -33310,15 +33310,15 @@ func (s *AdminSetAutomatedSnapshotOnStatementContext) Accept(visitor antlr.Parse } } -func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdminSetAutomatedSnapshotOnStatementContext) { +func (p *StarRocksSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdminSetAutomatedSnapshotOnStatementContext) { localctx = NewAdminSetAutomatedSnapshotOnStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 170, DorisSQLParserRULE_adminSetAutomatedSnapshotOnStatement) + p.EnterRule(localctx, 170, StarRocksSQLParserRULE_adminSetAutomatedSnapshotOnStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2480) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33326,7 +33326,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } { p.SetState(2481) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33334,7 +33334,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } { p.SetState(2482) - p.Match(DorisSQLParserAUTOMATED) + p.Match(StarRocksSQLParserAUTOMATED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33342,7 +33342,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } { p.SetState(2483) - p.Match(DorisSQLParserCLUSTER) + p.Match(StarRocksSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33350,7 +33350,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } { p.SetState(2484) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33358,7 +33358,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } { p.SetState(2485) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33371,10 +33371,10 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSTORAGE { + if _la == StarRocksSQLParserSTORAGE { { p.SetState(2486) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33382,7 +33382,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOnStatement() (localctx IAdmin } { p.SetState(2487) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33438,13 +33438,13 @@ type AdminSetAutomatedSnapshotOffStatementContext struct { func NewEmptyAdminSetAutomatedSnapshotOffStatementContext() *AdminSetAutomatedSnapshotOffStatementContext { var p = new(AdminSetAutomatedSnapshotOffStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetAutomatedSnapshotOffStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetAutomatedSnapshotOffStatement return p } func InitEmptyAdminSetAutomatedSnapshotOffStatementContext(p *AdminSetAutomatedSnapshotOffStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_adminSetAutomatedSnapshotOffStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetAutomatedSnapshotOffStatement } func (*AdminSetAutomatedSnapshotOffStatementContext) IsAdminSetAutomatedSnapshotOffStatementContext() { @@ -33456,7 +33456,7 @@ func NewAdminSetAutomatedSnapshotOffStatementContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_adminSetAutomatedSnapshotOffStatement + p.RuleIndex = StarRocksSQLParserRULE_adminSetAutomatedSnapshotOffStatement return p } @@ -33464,27 +33464,27 @@ func NewAdminSetAutomatedSnapshotOffStatementContext(parser antlr.Parser, parent func (s *AdminSetAutomatedSnapshotOffStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AdminSetAutomatedSnapshotOffStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *AdminSetAutomatedSnapshotOffStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AdminSetAutomatedSnapshotOffStatementContext) AUTOMATED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTOMATED, 0) + return s.GetToken(StarRocksSQLParserAUTOMATED, 0) } func (s *AdminSetAutomatedSnapshotOffStatementContext) CLUSTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLUSTER, 0) + return s.GetToken(StarRocksSQLParserCLUSTER, 0) } func (s *AdminSetAutomatedSnapshotOffStatementContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *AdminSetAutomatedSnapshotOffStatementContext) OFF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOFF, 0) + return s.GetToken(StarRocksSQLParserOFF, 0) } func (s *AdminSetAutomatedSnapshotOffStatementContext) GetRuleContext() antlr.RuleContext { @@ -33496,20 +33496,20 @@ func (s *AdminSetAutomatedSnapshotOffStatementContext) ToStringTree(ruleNames [] } func (s *AdminSetAutomatedSnapshotOffStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAdminSetAutomatedSnapshotOffStatement(s) } } func (s *AdminSetAutomatedSnapshotOffStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAdminSetAutomatedSnapshotOffStatement(s) } } func (s *AdminSetAutomatedSnapshotOffStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAdminSetAutomatedSnapshotOffStatement(s) default: @@ -33517,13 +33517,13 @@ func (s *AdminSetAutomatedSnapshotOffStatementContext) Accept(visitor antlr.Pars } } -func (p *DorisSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdminSetAutomatedSnapshotOffStatementContext) { +func (p *StarRocksSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdminSetAutomatedSnapshotOffStatementContext) { localctx = NewAdminSetAutomatedSnapshotOffStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 172, DorisSQLParserRULE_adminSetAutomatedSnapshotOffStatement) + p.EnterRule(localctx, 172, StarRocksSQLParserRULE_adminSetAutomatedSnapshotOffStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2491) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33531,7 +33531,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdmi } { p.SetState(2492) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33539,7 +33539,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdmi } { p.SetState(2493) - p.Match(DorisSQLParserAUTOMATED) + p.Match(StarRocksSQLParserAUTOMATED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33547,7 +33547,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdmi } { p.SetState(2494) - p.Match(DorisSQLParserCLUSTER) + p.Match(StarRocksSQLParserCLUSTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33555,7 +33555,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdmi } { p.SetState(2495) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33563,7 +33563,7 @@ func (p *DorisSQLParser) AdminSetAutomatedSnapshotOffStatement() (localctx IAdmi } { p.SetState(2496) - p.Match(DorisSQLParserOFF) + p.Match(StarRocksSQLParserOFF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33607,13 +33607,13 @@ type AlterSystemStatementContext struct { func NewEmptyAlterSystemStatementContext() *AlterSystemStatementContext { var p = new(AlterSystemStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterSystemStatement + p.RuleIndex = StarRocksSQLParserRULE_alterSystemStatement return p } func InitEmptyAlterSystemStatementContext(p *AlterSystemStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterSystemStatement + p.RuleIndex = StarRocksSQLParserRULE_alterSystemStatement } func (*AlterSystemStatementContext) IsAlterSystemStatementContext() {} @@ -33624,7 +33624,7 @@ func NewAlterSystemStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterSystemStatement + p.RuleIndex = StarRocksSQLParserRULE_alterSystemStatement return p } @@ -33632,11 +33632,11 @@ func NewAlterSystemStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *AlterSystemStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterSystemStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterSystemStatementContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYSTEM, 0) + return s.GetToken(StarRocksSQLParserSYSTEM, 0) } func (s *AlterSystemStatementContext) AlterClause() IAlterClauseContext { @@ -33664,20 +33664,20 @@ func (s *AlterSystemStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *AlterSystemStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterSystemStatement(s) } } func (s *AlterSystemStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterSystemStatement(s) } } func (s *AlterSystemStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterSystemStatement(s) default: @@ -33685,13 +33685,13 @@ func (s *AlterSystemStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) AlterSystemStatement() (localctx IAlterSystemStatementContext) { +func (p *StarRocksSQLParser) AlterSystemStatement() (localctx IAlterSystemStatementContext) { localctx = NewAlterSystemStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 174, DorisSQLParserRULE_alterSystemStatement) + p.EnterRule(localctx, 174, StarRocksSQLParserRULE_alterSystemStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2498) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33699,7 +33699,7 @@ func (p *DorisSQLParser) AlterSystemStatement() (localctx IAlterSystemStatementC } { p.SetState(2499) - p.Match(DorisSQLParserSYSTEM) + p.Match(StarRocksSQLParserSYSTEM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33749,13 +33749,13 @@ type CancelAlterSystemStatementContext struct { func NewEmptyCancelAlterSystemStatementContext() *CancelAlterSystemStatementContext { var p = new(CancelAlterSystemStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelAlterSystemStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelAlterSystemStatement return p } func InitEmptyCancelAlterSystemStatementContext(p *CancelAlterSystemStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelAlterSystemStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelAlterSystemStatement } func (*CancelAlterSystemStatementContext) IsCancelAlterSystemStatementContext() {} @@ -33766,7 +33766,7 @@ func NewCancelAlterSystemStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelAlterSystemStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelAlterSystemStatement return p } @@ -33774,15 +33774,15 @@ func NewCancelAlterSystemStatementContext(parser antlr.Parser, parent antlr.Pars func (s *CancelAlterSystemStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelAlterSystemStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelAlterSystemStatementContext) DECOMMISSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECOMMISSION, 0) + return s.GetToken(StarRocksSQLParserDECOMMISSION, 0) } func (s *CancelAlterSystemStatementContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *CancelAlterSystemStatementContext) AllString_() []IStringContext { @@ -33835,20 +33835,20 @@ func (s *CancelAlterSystemStatementContext) ToStringTree(ruleNames []string, rec } func (s *CancelAlterSystemStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelAlterSystemStatement(s) } } func (s *CancelAlterSystemStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelAlterSystemStatement(s) } } func (s *CancelAlterSystemStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelAlterSystemStatement(s) default: @@ -33856,15 +33856,15 @@ func (s *CancelAlterSystemStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) CancelAlterSystemStatement() (localctx ICancelAlterSystemStatementContext) { +func (p *StarRocksSQLParser) CancelAlterSystemStatement() (localctx ICancelAlterSystemStatementContext) { localctx = NewCancelAlterSystemStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 176, DorisSQLParserRULE_cancelAlterSystemStatement) + p.EnterRule(localctx, 176, StarRocksSQLParserRULE_cancelAlterSystemStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2502) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33872,7 +33872,7 @@ func (p *DorisSQLParser) CancelAlterSystemStatement() (localctx ICancelAlterSyst } { p.SetState(2503) - p.Match(DorisSQLParserDECOMMISSION) + p.Match(StarRocksSQLParserDECOMMISSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33880,7 +33880,7 @@ func (p *DorisSQLParser) CancelAlterSystemStatement() (localctx ICancelAlterSyst } { p.SetState(2504) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33897,10 +33897,10 @@ func (p *DorisSQLParser) CancelAlterSystemStatement() (localctx ICancelAlterSyst } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2506) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -33956,13 +33956,13 @@ type ShowComputeNodesStatementContext struct { func NewEmptyShowComputeNodesStatementContext() *ShowComputeNodesStatementContext { var p = new(ShowComputeNodesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showComputeNodesStatement + p.RuleIndex = StarRocksSQLParserRULE_showComputeNodesStatement return p } func InitEmptyShowComputeNodesStatementContext(p *ShowComputeNodesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showComputeNodesStatement + p.RuleIndex = StarRocksSQLParserRULE_showComputeNodesStatement } func (*ShowComputeNodesStatementContext) IsShowComputeNodesStatementContext() {} @@ -33973,7 +33973,7 @@ func NewShowComputeNodesStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showComputeNodesStatement + p.RuleIndex = StarRocksSQLParserRULE_showComputeNodesStatement return p } @@ -33981,15 +33981,15 @@ func NewShowComputeNodesStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowComputeNodesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowComputeNodesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowComputeNodesStatementContext) COMPUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPUTE, 0) + return s.GetToken(StarRocksSQLParserCOMPUTE, 0) } func (s *ShowComputeNodesStatementContext) NODES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODES, 0) + return s.GetToken(StarRocksSQLParserNODES, 0) } func (s *ShowComputeNodesStatementContext) GetRuleContext() antlr.RuleContext { @@ -34001,20 +34001,20 @@ func (s *ShowComputeNodesStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowComputeNodesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowComputeNodesStatement(s) } } func (s *ShowComputeNodesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowComputeNodesStatement(s) } } func (s *ShowComputeNodesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowComputeNodesStatement(s) default: @@ -34022,13 +34022,13 @@ func (s *ShowComputeNodesStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowComputeNodesStatement() (localctx IShowComputeNodesStatementContext) { +func (p *StarRocksSQLParser) ShowComputeNodesStatement() (localctx IShowComputeNodesStatementContext) { localctx = NewShowComputeNodesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 178, DorisSQLParserRULE_showComputeNodesStatement) + p.EnterRule(localctx, 178, StarRocksSQLParserRULE_showComputeNodesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2513) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34036,7 +34036,7 @@ func (p *DorisSQLParser) ShowComputeNodesStatement() (localctx IShowComputeNodes } { p.SetState(2514) - p.Match(DorisSQLParserCOMPUTE) + p.Match(StarRocksSQLParserCOMPUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34044,7 +34044,7 @@ func (p *DorisSQLParser) ShowComputeNodesStatement() (localctx IShowComputeNodes } { p.SetState(2515) - p.Match(DorisSQLParserNODES) + p.Match(StarRocksSQLParserNODES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34101,13 +34101,13 @@ type CreateExternalCatalogStatementContext struct { func NewEmptyCreateExternalCatalogStatementContext() *CreateExternalCatalogStatementContext { var p = new(CreateExternalCatalogStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_createExternalCatalogStatement return p } func InitEmptyCreateExternalCatalogStatementContext(p *CreateExternalCatalogStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_createExternalCatalogStatement } func (*CreateExternalCatalogStatementContext) IsCreateExternalCatalogStatementContext() {} @@ -34118,7 +34118,7 @@ func NewCreateExternalCatalogStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_createExternalCatalogStatement return p } @@ -34134,15 +34134,15 @@ func (s *CreateExternalCatalogStatementContext) SetCatalogName(v IIdentifierOrSt } func (s *CreateExternalCatalogStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateExternalCatalogStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *CreateExternalCatalogStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *CreateExternalCatalogStatementContext) Properties() IPropertiesContext { @@ -34178,15 +34178,15 @@ func (s *CreateExternalCatalogStatementContext) IdentifierOrString() IIdentifier } func (s *CreateExternalCatalogStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateExternalCatalogStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateExternalCatalogStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateExternalCatalogStatementContext) Comment() ICommentContext { @@ -34214,20 +34214,20 @@ func (s *CreateExternalCatalogStatementContext) ToStringTree(ruleNames []string, } func (s *CreateExternalCatalogStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateExternalCatalogStatement(s) } } func (s *CreateExternalCatalogStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateExternalCatalogStatement(s) } } func (s *CreateExternalCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateExternalCatalogStatement(s) default: @@ -34235,15 +34235,15 @@ func (s *CreateExternalCatalogStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExternalCatalogStatementContext) { +func (p *StarRocksSQLParser) CreateExternalCatalogStatement() (localctx ICreateExternalCatalogStatementContext) { localctx = NewCreateExternalCatalogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 180, DorisSQLParserRULE_createExternalCatalogStatement) + p.EnterRule(localctx, 180, StarRocksSQLParserRULE_createExternalCatalogStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2517) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34251,7 +34251,7 @@ func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExter } { p.SetState(2518) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34259,7 +34259,7 @@ func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExter } { p.SetState(2519) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34272,10 +34272,10 @@ func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExter } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2520) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34283,7 +34283,7 @@ func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExter } { p.SetState(2521) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34291,7 +34291,7 @@ func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExter } { p.SetState(2522) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34313,7 +34313,7 @@ func (p *DorisSQLParser) CreateExternalCatalogStatement() (localctx ICreateExter } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(2526) p.Comment() @@ -34370,13 +34370,13 @@ type ShowCreateExternalCatalogStatementContext struct { func NewEmptyShowCreateExternalCatalogStatementContext() *ShowCreateExternalCatalogStatementContext { var p = new(ShowCreateExternalCatalogStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateExternalCatalogStatement return p } func InitEmptyShowCreateExternalCatalogStatementContext(p *ShowCreateExternalCatalogStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateExternalCatalogStatement } func (*ShowCreateExternalCatalogStatementContext) IsShowCreateExternalCatalogStatementContext() {} @@ -34387,7 +34387,7 @@ func NewShowCreateExternalCatalogStatementContext(parser antlr.Parser, parent an antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateExternalCatalogStatement return p } @@ -34403,15 +34403,15 @@ func (s *ShowCreateExternalCatalogStatementContext) SetCatalogName(v IIdentifier } func (s *ShowCreateExternalCatalogStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateExternalCatalogStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateExternalCatalogStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *ShowCreateExternalCatalogStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -34439,20 +34439,20 @@ func (s *ShowCreateExternalCatalogStatementContext) ToStringTree(ruleNames []str } func (s *ShowCreateExternalCatalogStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateExternalCatalogStatement(s) } } func (s *ShowCreateExternalCatalogStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateExternalCatalogStatement(s) } } func (s *ShowCreateExternalCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateExternalCatalogStatement(s) default: @@ -34460,13 +34460,13 @@ func (s *ShowCreateExternalCatalogStatementContext) Accept(visitor antlr.ParseTr } } -func (p *DorisSQLParser) ShowCreateExternalCatalogStatement() (localctx IShowCreateExternalCatalogStatementContext) { +func (p *StarRocksSQLParser) ShowCreateExternalCatalogStatement() (localctx IShowCreateExternalCatalogStatementContext) { localctx = NewShowCreateExternalCatalogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 182, DorisSQLParserRULE_showCreateExternalCatalogStatement) + p.EnterRule(localctx, 182, StarRocksSQLParserRULE_showCreateExternalCatalogStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2531) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34474,7 +34474,7 @@ func (p *DorisSQLParser) ShowCreateExternalCatalogStatement() (localctx IShowCre } { p.SetState(2532) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34482,7 +34482,7 @@ func (p *DorisSQLParser) ShowCreateExternalCatalogStatement() (localctx IShowCre } { p.SetState(2533) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34542,13 +34542,13 @@ type DropExternalCatalogStatementContext struct { func NewEmptyDropExternalCatalogStatementContext() *DropExternalCatalogStatementContext { var p = new(DropExternalCatalogStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_dropExternalCatalogStatement return p } func InitEmptyDropExternalCatalogStatementContext(p *DropExternalCatalogStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_dropExternalCatalogStatement } func (*DropExternalCatalogStatementContext) IsDropExternalCatalogStatementContext() {} @@ -34559,7 +34559,7 @@ func NewDropExternalCatalogStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropExternalCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_dropExternalCatalogStatement return p } @@ -34575,11 +34575,11 @@ func (s *DropExternalCatalogStatementContext) SetCatalogName(v IIdentifierOrStri } func (s *DropExternalCatalogStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropExternalCatalogStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *DropExternalCatalogStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -34599,11 +34599,11 @@ func (s *DropExternalCatalogStatementContext) IdentifierOrString() IIdentifierOr } func (s *DropExternalCatalogStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropExternalCatalogStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropExternalCatalogStatementContext) GetRuleContext() antlr.RuleContext { @@ -34615,20 +34615,20 @@ func (s *DropExternalCatalogStatementContext) ToStringTree(ruleNames []string, r } func (s *DropExternalCatalogStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropExternalCatalogStatement(s) } } func (s *DropExternalCatalogStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropExternalCatalogStatement(s) } } func (s *DropExternalCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropExternalCatalogStatement(s) default: @@ -34636,15 +34636,15 @@ func (s *DropExternalCatalogStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) DropExternalCatalogStatement() (localctx IDropExternalCatalogStatementContext) { +func (p *StarRocksSQLParser) DropExternalCatalogStatement() (localctx IDropExternalCatalogStatementContext) { localctx = NewDropExternalCatalogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 184, DorisSQLParserRULE_dropExternalCatalogStatement) + p.EnterRule(localctx, 184, StarRocksSQLParserRULE_dropExternalCatalogStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2536) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34652,7 +34652,7 @@ func (p *DorisSQLParser) DropExternalCatalogStatement() (localctx IDropExternalC } { p.SetState(2537) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34665,10 +34665,10 @@ func (p *DorisSQLParser) DropExternalCatalogStatement() (localctx IDropExternalC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2538) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34676,7 +34676,7 @@ func (p *DorisSQLParser) DropExternalCatalogStatement() (localctx IDropExternalC } { p.SetState(2539) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34737,13 +34737,13 @@ type ShowCatalogsStatementContext struct { func NewEmptyShowCatalogsStatementContext() *ShowCatalogsStatementContext { var p = new(ShowCatalogsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCatalogsStatement + p.RuleIndex = StarRocksSQLParserRULE_showCatalogsStatement return p } func InitEmptyShowCatalogsStatementContext(p *ShowCatalogsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCatalogsStatement + p.RuleIndex = StarRocksSQLParserRULE_showCatalogsStatement } func (*ShowCatalogsStatementContext) IsShowCatalogsStatementContext() {} @@ -34754,7 +34754,7 @@ func NewShowCatalogsStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCatalogsStatement + p.RuleIndex = StarRocksSQLParserRULE_showCatalogsStatement return p } @@ -34766,15 +34766,15 @@ func (s *ShowCatalogsStatementContext) GetPattern() IStringContext { return s.pa func (s *ShowCatalogsStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowCatalogsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCatalogsStatementContext) CATALOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOGS, 0) + return s.GetToken(StarRocksSQLParserCATALOGS, 0) } func (s *ShowCatalogsStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowCatalogsStatementContext) String_() IStringContext { @@ -34802,20 +34802,20 @@ func (s *ShowCatalogsStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowCatalogsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCatalogsStatement(s) } } func (s *ShowCatalogsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCatalogsStatement(s) } } func (s *ShowCatalogsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCatalogsStatement(s) default: @@ -34823,15 +34823,15 @@ func (s *ShowCatalogsStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowCatalogsStatement() (localctx IShowCatalogsStatementContext) { +func (p *StarRocksSQLParser) ShowCatalogsStatement() (localctx IShowCatalogsStatementContext) { localctx = NewShowCatalogsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 186, DorisSQLParserRULE_showCatalogsStatement) + p.EnterRule(localctx, 186, StarRocksSQLParserRULE_showCatalogsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2544) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34839,7 +34839,7 @@ func (p *DorisSQLParser) ShowCatalogsStatement() (localctx IShowCatalogsStatemen } { p.SetState(2545) - p.Match(DorisSQLParserCATALOGS) + p.Match(StarRocksSQLParserCATALOGS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34852,10 +34852,10 @@ func (p *DorisSQLParser) ShowCatalogsStatement() (localctx IShowCatalogsStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(2546) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -34916,13 +34916,13 @@ type AlterCatalogStatementContext struct { func NewEmptyAlterCatalogStatementContext() *AlterCatalogStatementContext { var p = new(AlterCatalogStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_alterCatalogStatement return p } func InitEmptyAlterCatalogStatementContext(p *AlterCatalogStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_alterCatalogStatement } func (*AlterCatalogStatementContext) IsAlterCatalogStatementContext() {} @@ -34933,7 +34933,7 @@ func NewAlterCatalogStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterCatalogStatement + p.RuleIndex = StarRocksSQLParserRULE_alterCatalogStatement return p } @@ -34949,11 +34949,11 @@ func (s *AlterCatalogStatementContext) SetCatalogName(v IIdentifierOrStringConte } func (s *AlterCatalogStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterCatalogStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *AlterCatalogStatementContext) ModifyPropertiesClause() IModifyPropertiesClauseContext { @@ -34997,20 +34997,20 @@ func (s *AlterCatalogStatementContext) ToStringTree(ruleNames []string, recog an } func (s *AlterCatalogStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterCatalogStatement(s) } } func (s *AlterCatalogStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterCatalogStatement(s) } } func (s *AlterCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterCatalogStatement(s) default: @@ -35018,13 +35018,13 @@ func (s *AlterCatalogStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) AlterCatalogStatement() (localctx IAlterCatalogStatementContext) { +func (p *StarRocksSQLParser) AlterCatalogStatement() (localctx IAlterCatalogStatementContext) { localctx = NewAlterCatalogStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 188, DorisSQLParserRULE_alterCatalogStatement) + p.EnterRule(localctx, 188, StarRocksSQLParserRULE_alterCatalogStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2550) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35032,7 +35032,7 @@ func (p *DorisSQLParser) AlterCatalogStatement() (localctx IAlterCatalogStatemen } { p.SetState(2551) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35102,13 +35102,13 @@ type CreateStorageVolumeStatementContext struct { func NewEmptyCreateStorageVolumeStatementContext() *CreateStorageVolumeStatementContext { var p = new(CreateStorageVolumeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_createStorageVolumeStatement return p } func InitEmptyCreateStorageVolumeStatementContext(p *CreateStorageVolumeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_createStorageVolumeStatement } func (*CreateStorageVolumeStatementContext) IsCreateStorageVolumeStatementContext() {} @@ -35119,7 +35119,7 @@ func NewCreateStorageVolumeStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_createStorageVolumeStatement return p } @@ -35135,15 +35135,15 @@ func (s *CreateStorageVolumeStatementContext) SetStorageVolumeName(v IIdentifier } func (s *CreateStorageVolumeStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateStorageVolumeStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *CreateStorageVolumeStatementContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *CreateStorageVolumeStatementContext) TypeDesc() ITypeDescContext { @@ -35195,15 +35195,15 @@ func (s *CreateStorageVolumeStatementContext) IdentifierOrString() IIdentifierOr } func (s *CreateStorageVolumeStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateStorageVolumeStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateStorageVolumeStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateStorageVolumeStatementContext) Comment() ICommentContext { @@ -35247,20 +35247,20 @@ func (s *CreateStorageVolumeStatementContext) ToStringTree(ruleNames []string, r } func (s *CreateStorageVolumeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateStorageVolumeStatement(s) } } func (s *CreateStorageVolumeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateStorageVolumeStatement(s) } } func (s *CreateStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateStorageVolumeStatement(s) default: @@ -35268,15 +35268,15 @@ func (s *CreateStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorageVolumeStatementContext) { +func (p *StarRocksSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorageVolumeStatementContext) { localctx = NewCreateStorageVolumeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 190, DorisSQLParserRULE_createStorageVolumeStatement) + p.EnterRule(localctx, 190, StarRocksSQLParserRULE_createStorageVolumeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2555) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35284,7 +35284,7 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } { p.SetState(2556) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35292,7 +35292,7 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } { p.SetState(2557) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35305,10 +35305,10 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2558) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35316,7 +35316,7 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } { p.SetState(2559) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35324,7 +35324,7 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } { p.SetState(2560) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35354,7 +35354,7 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(2566) p.Comment() @@ -35368,7 +35368,7 @@ func (p *DorisSQLParser) CreateStorageVolumeStatement() (localctx ICreateStorage } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(2569) p.Properties() @@ -35413,13 +35413,13 @@ type TypeDescContext struct { func NewEmptyTypeDescContext() *TypeDescContext { var p = new(TypeDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeDesc + p.RuleIndex = StarRocksSQLParserRULE_typeDesc return p } func InitEmptyTypeDescContext(p *TypeDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeDesc + p.RuleIndex = StarRocksSQLParserRULE_typeDesc } func (*TypeDescContext) IsTypeDescContext() {} @@ -35430,7 +35430,7 @@ func NewTypeDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_typeDesc + p.RuleIndex = StarRocksSQLParserRULE_typeDesc return p } @@ -35438,11 +35438,11 @@ func NewTypeDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *TypeDescContext) GetParser() antlr.Parser { return s.parser } func (s *TypeDescContext) TYPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTYPE, 0) + return s.GetToken(StarRocksSQLParserTYPE, 0) } func (s *TypeDescContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *TypeDescContext) Identifier() IIdentifierContext { @@ -35470,20 +35470,20 @@ func (s *TypeDescContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *TypeDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTypeDesc(s) } } func (s *TypeDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTypeDesc(s) } } func (s *TypeDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTypeDesc(s) default: @@ -35491,13 +35491,13 @@ func (s *TypeDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TypeDesc() (localctx ITypeDescContext) { +func (p *StarRocksSQLParser) TypeDesc() (localctx ITypeDescContext) { localctx = NewTypeDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 192, DorisSQLParserRULE_typeDesc) + p.EnterRule(localctx, 192, StarRocksSQLParserRULE_typeDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(2572) - p.Match(DorisSQLParserTYPE) + p.Match(StarRocksSQLParserTYPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35505,7 +35505,7 @@ func (p *DorisSQLParser) TypeDesc() (localctx ITypeDescContext) { } { p.SetState(2573) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35553,13 +35553,13 @@ type LocationsDescContext struct { func NewEmptyLocationsDescContext() *LocationsDescContext { var p = new(LocationsDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_locationsDesc + p.RuleIndex = StarRocksSQLParserRULE_locationsDesc return p } func InitEmptyLocationsDescContext(p *LocationsDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_locationsDesc + p.RuleIndex = StarRocksSQLParserRULE_locationsDesc } func (*LocationsDescContext) IsLocationsDescContext() {} @@ -35570,7 +35570,7 @@ func NewLocationsDescContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_locationsDesc + p.RuleIndex = StarRocksSQLParserRULE_locationsDesc return p } @@ -35578,11 +35578,11 @@ func NewLocationsDescContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *LocationsDescContext) GetParser() antlr.Parser { return s.parser } func (s *LocationsDescContext) LOCATIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCATIONS, 0) + return s.GetToken(StarRocksSQLParserLOCATIONS, 0) } func (s *LocationsDescContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *LocationsDescContext) StringList() IStringListContext { @@ -35610,20 +35610,20 @@ func (s *LocationsDescContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *LocationsDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLocationsDesc(s) } } func (s *LocationsDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLocationsDesc(s) } } func (s *LocationsDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLocationsDesc(s) default: @@ -35631,13 +35631,13 @@ func (s *LocationsDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) LocationsDesc() (localctx ILocationsDescContext) { +func (p *StarRocksSQLParser) LocationsDesc() (localctx ILocationsDescContext) { localctx = NewLocationsDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 194, DorisSQLParserRULE_locationsDesc) + p.EnterRule(localctx, 194, StarRocksSQLParserRULE_locationsDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(2576) - p.Match(DorisSQLParserLOCATIONS) + p.Match(StarRocksSQLParserLOCATIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35645,7 +35645,7 @@ func (p *DorisSQLParser) LocationsDesc() (localctx ILocationsDescContext) { } { p.SetState(2577) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35702,13 +35702,13 @@ type ShowStorageVolumesStatementContext struct { func NewEmptyShowStorageVolumesStatementContext() *ShowStorageVolumesStatementContext { var p = new(ShowStorageVolumesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStorageVolumesStatement + p.RuleIndex = StarRocksSQLParserRULE_showStorageVolumesStatement return p } func InitEmptyShowStorageVolumesStatementContext(p *ShowStorageVolumesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStorageVolumesStatement + p.RuleIndex = StarRocksSQLParserRULE_showStorageVolumesStatement } func (*ShowStorageVolumesStatementContext) IsShowStorageVolumesStatementContext() {} @@ -35719,7 +35719,7 @@ func NewShowStorageVolumesStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showStorageVolumesStatement + p.RuleIndex = StarRocksSQLParserRULE_showStorageVolumesStatement return p } @@ -35731,19 +35731,19 @@ func (s *ShowStorageVolumesStatementContext) GetPattern() IStringContext { retur func (s *ShowStorageVolumesStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowStorageVolumesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowStorageVolumesStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *ShowStorageVolumesStatementContext) VOLUMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUMES, 0) + return s.GetToken(StarRocksSQLParserVOLUMES, 0) } func (s *ShowStorageVolumesStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowStorageVolumesStatementContext) String_() IStringContext { @@ -35771,20 +35771,20 @@ func (s *ShowStorageVolumesStatementContext) ToStringTree(ruleNames []string, re } func (s *ShowStorageVolumesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowStorageVolumesStatement(s) } } func (s *ShowStorageVolumesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowStorageVolumesStatement(s) } } func (s *ShowStorageVolumesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowStorageVolumesStatement(s) default: @@ -35792,15 +35792,15 @@ func (s *ShowStorageVolumesStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) ShowStorageVolumesStatement() (localctx IShowStorageVolumesStatementContext) { +func (p *StarRocksSQLParser) ShowStorageVolumesStatement() (localctx IShowStorageVolumesStatementContext) { localctx = NewShowStorageVolumesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 196, DorisSQLParserRULE_showStorageVolumesStatement) + p.EnterRule(localctx, 196, StarRocksSQLParserRULE_showStorageVolumesStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2580) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35808,7 +35808,7 @@ func (p *DorisSQLParser) ShowStorageVolumesStatement() (localctx IShowStorageVol } { p.SetState(2581) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35816,7 +35816,7 @@ func (p *DorisSQLParser) ShowStorageVolumesStatement() (localctx IShowStorageVol } { p.SetState(2582) - p.Match(DorisSQLParserVOLUMES) + p.Match(StarRocksSQLParserVOLUMES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35829,10 +35829,10 @@ func (p *DorisSQLParser) ShowStorageVolumesStatement() (localctx IShowStorageVol } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(2583) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -35895,13 +35895,13 @@ type DropStorageVolumeStatementContext struct { func NewEmptyDropStorageVolumeStatementContext() *DropStorageVolumeStatementContext { var p = new(DropStorageVolumeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_dropStorageVolumeStatement return p } func InitEmptyDropStorageVolumeStatementContext(p *DropStorageVolumeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_dropStorageVolumeStatement } func (*DropStorageVolumeStatementContext) IsDropStorageVolumeStatementContext() {} @@ -35912,7 +35912,7 @@ func NewDropStorageVolumeStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_dropStorageVolumeStatement return p } @@ -35928,15 +35928,15 @@ func (s *DropStorageVolumeStatementContext) SetStorageVolumeName(v IIdentifierOr } func (s *DropStorageVolumeStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropStorageVolumeStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *DropStorageVolumeStatementContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *DropStorageVolumeStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -35956,11 +35956,11 @@ func (s *DropStorageVolumeStatementContext) IdentifierOrString() IIdentifierOrSt } func (s *DropStorageVolumeStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropStorageVolumeStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropStorageVolumeStatementContext) GetRuleContext() antlr.RuleContext { @@ -35972,20 +35972,20 @@ func (s *DropStorageVolumeStatementContext) ToStringTree(ruleNames []string, rec } func (s *DropStorageVolumeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropStorageVolumeStatement(s) } } func (s *DropStorageVolumeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropStorageVolumeStatement(s) } } func (s *DropStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropStorageVolumeStatement(s) default: @@ -35993,15 +35993,15 @@ func (s *DropStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) DropStorageVolumeStatement() (localctx IDropStorageVolumeStatementContext) { +func (p *StarRocksSQLParser) DropStorageVolumeStatement() (localctx IDropStorageVolumeStatementContext) { localctx = NewDropStorageVolumeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 198, DorisSQLParserRULE_dropStorageVolumeStatement) + p.EnterRule(localctx, 198, StarRocksSQLParserRULE_dropStorageVolumeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2587) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36009,7 +36009,7 @@ func (p *DorisSQLParser) DropStorageVolumeStatement() (localctx IDropStorageVolu } { p.SetState(2588) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36017,7 +36017,7 @@ func (p *DorisSQLParser) DropStorageVolumeStatement() (localctx IDropStorageVolu } { p.SetState(2589) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36030,10 +36030,10 @@ func (p *DorisSQLParser) DropStorageVolumeStatement() (localctx IDropStorageVolu } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(2590) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36041,7 +36041,7 @@ func (p *DorisSQLParser) DropStorageVolumeStatement() (localctx IDropStorageVolu } { p.SetState(2591) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36097,13 +36097,13 @@ type AlterStorageVolumeStatementContext struct { func NewEmptyAlterStorageVolumeStatementContext() *AlterStorageVolumeStatementContext { var p = new(AlterStorageVolumeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_alterStorageVolumeStatement return p } func InitEmptyAlterStorageVolumeStatementContext(p *AlterStorageVolumeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_alterStorageVolumeStatement } func (*AlterStorageVolumeStatementContext) IsAlterStorageVolumeStatementContext() {} @@ -36114,7 +36114,7 @@ func NewAlterStorageVolumeStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_alterStorageVolumeStatement return p } @@ -36122,15 +36122,15 @@ func NewAlterStorageVolumeStatementContext(parser antlr.Parser, parent antlr.Par func (s *AlterStorageVolumeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterStorageVolumeStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterStorageVolumeStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *AlterStorageVolumeStatementContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *AlterStorageVolumeStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -36199,20 +36199,20 @@ func (s *AlterStorageVolumeStatementContext) ToStringTree(ruleNames []string, re } func (s *AlterStorageVolumeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterStorageVolumeStatement(s) } } func (s *AlterStorageVolumeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterStorageVolumeStatement(s) } } func (s *AlterStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterStorageVolumeStatement(s) default: @@ -36220,15 +36220,15 @@ func (s *AlterStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) AlterStorageVolumeStatement() (localctx IAlterStorageVolumeStatementContext) { +func (p *StarRocksSQLParser) AlterStorageVolumeStatement() (localctx IAlterStorageVolumeStatementContext) { localctx = NewAlterStorageVolumeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 200, DorisSQLParserRULE_alterStorageVolumeStatement) + p.EnterRule(localctx, 200, StarRocksSQLParserRULE_alterStorageVolumeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2596) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36236,7 +36236,7 @@ func (p *DorisSQLParser) AlterStorageVolumeStatement() (localctx IAlterStorageVo } { p.SetState(2597) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36244,7 +36244,7 @@ func (p *DorisSQLParser) AlterStorageVolumeStatement() (localctx IAlterStorageVo } { p.SetState(2598) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36265,10 +36265,10 @@ func (p *DorisSQLParser) AlterStorageVolumeStatement() (localctx IAlterStorageVo } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2601) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36323,13 +36323,13 @@ type AlterStorageVolumeClauseContext struct { func NewEmptyAlterStorageVolumeClauseContext() *AlterStorageVolumeClauseContext { var p = new(AlterStorageVolumeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterStorageVolumeClause + p.RuleIndex = StarRocksSQLParserRULE_alterStorageVolumeClause return p } func InitEmptyAlterStorageVolumeClauseContext(p *AlterStorageVolumeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterStorageVolumeClause + p.RuleIndex = StarRocksSQLParserRULE_alterStorageVolumeClause } func (*AlterStorageVolumeClauseContext) IsAlterStorageVolumeClauseContext() {} @@ -36340,7 +36340,7 @@ func NewAlterStorageVolumeClauseContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterStorageVolumeClause + p.RuleIndex = StarRocksSQLParserRULE_alterStorageVolumeClause return p } @@ -36388,20 +36388,20 @@ func (s *AlterStorageVolumeClauseContext) ToStringTree(ruleNames []string, recog } func (s *AlterStorageVolumeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterStorageVolumeClause(s) } } func (s *AlterStorageVolumeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterStorageVolumeClause(s) } } func (s *AlterStorageVolumeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterStorageVolumeClause(s) default: @@ -36409,9 +36409,9 @@ func (s *AlterStorageVolumeClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AlterStorageVolumeClause() (localctx IAlterStorageVolumeClauseContext) { +func (p *StarRocksSQLParser) AlterStorageVolumeClause() (localctx IAlterStorageVolumeClauseContext) { localctx = NewAlterStorageVolumeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 202, DorisSQLParserRULE_alterStorageVolumeClause) + p.EnterRule(localctx, 202, StarRocksSQLParserRULE_alterStorageVolumeClause) p.SetState(2610) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -36419,14 +36419,14 @@ func (p *DorisSQLParser) AlterStorageVolumeClause() (localctx IAlterStorageVolum } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCOMMENT: + case StarRocksSQLParserCOMMENT: p.EnterOuterAlt(localctx, 1) { p.SetState(2608) p.ModifyStorageVolumeCommentClause() } - case DorisSQLParserSET: + case StarRocksSQLParserSET: p.EnterOuterAlt(localctx, 2) { p.SetState(2609) @@ -36474,13 +36474,13 @@ type ModifyStorageVolumePropertiesClauseContext struct { func NewEmptyModifyStorageVolumePropertiesClauseContext() *ModifyStorageVolumePropertiesClauseContext { var p = new(ModifyStorageVolumePropertiesClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyStorageVolumePropertiesClause + p.RuleIndex = StarRocksSQLParserRULE_modifyStorageVolumePropertiesClause return p } func InitEmptyModifyStorageVolumePropertiesClauseContext(p *ModifyStorageVolumePropertiesClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyStorageVolumePropertiesClause + p.RuleIndex = StarRocksSQLParserRULE_modifyStorageVolumePropertiesClause } func (*ModifyStorageVolumePropertiesClauseContext) IsModifyStorageVolumePropertiesClauseContext() {} @@ -36491,7 +36491,7 @@ func NewModifyStorageVolumePropertiesClauseContext(parser antlr.Parser, parent a antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyStorageVolumePropertiesClause + p.RuleIndex = StarRocksSQLParserRULE_modifyStorageVolumePropertiesClause return p } @@ -36499,7 +36499,7 @@ func NewModifyStorageVolumePropertiesClauseContext(parser antlr.Parser, parent a func (s *ModifyStorageVolumePropertiesClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyStorageVolumePropertiesClauseContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *ModifyStorageVolumePropertiesClauseContext) PropertyList() IPropertyListContext { @@ -36527,20 +36527,20 @@ func (s *ModifyStorageVolumePropertiesClauseContext) ToStringTree(ruleNames []st } func (s *ModifyStorageVolumePropertiesClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyStorageVolumePropertiesClause(s) } } func (s *ModifyStorageVolumePropertiesClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyStorageVolumePropertiesClause(s) } } func (s *ModifyStorageVolumePropertiesClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyStorageVolumePropertiesClause(s) default: @@ -36548,13 +36548,13 @@ func (s *ModifyStorageVolumePropertiesClauseContext) Accept(visitor antlr.ParseT } } -func (p *DorisSQLParser) ModifyStorageVolumePropertiesClause() (localctx IModifyStorageVolumePropertiesClauseContext) { +func (p *StarRocksSQLParser) ModifyStorageVolumePropertiesClause() (localctx IModifyStorageVolumePropertiesClauseContext) { localctx = NewModifyStorageVolumePropertiesClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 204, DorisSQLParserRULE_modifyStorageVolumePropertiesClause) + p.EnterRule(localctx, 204, StarRocksSQLParserRULE_modifyStorageVolumePropertiesClause) p.EnterOuterAlt(localctx, 1) { p.SetState(2612) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36602,13 +36602,13 @@ type ModifyStorageVolumeCommentClauseContext struct { func NewEmptyModifyStorageVolumeCommentClauseContext() *ModifyStorageVolumeCommentClauseContext { var p = new(ModifyStorageVolumeCommentClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyStorageVolumeCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyStorageVolumeCommentClause return p } func InitEmptyModifyStorageVolumeCommentClauseContext(p *ModifyStorageVolumeCommentClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyStorageVolumeCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyStorageVolumeCommentClause } func (*ModifyStorageVolumeCommentClauseContext) IsModifyStorageVolumeCommentClauseContext() {} @@ -36619,7 +36619,7 @@ func NewModifyStorageVolumeCommentClauseContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyStorageVolumeCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyStorageVolumeCommentClause return p } @@ -36627,11 +36627,11 @@ func NewModifyStorageVolumeCommentClauseContext(parser antlr.Parser, parent antl func (s *ModifyStorageVolumeCommentClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyStorageVolumeCommentClauseContext) COMMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMENT, 0) + return s.GetToken(StarRocksSQLParserCOMMENT, 0) } func (s *ModifyStorageVolumeCommentClauseContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *ModifyStorageVolumeCommentClauseContext) String_() IStringContext { @@ -36659,20 +36659,20 @@ func (s *ModifyStorageVolumeCommentClauseContext) ToStringTree(ruleNames []strin } func (s *ModifyStorageVolumeCommentClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyStorageVolumeCommentClause(s) } } func (s *ModifyStorageVolumeCommentClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyStorageVolumeCommentClause(s) } } func (s *ModifyStorageVolumeCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyStorageVolumeCommentClause(s) default: @@ -36680,13 +36680,13 @@ func (s *ModifyStorageVolumeCommentClauseContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) ModifyStorageVolumeCommentClause() (localctx IModifyStorageVolumeCommentClauseContext) { +func (p *StarRocksSQLParser) ModifyStorageVolumeCommentClause() (localctx IModifyStorageVolumeCommentClauseContext) { localctx = NewModifyStorageVolumeCommentClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 206, DorisSQLParserRULE_modifyStorageVolumeCommentClause) + p.EnterRule(localctx, 206, StarRocksSQLParserRULE_modifyStorageVolumeCommentClause) p.EnterOuterAlt(localctx, 1) { p.SetState(2615) - p.Match(DorisSQLParserCOMMENT) + p.Match(StarRocksSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36694,7 +36694,7 @@ func (p *DorisSQLParser) ModifyStorageVolumeCommentClause() (localctx IModifySto } { p.SetState(2616) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36744,13 +36744,13 @@ type DescStorageVolumeStatementContext struct { func NewEmptyDescStorageVolumeStatementContext() *DescStorageVolumeStatementContext { var p = new(DescStorageVolumeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_descStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_descStorageVolumeStatement return p } func InitEmptyDescStorageVolumeStatementContext(p *DescStorageVolumeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_descStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_descStorageVolumeStatement } func (*DescStorageVolumeStatementContext) IsDescStorageVolumeStatementContext() {} @@ -36761,7 +36761,7 @@ func NewDescStorageVolumeStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_descStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_descStorageVolumeStatement return p } @@ -36769,11 +36769,11 @@ func NewDescStorageVolumeStatementContext(parser antlr.Parser, parent antlr.Pars func (s *DescStorageVolumeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DescStorageVolumeStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *DescStorageVolumeStatementContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *DescStorageVolumeStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -36793,11 +36793,11 @@ func (s *DescStorageVolumeStatementContext) IdentifierOrString() IIdentifierOrSt } func (s *DescStorageVolumeStatementContext) DESC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESC, 0) + return s.GetToken(StarRocksSQLParserDESC, 0) } func (s *DescStorageVolumeStatementContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESCRIBE, 0) + return s.GetToken(StarRocksSQLParserDESCRIBE, 0) } func (s *DescStorageVolumeStatementContext) GetRuleContext() antlr.RuleContext { @@ -36809,20 +36809,20 @@ func (s *DescStorageVolumeStatementContext) ToStringTree(ruleNames []string, rec } func (s *DescStorageVolumeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDescStorageVolumeStatement(s) } } func (s *DescStorageVolumeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDescStorageVolumeStatement(s) } } func (s *DescStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDescStorageVolumeStatement(s) default: @@ -36830,9 +36830,9 @@ func (s *DescStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) DescStorageVolumeStatement() (localctx IDescStorageVolumeStatementContext) { +func (p *StarRocksSQLParser) DescStorageVolumeStatement() (localctx IDescStorageVolumeStatementContext) { localctx = NewDescStorageVolumeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 208, DorisSQLParserRULE_descStorageVolumeStatement) + p.EnterRule(localctx, 208, StarRocksSQLParserRULE_descStorageVolumeStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -36840,7 +36840,7 @@ func (p *DorisSQLParser) DescStorageVolumeStatement() (localctx IDescStorageVolu p.SetState(2619) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDESC || _la == DorisSQLParserDESCRIBE) { + if !(_la == StarRocksSQLParserDESC || _la == StarRocksSQLParserDESCRIBE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -36849,7 +36849,7 @@ func (p *DorisSQLParser) DescStorageVolumeStatement() (localctx IDescStorageVolu } { p.SetState(2620) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36857,7 +36857,7 @@ func (p *DorisSQLParser) DescStorageVolumeStatement() (localctx IDescStorageVolu } { p.SetState(2621) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -36908,13 +36908,13 @@ type SetDefaultStorageVolumeStatementContext struct { func NewEmptySetDefaultStorageVolumeStatementContext() *SetDefaultStorageVolumeStatementContext { var p = new(SetDefaultStorageVolumeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setDefaultStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_setDefaultStorageVolumeStatement return p } func InitEmptySetDefaultStorageVolumeStatementContext(p *SetDefaultStorageVolumeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setDefaultStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_setDefaultStorageVolumeStatement } func (*SetDefaultStorageVolumeStatementContext) IsSetDefaultStorageVolumeStatementContext() {} @@ -36925,7 +36925,7 @@ func NewSetDefaultStorageVolumeStatementContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setDefaultStorageVolumeStatement + p.RuleIndex = StarRocksSQLParserRULE_setDefaultStorageVolumeStatement return p } @@ -36933,7 +36933,7 @@ func NewSetDefaultStorageVolumeStatementContext(parser antlr.Parser, parent antl func (s *SetDefaultStorageVolumeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetDefaultStorageVolumeStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetDefaultStorageVolumeStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -36953,19 +36953,19 @@ func (s *SetDefaultStorageVolumeStatementContext) IdentifierOrString() IIdentifi } func (s *SetDefaultStorageVolumeStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *SetDefaultStorageVolumeStatementContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *SetDefaultStorageVolumeStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *SetDefaultStorageVolumeStatementContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *SetDefaultStorageVolumeStatementContext) GetRuleContext() antlr.RuleContext { @@ -36977,20 +36977,20 @@ func (s *SetDefaultStorageVolumeStatementContext) ToStringTree(ruleNames []strin } func (s *SetDefaultStorageVolumeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetDefaultStorageVolumeStatement(s) } } func (s *SetDefaultStorageVolumeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetDefaultStorageVolumeStatement(s) } } func (s *SetDefaultStorageVolumeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetDefaultStorageVolumeStatement(s) default: @@ -36998,13 +36998,13 @@ func (s *SetDefaultStorageVolumeStatementContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) SetDefaultStorageVolumeStatement() (localctx ISetDefaultStorageVolumeStatementContext) { +func (p *StarRocksSQLParser) SetDefaultStorageVolumeStatement() (localctx ISetDefaultStorageVolumeStatementContext) { localctx = NewSetDefaultStorageVolumeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 210, DorisSQLParserRULE_setDefaultStorageVolumeStatement) + p.EnterRule(localctx, 210, StarRocksSQLParserRULE_setDefaultStorageVolumeStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2624) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37016,7 +37016,7 @@ func (p *DorisSQLParser) SetDefaultStorageVolumeStatement() (localctx ISetDefaul } { p.SetState(2626) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37024,7 +37024,7 @@ func (p *DorisSQLParser) SetDefaultStorageVolumeStatement() (localctx ISetDefaul } { p.SetState(2627) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37032,7 +37032,7 @@ func (p *DorisSQLParser) SetDefaultStorageVolumeStatement() (localctx ISetDefaul } { p.SetState(2628) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37040,7 +37040,7 @@ func (p *DorisSQLParser) SetDefaultStorageVolumeStatement() (localctx ISetDefaul } { p.SetState(2629) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37109,13 +37109,13 @@ type UpdateFailPointStatusStatementContext struct { func NewEmptyUpdateFailPointStatusStatementContext() *UpdateFailPointStatusStatementContext { var p = new(UpdateFailPointStatusStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_updateFailPointStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_updateFailPointStatusStatement return p } func InitEmptyUpdateFailPointStatusStatementContext(p *UpdateFailPointStatusStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_updateFailPointStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_updateFailPointStatusStatement } func (*UpdateFailPointStatusStatementContext) IsUpdateFailPointStatusStatementContext() {} @@ -37126,7 +37126,7 @@ func NewUpdateFailPointStatusStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_updateFailPointStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_updateFailPointStatusStatement return p } @@ -37142,11 +37142,11 @@ func (s *UpdateFailPointStatusStatementContext) SetTimes(v antlr.Token) { s.time func (s *UpdateFailPointStatusStatementContext) SetProb(v antlr.Token) { s.prob = v } func (s *UpdateFailPointStatusStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *UpdateFailPointStatusStatementContext) FAILPOINT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFAILPOINT, 0) + return s.GetToken(StarRocksSQLParserFAILPOINT, 0) } func (s *UpdateFailPointStatusStatementContext) AllString_() []IStringContext { @@ -37191,43 +37191,43 @@ func (s *UpdateFailPointStatusStatementContext) String_(i int) IStringContext { } func (s *UpdateFailPointStatusStatementContext) DISABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISABLE, 0) + return s.GetToken(StarRocksSQLParserDISABLE, 0) } func (s *UpdateFailPointStatusStatementContext) ENABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENABLE, 0) + return s.GetToken(StarRocksSQLParserENABLE, 0) } func (s *UpdateFailPointStatusStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *UpdateFailPointStatusStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *UpdateFailPointStatusStatementContext) TIMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMES, 0) + return s.GetToken(StarRocksSQLParserTIMES, 0) } func (s *UpdateFailPointStatusStatementContext) PROBABILITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROBABILITY, 0) + return s.GetToken(StarRocksSQLParserPROBABILITY, 0) } func (s *UpdateFailPointStatusStatementContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *UpdateFailPointStatusStatementContext) FRONTEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTEND, 0) + return s.GetToken(StarRocksSQLParserFRONTEND, 0) } func (s *UpdateFailPointStatusStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *UpdateFailPointStatusStatementContext) DECIMAL_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMAL_VALUE, 0) + return s.GetToken(StarRocksSQLParserDECIMAL_VALUE, 0) } func (s *UpdateFailPointStatusStatementContext) GetRuleContext() antlr.RuleContext { @@ -37239,20 +37239,20 @@ func (s *UpdateFailPointStatusStatementContext) ToStringTree(ruleNames []string, } func (s *UpdateFailPointStatusStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUpdateFailPointStatusStatement(s) } } func (s *UpdateFailPointStatusStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUpdateFailPointStatusStatement(s) } } func (s *UpdateFailPointStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUpdateFailPointStatusStatement(s) default: @@ -37260,15 +37260,15 @@ func (s *UpdateFailPointStatusStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailPointStatusStatementContext) { +func (p *StarRocksSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailPointStatusStatementContext) { localctx = NewUpdateFailPointStatusStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 212, DorisSQLParserRULE_updateFailPointStatusStatement) + p.EnterRule(localctx, 212, StarRocksSQLParserRULE_updateFailPointStatusStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2631) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37278,7 +37278,7 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP p.SetState(2632) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDISABLE || _la == DorisSQLParserENABLE) { + if !(_la == StarRocksSQLParserDISABLE || _la == StarRocksSQLParserENABLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -37287,7 +37287,7 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } { p.SetState(2633) - p.Match(DorisSQLParserFAILPOINT) + p.Match(StarRocksSQLParserFAILPOINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37304,10 +37304,10 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(2635) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37320,11 +37320,11 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } switch p.GetTokenStream().LA(1) { - case DorisSQLParserINTEGER_VALUE: + case StarRocksSQLParserINTEGER_VALUE: { p.SetState(2636) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*UpdateFailPointStatusStatementContext).times = _m if p.HasError() { @@ -37334,18 +37334,18 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } { p.SetState(2637) - p.Match(DorisSQLParserTIMES) + p.Match(StarRocksSQLParserTIMES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDECIMAL_VALUE: + case StarRocksSQLParserDECIMAL_VALUE: { p.SetState(2638) - var _m = p.Match(DorisSQLParserDECIMAL_VALUE) + var _m = p.Match(StarRocksSQLParserDECIMAL_VALUE) localctx.(*UpdateFailPointStatusStatementContext).prob = _m if p.HasError() { @@ -37355,7 +37355,7 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } { p.SetState(2639) - p.Match(DorisSQLParserPROBABILITY) + p.Match(StarRocksSQLParserPROBABILITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37375,10 +37375,10 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserON { + if _la == StarRocksSQLParserON { { p.SetState(2644) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37391,10 +37391,10 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP } switch p.GetTokenStream().LA(1) { - case DorisSQLParserBACKEND: + case StarRocksSQLParserBACKEND: { p.SetState(2645) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37405,10 +37405,10 @@ func (p *DorisSQLParser) UpdateFailPointStatusStatement() (localctx IUpdateFailP p.String_() } - case DorisSQLParserFRONTEND: + case StarRocksSQLParserFRONTEND: { p.SetState(2647) - p.Match(DorisSQLParserFRONTEND) + p.Match(StarRocksSQLParserFRONTEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37470,13 +37470,13 @@ type ShowFailPointStatementContext struct { func NewEmptyShowFailPointStatementContext() *ShowFailPointStatementContext { var p = new(ShowFailPointStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFailPointStatement + p.RuleIndex = StarRocksSQLParserRULE_showFailPointStatement return p } func InitEmptyShowFailPointStatementContext(p *ShowFailPointStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFailPointStatement + p.RuleIndex = StarRocksSQLParserRULE_showFailPointStatement } func (*ShowFailPointStatementContext) IsShowFailPointStatementContext() {} @@ -37487,7 +37487,7 @@ func NewShowFailPointStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showFailPointStatement + p.RuleIndex = StarRocksSQLParserRULE_showFailPointStatement return p } @@ -37499,19 +37499,19 @@ func (s *ShowFailPointStatementContext) GetPattern() IStringContext { return s.p func (s *ShowFailPointStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowFailPointStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowFailPointStatementContext) FAILPOINTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFAILPOINTS, 0) + return s.GetToken(StarRocksSQLParserFAILPOINTS, 0) } func (s *ShowFailPointStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *ShowFailPointStatementContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *ShowFailPointStatementContext) AllString_() []IStringContext { @@ -37556,7 +37556,7 @@ func (s *ShowFailPointStatementContext) String_(i int) IStringContext { } func (s *ShowFailPointStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowFailPointStatementContext) GetRuleContext() antlr.RuleContext { @@ -37568,20 +37568,20 @@ func (s *ShowFailPointStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowFailPointStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowFailPointStatement(s) } } func (s *ShowFailPointStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowFailPointStatement(s) } } func (s *ShowFailPointStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowFailPointStatement(s) default: @@ -37589,15 +37589,15 @@ func (s *ShowFailPointStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowFailPointStatement() (localctx IShowFailPointStatementContext) { +func (p *StarRocksSQLParser) ShowFailPointStatement() (localctx IShowFailPointStatementContext) { localctx = NewShowFailPointStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 214, DorisSQLParserRULE_showFailPointStatement) + p.EnterRule(localctx, 214, StarRocksSQLParserRULE_showFailPointStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2652) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37605,7 +37605,7 @@ func (p *DorisSQLParser) ShowFailPointStatement() (localctx IShowFailPointStatem } { p.SetState(2653) - p.Match(DorisSQLParserFAILPOINTS) + p.Match(StarRocksSQLParserFAILPOINTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37618,10 +37618,10 @@ func (p *DorisSQLParser) ShowFailPointStatement() (localctx IShowFailPointStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(2654) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37643,10 +37643,10 @@ func (p *DorisSQLParser) ShowFailPointStatement() (localctx IShowFailPointStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserON { + if _la == StarRocksSQLParserON { { p.SetState(2658) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37654,7 +37654,7 @@ func (p *DorisSQLParser) ShowFailPointStatement() (localctx IShowFailPointStatem } { p.SetState(2659) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37709,13 +37709,13 @@ type CreateDictionaryStatementContext struct { func NewEmptyCreateDictionaryStatementContext() *CreateDictionaryStatementContext { var p = new(CreateDictionaryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_createDictionaryStatement return p } func InitEmptyCreateDictionaryStatementContext(p *CreateDictionaryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_createDictionaryStatement } func (*CreateDictionaryStatementContext) IsCreateDictionaryStatementContext() {} @@ -37726,7 +37726,7 @@ func NewCreateDictionaryStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_createDictionaryStatement return p } @@ -37734,11 +37734,11 @@ func NewCreateDictionaryStatementContext(parser antlr.Parser, parent antlr.Parse func (s *CreateDictionaryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateDictionaryStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateDictionaryStatementContext) DICTIONARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY, 0) } func (s *CreateDictionaryStatementContext) DictionaryName() IDictionaryNameContext { @@ -37758,7 +37758,7 @@ func (s *CreateDictionaryStatementContext) DictionaryName() IDictionaryNameConte } func (s *CreateDictionaryStatementContext) USING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSING, 0) + return s.GetToken(StarRocksSQLParserUSING, 0) } func (s *CreateDictionaryStatementContext) QualifiedName() IQualifiedNameContext { @@ -37843,20 +37843,20 @@ func (s *CreateDictionaryStatementContext) ToStringTree(ruleNames []string, reco } func (s *CreateDictionaryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateDictionaryStatement(s) } } func (s *CreateDictionaryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateDictionaryStatement(s) } } func (s *CreateDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateDictionaryStatement(s) default: @@ -37864,15 +37864,15 @@ func (s *CreateDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionaryStatementContext) { +func (p *StarRocksSQLParser) CreateDictionaryStatement() (localctx ICreateDictionaryStatementContext) { localctx = NewCreateDictionaryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 216, DorisSQLParserRULE_createDictionaryStatement) + p.EnterRule(localctx, 216, StarRocksSQLParserRULE_createDictionaryStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2663) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37880,7 +37880,7 @@ func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionary } { p.SetState(2664) - p.Match(DorisSQLParserDICTIONARY) + p.Match(StarRocksSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37892,7 +37892,7 @@ func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionary } { p.SetState(2666) - p.Match(DorisSQLParserUSING) + p.Match(StarRocksSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37904,7 +37904,7 @@ func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionary } { p.SetState(2668) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37921,10 +37921,10 @@ func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionary } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2670) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37944,7 +37944,7 @@ func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionary } { p.SetState(2677) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -37957,7 +37957,7 @@ func (p *DorisSQLParser) CreateDictionaryStatement() (localctx ICreateDictionary } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(2678) p.Properties() @@ -38003,13 +38003,13 @@ type DropDictionaryStatementContext struct { func NewEmptyDropDictionaryStatementContext() *DropDictionaryStatementContext { var p = new(DropDictionaryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDictionaryStatement return p } func InitEmptyDropDictionaryStatementContext(p *DropDictionaryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDictionaryStatement } func (*DropDictionaryStatementContext) IsDropDictionaryStatementContext() {} @@ -38020,7 +38020,7 @@ func NewDropDictionaryStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDictionaryStatement return p } @@ -38028,11 +38028,11 @@ func NewDropDictionaryStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *DropDictionaryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropDictionaryStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropDictionaryStatementContext) DICTIONARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY, 0) } func (s *DropDictionaryStatementContext) QualifiedName() IQualifiedNameContext { @@ -38052,7 +38052,7 @@ func (s *DropDictionaryStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropDictionaryStatementContext) CACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCACHE, 0) + return s.GetToken(StarRocksSQLParserCACHE, 0) } func (s *DropDictionaryStatementContext) GetRuleContext() antlr.RuleContext { @@ -38064,20 +38064,20 @@ func (s *DropDictionaryStatementContext) ToStringTree(ruleNames []string, recog } func (s *DropDictionaryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropDictionaryStatement(s) } } func (s *DropDictionaryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropDictionaryStatement(s) } } func (s *DropDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropDictionaryStatement(s) default: @@ -38085,15 +38085,15 @@ func (s *DropDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) DropDictionaryStatement() (localctx IDropDictionaryStatementContext) { +func (p *StarRocksSQLParser) DropDictionaryStatement() (localctx IDropDictionaryStatementContext) { localctx = NewDropDictionaryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 218, DorisSQLParserRULE_dropDictionaryStatement) + p.EnterRule(localctx, 218, StarRocksSQLParserRULE_dropDictionaryStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2681) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38101,7 +38101,7 @@ func (p *DorisSQLParser) DropDictionaryStatement() (localctx IDropDictionaryStat } { p.SetState(2682) - p.Match(DorisSQLParserDICTIONARY) + p.Match(StarRocksSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38118,10 +38118,10 @@ func (p *DorisSQLParser) DropDictionaryStatement() (localctx IDropDictionaryStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCACHE { + if _la == StarRocksSQLParserCACHE { { p.SetState(2684) - p.Match(DorisSQLParserCACHE) + p.Match(StarRocksSQLParserCACHE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38167,13 +38167,13 @@ type RefreshDictionaryStatementContext struct { func NewEmptyRefreshDictionaryStatementContext() *RefreshDictionaryStatementContext { var p = new(RefreshDictionaryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshDictionaryStatement return p } func InitEmptyRefreshDictionaryStatementContext(p *RefreshDictionaryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshDictionaryStatement } func (*RefreshDictionaryStatementContext) IsRefreshDictionaryStatementContext() {} @@ -38184,7 +38184,7 @@ func NewRefreshDictionaryStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_refreshDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_refreshDictionaryStatement return p } @@ -38192,11 +38192,11 @@ func NewRefreshDictionaryStatementContext(parser antlr.Parser, parent antlr.Pars func (s *RefreshDictionaryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *RefreshDictionaryStatementContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *RefreshDictionaryStatementContext) DICTIONARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY, 0) } func (s *RefreshDictionaryStatementContext) QualifiedName() IQualifiedNameContext { @@ -38224,20 +38224,20 @@ func (s *RefreshDictionaryStatementContext) ToStringTree(ruleNames []string, rec } func (s *RefreshDictionaryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRefreshDictionaryStatement(s) } } func (s *RefreshDictionaryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRefreshDictionaryStatement(s) } } func (s *RefreshDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRefreshDictionaryStatement(s) default: @@ -38245,13 +38245,13 @@ func (s *RefreshDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) RefreshDictionaryStatement() (localctx IRefreshDictionaryStatementContext) { +func (p *StarRocksSQLParser) RefreshDictionaryStatement() (localctx IRefreshDictionaryStatementContext) { localctx = NewRefreshDictionaryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 220, DorisSQLParserRULE_refreshDictionaryStatement) + p.EnterRule(localctx, 220, StarRocksSQLParserRULE_refreshDictionaryStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2687) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38259,7 +38259,7 @@ func (p *DorisSQLParser) RefreshDictionaryStatement() (localctx IRefreshDictiona } { p.SetState(2688) - p.Match(DorisSQLParserDICTIONARY) + p.Match(StarRocksSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38307,13 +38307,13 @@ type ShowDictionaryStatementContext struct { func NewEmptyShowDictionaryStatementContext() *ShowDictionaryStatementContext { var p = new(ShowDictionaryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_showDictionaryStatement return p } func InitEmptyShowDictionaryStatementContext(p *ShowDictionaryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_showDictionaryStatement } func (*ShowDictionaryStatementContext) IsShowDictionaryStatementContext() {} @@ -38324,7 +38324,7 @@ func NewShowDictionaryStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_showDictionaryStatement return p } @@ -38332,11 +38332,11 @@ func NewShowDictionaryStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowDictionaryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDictionaryStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDictionaryStatementContext) DICTIONARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY, 0) } func (s *ShowDictionaryStatementContext) QualifiedName() IQualifiedNameContext { @@ -38364,20 +38364,20 @@ func (s *ShowDictionaryStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowDictionaryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDictionaryStatement(s) } } func (s *ShowDictionaryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDictionaryStatement(s) } } func (s *ShowDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDictionaryStatement(s) default: @@ -38385,15 +38385,15 @@ func (s *ShowDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowDictionaryStatement() (localctx IShowDictionaryStatementContext) { +func (p *StarRocksSQLParser) ShowDictionaryStatement() (localctx IShowDictionaryStatementContext) { localctx = NewShowDictionaryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 222, DorisSQLParserRULE_showDictionaryStatement) + p.EnterRule(localctx, 222, StarRocksSQLParserRULE_showDictionaryStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2691) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38401,7 +38401,7 @@ func (p *DorisSQLParser) ShowDictionaryStatement() (localctx IShowDictionaryStat } { p.SetState(2692) - p.Match(DorisSQLParserDICTIONARY) + p.Match(StarRocksSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38460,13 +38460,13 @@ type CancelRefreshDictionaryStatementContext struct { func NewEmptyCancelRefreshDictionaryStatementContext() *CancelRefreshDictionaryStatementContext { var p = new(CancelRefreshDictionaryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelRefreshDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRefreshDictionaryStatement return p } func InitEmptyCancelRefreshDictionaryStatementContext(p *CancelRefreshDictionaryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelRefreshDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRefreshDictionaryStatement } func (*CancelRefreshDictionaryStatementContext) IsCancelRefreshDictionaryStatementContext() {} @@ -38477,7 +38477,7 @@ func NewCancelRefreshDictionaryStatementContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelRefreshDictionaryStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRefreshDictionaryStatement return p } @@ -38485,15 +38485,15 @@ func NewCancelRefreshDictionaryStatementContext(parser antlr.Parser, parent antl func (s *CancelRefreshDictionaryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelRefreshDictionaryStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelRefreshDictionaryStatementContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *CancelRefreshDictionaryStatementContext) DICTIONARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY, 0) } func (s *CancelRefreshDictionaryStatementContext) QualifiedName() IQualifiedNameContext { @@ -38521,20 +38521,20 @@ func (s *CancelRefreshDictionaryStatementContext) ToStringTree(ruleNames []strin } func (s *CancelRefreshDictionaryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelRefreshDictionaryStatement(s) } } func (s *CancelRefreshDictionaryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelRefreshDictionaryStatement(s) } } func (s *CancelRefreshDictionaryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelRefreshDictionaryStatement(s) default: @@ -38542,13 +38542,13 @@ func (s *CancelRefreshDictionaryStatementContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) CancelRefreshDictionaryStatement() (localctx ICancelRefreshDictionaryStatementContext) { +func (p *StarRocksSQLParser) CancelRefreshDictionaryStatement() (localctx ICancelRefreshDictionaryStatementContext) { localctx = NewCancelRefreshDictionaryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 224, DorisSQLParserRULE_cancelRefreshDictionaryStatement) + p.EnterRule(localctx, 224, StarRocksSQLParserRULE_cancelRefreshDictionaryStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(2696) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38556,7 +38556,7 @@ func (p *DorisSQLParser) CancelRefreshDictionaryStatement() (localctx ICancelRef } { p.SetState(2697) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38564,7 +38564,7 @@ func (p *DorisSQLParser) CancelRefreshDictionaryStatement() (localctx ICancelRef } { p.SetState(2698) - p.Match(DorisSQLParserDICTIONARY) + p.Match(StarRocksSQLParserDICTIONARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38612,13 +38612,13 @@ type DictionaryColumnDescContext struct { func NewEmptyDictionaryColumnDescContext() *DictionaryColumnDescContext { var p = new(DictionaryColumnDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dictionaryColumnDesc + p.RuleIndex = StarRocksSQLParserRULE_dictionaryColumnDesc return p } func InitEmptyDictionaryColumnDescContext(p *DictionaryColumnDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dictionaryColumnDesc + p.RuleIndex = StarRocksSQLParserRULE_dictionaryColumnDesc } func (*DictionaryColumnDescContext) IsDictionaryColumnDescContext() {} @@ -38629,7 +38629,7 @@ func NewDictionaryColumnDescContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dictionaryColumnDesc + p.RuleIndex = StarRocksSQLParserRULE_dictionaryColumnDesc return p } @@ -38653,11 +38653,11 @@ func (s *DictionaryColumnDescContext) QualifiedName() IQualifiedNameContext { } func (s *DictionaryColumnDescContext) KEY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEY, 0) + return s.GetToken(StarRocksSQLParserKEY, 0) } func (s *DictionaryColumnDescContext) VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUE, 0) + return s.GetToken(StarRocksSQLParserVALUE, 0) } func (s *DictionaryColumnDescContext) GetRuleContext() antlr.RuleContext { @@ -38669,20 +38669,20 @@ func (s *DictionaryColumnDescContext) ToStringTree(ruleNames []string, recog ant } func (s *DictionaryColumnDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDictionaryColumnDesc(s) } } func (s *DictionaryColumnDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDictionaryColumnDesc(s) } } func (s *DictionaryColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDictionaryColumnDesc(s) default: @@ -38690,9 +38690,9 @@ func (s *DictionaryColumnDescContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) DictionaryColumnDesc() (localctx IDictionaryColumnDescContext) { +func (p *StarRocksSQLParser) DictionaryColumnDesc() (localctx IDictionaryColumnDescContext) { localctx = NewDictionaryColumnDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 226, DorisSQLParserRULE_dictionaryColumnDesc) + p.EnterRule(localctx, 226, StarRocksSQLParserRULE_dictionaryColumnDesc) p.SetState(2707) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -38708,7 +38708,7 @@ func (p *DorisSQLParser) DictionaryColumnDesc() (localctx IDictionaryColumnDescC } { p.SetState(2702) - p.Match(DorisSQLParserKEY) + p.Match(StarRocksSQLParserKEY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38723,7 +38723,7 @@ func (p *DorisSQLParser) DictionaryColumnDesc() (localctx IDictionaryColumnDescC } { p.SetState(2705) - p.Match(DorisSQLParserVALUE) + p.Match(StarRocksSQLParserVALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -38769,13 +38769,13 @@ type DictionaryNameContext struct { func NewEmptyDictionaryNameContext() *DictionaryNameContext { var p = new(DictionaryNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dictionaryName + p.RuleIndex = StarRocksSQLParserRULE_dictionaryName return p } func InitEmptyDictionaryNameContext(p *DictionaryNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dictionaryName + p.RuleIndex = StarRocksSQLParserRULE_dictionaryName } func (*DictionaryNameContext) IsDictionaryNameContext() {} @@ -38786,7 +38786,7 @@ func NewDictionaryNameContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dictionaryName + p.RuleIndex = StarRocksSQLParserRULE_dictionaryName return p } @@ -38818,20 +38818,20 @@ func (s *DictionaryNameContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *DictionaryNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDictionaryName(s) } } func (s *DictionaryNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDictionaryName(s) } } func (s *DictionaryNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDictionaryName(s) default: @@ -38839,9 +38839,9 @@ func (s *DictionaryNameContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) DictionaryName() (localctx IDictionaryNameContext) { +func (p *StarRocksSQLParser) DictionaryName() (localctx IDictionaryNameContext) { localctx = NewDictionaryNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 228, DorisSQLParserRULE_dictionaryName) + p.EnterRule(localctx, 228, StarRocksSQLParserRULE_dictionaryName) p.EnterOuterAlt(localctx, 1) { p.SetState(2709) @@ -38930,13 +38930,13 @@ type AlterClauseContext struct { func NewEmptyAlterClauseContext() *AlterClauseContext { var p = new(AlterClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterClause + p.RuleIndex = StarRocksSQLParserRULE_alterClause return p } func InitEmptyAlterClauseContext(p *AlterClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterClause + p.RuleIndex = StarRocksSQLParserRULE_alterClause } func (*AlterClauseContext) IsAlterClauseContext() {} @@ -38947,7 +38947,7 @@ func NewAlterClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterClause + p.RuleIndex = StarRocksSQLParserRULE_alterClause return p } @@ -39731,20 +39731,20 @@ func (s *AlterClauseContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *AlterClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterClause(s) } } func (s *AlterClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterClause(s) } } func (s *AlterClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterClause(s) default: @@ -39752,9 +39752,9 @@ func (s *AlterClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) AlterClause() (localctx IAlterClauseContext) { +func (p *StarRocksSQLParser) AlterClause() (localctx IAlterClauseContext) { localctx = NewAlterClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 230, DorisSQLParserRULE_alterClause) + p.EnterRule(localctx, 230, StarRocksSQLParserRULE_alterClause) p.SetState(2759) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -40140,13 +40140,13 @@ type AddFrontendClauseContext struct { func NewEmptyAddFrontendClauseContext() *AddFrontendClauseContext { var p = new(AddFrontendClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addFrontendClause + p.RuleIndex = StarRocksSQLParserRULE_addFrontendClause return p } func InitEmptyAddFrontendClauseContext(p *AddFrontendClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addFrontendClause + p.RuleIndex = StarRocksSQLParserRULE_addFrontendClause } func (*AddFrontendClauseContext) IsAddFrontendClauseContext() {} @@ -40157,7 +40157,7 @@ func NewAddFrontendClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addFrontendClause + p.RuleIndex = StarRocksSQLParserRULE_addFrontendClause return p } @@ -40165,7 +40165,7 @@ func NewAddFrontendClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *AddFrontendClauseContext) GetParser() antlr.Parser { return s.parser } func (s *AddFrontendClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddFrontendClauseContext) String_() IStringContext { @@ -40185,11 +40185,11 @@ func (s *AddFrontendClauseContext) String_() IStringContext { } func (s *AddFrontendClauseContext) FOLLOWER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOLLOWER, 0) + return s.GetToken(StarRocksSQLParserFOLLOWER, 0) } func (s *AddFrontendClauseContext) OBSERVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOBSERVER, 0) + return s.GetToken(StarRocksSQLParserOBSERVER, 0) } func (s *AddFrontendClauseContext) GetRuleContext() antlr.RuleContext { @@ -40201,20 +40201,20 @@ func (s *AddFrontendClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *AddFrontendClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddFrontendClause(s) } } func (s *AddFrontendClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddFrontendClause(s) } } func (s *AddFrontendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddFrontendClause(s) default: @@ -40222,15 +40222,15 @@ func (s *AddFrontendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) AddFrontendClause() (localctx IAddFrontendClauseContext) { +func (p *StarRocksSQLParser) AddFrontendClause() (localctx IAddFrontendClauseContext) { localctx = NewAddFrontendClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 232, DorisSQLParserRULE_addFrontendClause) + p.EnterRule(localctx, 232, StarRocksSQLParserRULE_addFrontendClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2761) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40240,7 +40240,7 @@ func (p *DorisSQLParser) AddFrontendClause() (localctx IAddFrontendClauseContext p.SetState(2762) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFOLLOWER || _la == DorisSQLParserOBSERVER) { + if !(_la == StarRocksSQLParserFOLLOWER || _la == StarRocksSQLParserOBSERVER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -40290,13 +40290,13 @@ type DropFrontendClauseContext struct { func NewEmptyDropFrontendClauseContext() *DropFrontendClauseContext { var p = new(DropFrontendClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFrontendClause + p.RuleIndex = StarRocksSQLParserRULE_dropFrontendClause return p } func InitEmptyDropFrontendClauseContext(p *DropFrontendClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFrontendClause + p.RuleIndex = StarRocksSQLParserRULE_dropFrontendClause } func (*DropFrontendClauseContext) IsDropFrontendClauseContext() {} @@ -40307,7 +40307,7 @@ func NewDropFrontendClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropFrontendClause + p.RuleIndex = StarRocksSQLParserRULE_dropFrontendClause return p } @@ -40315,7 +40315,7 @@ func NewDropFrontendClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *DropFrontendClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DropFrontendClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropFrontendClauseContext) String_() IStringContext { @@ -40335,11 +40335,11 @@ func (s *DropFrontendClauseContext) String_() IStringContext { } func (s *DropFrontendClauseContext) FOLLOWER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOLLOWER, 0) + return s.GetToken(StarRocksSQLParserFOLLOWER, 0) } func (s *DropFrontendClauseContext) OBSERVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOBSERVER, 0) + return s.GetToken(StarRocksSQLParserOBSERVER, 0) } func (s *DropFrontendClauseContext) GetRuleContext() antlr.RuleContext { @@ -40351,20 +40351,20 @@ func (s *DropFrontendClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *DropFrontendClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropFrontendClause(s) } } func (s *DropFrontendClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropFrontendClause(s) } } func (s *DropFrontendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropFrontendClause(s) default: @@ -40372,15 +40372,15 @@ func (s *DropFrontendClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) DropFrontendClause() (localctx IDropFrontendClauseContext) { +func (p *StarRocksSQLParser) DropFrontendClause() (localctx IDropFrontendClauseContext) { localctx = NewDropFrontendClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 234, DorisSQLParserRULE_dropFrontendClause) + p.EnterRule(localctx, 234, StarRocksSQLParserRULE_dropFrontendClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2765) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40390,7 +40390,7 @@ func (p *DorisSQLParser) DropFrontendClause() (localctx IDropFrontendClauseConte p.SetState(2766) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFOLLOWER || _la == DorisSQLParserOBSERVER) { + if !(_la == StarRocksSQLParserFOLLOWER || _la == StarRocksSQLParserOBSERVER) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -40442,13 +40442,13 @@ type ModifyFrontendHostClauseContext struct { func NewEmptyModifyFrontendHostClauseContext() *ModifyFrontendHostClauseContext { var p = new(ModifyFrontendHostClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyFrontendHostClause + p.RuleIndex = StarRocksSQLParserRULE_modifyFrontendHostClause return p } func InitEmptyModifyFrontendHostClauseContext(p *ModifyFrontendHostClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyFrontendHostClause + p.RuleIndex = StarRocksSQLParserRULE_modifyFrontendHostClause } func (*ModifyFrontendHostClauseContext) IsModifyFrontendHostClauseContext() {} @@ -40459,7 +40459,7 @@ func NewModifyFrontendHostClauseContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyFrontendHostClause + p.RuleIndex = StarRocksSQLParserRULE_modifyFrontendHostClause return p } @@ -40467,15 +40467,15 @@ func NewModifyFrontendHostClauseContext(parser antlr.Parser, parent antlr.Parser func (s *ModifyFrontendHostClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyFrontendHostClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *ModifyFrontendHostClauseContext) FRONTEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTEND, 0) + return s.GetToken(StarRocksSQLParserFRONTEND, 0) } func (s *ModifyFrontendHostClauseContext) HOST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOST, 0) + return s.GetToken(StarRocksSQLParserHOST, 0) } func (s *ModifyFrontendHostClauseContext) AllString_() []IStringContext { @@ -40520,7 +40520,7 @@ func (s *ModifyFrontendHostClauseContext) String_(i int) IStringContext { } func (s *ModifyFrontendHostClauseContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *ModifyFrontendHostClauseContext) GetRuleContext() antlr.RuleContext { @@ -40532,20 +40532,20 @@ func (s *ModifyFrontendHostClauseContext) ToStringTree(ruleNames []string, recog } func (s *ModifyFrontendHostClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyFrontendHostClause(s) } } func (s *ModifyFrontendHostClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyFrontendHostClause(s) } } func (s *ModifyFrontendHostClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyFrontendHostClause(s) default: @@ -40553,13 +40553,13 @@ func (s *ModifyFrontendHostClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ModifyFrontendHostClause() (localctx IModifyFrontendHostClauseContext) { +func (p *StarRocksSQLParser) ModifyFrontendHostClause() (localctx IModifyFrontendHostClauseContext) { localctx = NewModifyFrontendHostClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 236, DorisSQLParserRULE_modifyFrontendHostClause) + p.EnterRule(localctx, 236, StarRocksSQLParserRULE_modifyFrontendHostClause) p.EnterOuterAlt(localctx, 1) { p.SetState(2769) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40567,7 +40567,7 @@ func (p *DorisSQLParser) ModifyFrontendHostClause() (localctx IModifyFrontendHos } { p.SetState(2770) - p.Match(DorisSQLParserFRONTEND) + p.Match(StarRocksSQLParserFRONTEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40575,7 +40575,7 @@ func (p *DorisSQLParser) ModifyFrontendHostClause() (localctx IModifyFrontendHos } { p.SetState(2771) - p.Match(DorisSQLParserHOST) + p.Match(StarRocksSQLParserHOST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40587,7 +40587,7 @@ func (p *DorisSQLParser) ModifyFrontendHostClause() (localctx IModifyFrontendHos } { p.SetState(2773) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40655,13 +40655,13 @@ type AddBackendClauseContext struct { func NewEmptyAddBackendClauseContext() *AddBackendClauseContext { var p = new(AddBackendClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addBackendClause + p.RuleIndex = StarRocksSQLParserRULE_addBackendClause return p } func InitEmptyAddBackendClauseContext(p *AddBackendClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addBackendClause + p.RuleIndex = StarRocksSQLParserRULE_addBackendClause } func (*AddBackendClauseContext) IsAddBackendClauseContext() {} @@ -40672,7 +40672,7 @@ func NewAddBackendClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addBackendClause + p.RuleIndex = StarRocksSQLParserRULE_addBackendClause return p } @@ -40690,11 +40690,11 @@ func (s *AddBackendClauseContext) SetWarehouseName(v IIdentifierOrStringContext) func (s *AddBackendClauseContext) SetCngroupName(v IIdentifierOrStringContext) { s.cngroupName = v } func (s *AddBackendClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddBackendClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *AddBackendClauseContext) AllString_() []IStringContext { @@ -40739,11 +40739,11 @@ func (s *AddBackendClauseContext) String_(i int) IStringContext { } func (s *AddBackendClauseContext) INTO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTO, 0) + return s.GetToken(StarRocksSQLParserINTO, 0) } func (s *AddBackendClauseContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *AddBackendClauseContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -40788,7 +40788,7 @@ func (s *AddBackendClauseContext) IdentifierOrString(i int) IIdentifierOrStringC } func (s *AddBackendClauseContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *AddBackendClauseContext) GetRuleContext() antlr.RuleContext { @@ -40800,20 +40800,20 @@ func (s *AddBackendClauseContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *AddBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddBackendClause(s) } } func (s *AddBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddBackendClause(s) } } func (s *AddBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddBackendClause(s) default: @@ -40821,9 +40821,9 @@ func (s *AddBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) { +func (p *StarRocksSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) { localctx = NewAddBackendClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 238, DorisSQLParserRULE_addBackendClause) + p.EnterRule(localctx, 238, StarRocksSQLParserRULE_addBackendClause) var _la int var _alt int @@ -40831,7 +40831,7 @@ func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) p.EnterOuterAlt(localctx, 1) { p.SetState(2776) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40839,7 +40839,7 @@ func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) } { p.SetState(2777) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40862,7 +40862,7 @@ func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) if _alt == 1 { { p.SetState(2779) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40891,10 +40891,10 @@ func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTO { + if _la == StarRocksSQLParserINTO { { p.SetState(2786) - p.Match(DorisSQLParserINTO) + p.Match(StarRocksSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40902,7 +40902,7 @@ func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) } { p.SetState(2787) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -40922,10 +40922,10 @@ func (p *DorisSQLParser) AddBackendClause() (localctx IAddBackendClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCNGROUP { + if _la == StarRocksSQLParserCNGROUP { { p.SetState(2789) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41001,13 +41001,13 @@ type DropBackendClauseContext struct { func NewEmptyDropBackendClauseContext() *DropBackendClauseContext { var p = new(DropBackendClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropBackendClause + p.RuleIndex = StarRocksSQLParserRULE_dropBackendClause return p } func InitEmptyDropBackendClauseContext(p *DropBackendClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropBackendClause + p.RuleIndex = StarRocksSQLParserRULE_dropBackendClause } func (*DropBackendClauseContext) IsDropBackendClauseContext() {} @@ -41018,7 +41018,7 @@ func NewDropBackendClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropBackendClause + p.RuleIndex = StarRocksSQLParserRULE_dropBackendClause return p } @@ -41038,11 +41038,11 @@ func (s *DropBackendClauseContext) SetWarehouseName(v IIdentifierOrStringContext func (s *DropBackendClauseContext) SetCngroupName(v IIdentifierOrStringContext) { s.cngroupName = v } func (s *DropBackendClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropBackendClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *DropBackendClauseContext) AllString_() []IStringContext { @@ -41087,15 +41087,15 @@ func (s *DropBackendClauseContext) String_(i int) IStringContext { } func (s *DropBackendClauseContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DropBackendClauseContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *DropBackendClauseContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *DropBackendClauseContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -41140,7 +41140,7 @@ func (s *DropBackendClauseContext) IdentifierOrString(i int) IIdentifierOrString } func (s *DropBackendClauseContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *DropBackendClauseContext) GetRuleContext() antlr.RuleContext { @@ -41152,20 +41152,20 @@ func (s *DropBackendClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropBackendClause(s) } } func (s *DropBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropBackendClause(s) } } func (s *DropBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropBackendClause(s) default: @@ -41173,9 +41173,9 @@ func (s *DropBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext) { +func (p *StarRocksSQLParser) DropBackendClause() (localctx IDropBackendClauseContext) { localctx = NewDropBackendClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 240, DorisSQLParserRULE_dropBackendClause) + p.EnterRule(localctx, 240, StarRocksSQLParserRULE_dropBackendClause) var _la int var _alt int @@ -41183,7 +41183,7 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext p.EnterOuterAlt(localctx, 1) { p.SetState(2795) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41191,7 +41191,7 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext } { p.SetState(2796) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41214,7 +41214,7 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext if _alt == 1 { { p.SetState(2798) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41243,10 +41243,10 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(2805) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41254,7 +41254,7 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext } { p.SetState(2806) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41274,10 +41274,10 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCNGROUP { + if _la == StarRocksSQLParserCNGROUP { { p.SetState(2808) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41301,10 +41301,10 @@ func (p *DorisSQLParser) DropBackendClause() (localctx IDropBackendClauseContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(2814) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41351,13 +41351,13 @@ type DecommissionBackendClauseContext struct { func NewEmptyDecommissionBackendClauseContext() *DecommissionBackendClauseContext { var p = new(DecommissionBackendClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_decommissionBackendClause + p.RuleIndex = StarRocksSQLParserRULE_decommissionBackendClause return p } func InitEmptyDecommissionBackendClauseContext(p *DecommissionBackendClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_decommissionBackendClause + p.RuleIndex = StarRocksSQLParserRULE_decommissionBackendClause } func (*DecommissionBackendClauseContext) IsDecommissionBackendClauseContext() {} @@ -41368,7 +41368,7 @@ func NewDecommissionBackendClauseContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_decommissionBackendClause + p.RuleIndex = StarRocksSQLParserRULE_decommissionBackendClause return p } @@ -41376,11 +41376,11 @@ func NewDecommissionBackendClauseContext(parser antlr.Parser, parent antlr.Parse func (s *DecommissionBackendClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DecommissionBackendClauseContext) DECOMMISSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECOMMISSION, 0) + return s.GetToken(StarRocksSQLParserDECOMMISSION, 0) } func (s *DecommissionBackendClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *DecommissionBackendClauseContext) AllString_() []IStringContext { @@ -41433,20 +41433,20 @@ func (s *DecommissionBackendClauseContext) ToStringTree(ruleNames []string, reco } func (s *DecommissionBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDecommissionBackendClause(s) } } func (s *DecommissionBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDecommissionBackendClause(s) } } func (s *DecommissionBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDecommissionBackendClause(s) default: @@ -41454,15 +41454,15 @@ func (s *DecommissionBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) DecommissionBackendClause() (localctx IDecommissionBackendClauseContext) { +func (p *StarRocksSQLParser) DecommissionBackendClause() (localctx IDecommissionBackendClauseContext) { localctx = NewDecommissionBackendClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 242, DorisSQLParserRULE_decommissionBackendClause) + p.EnterRule(localctx, 242, StarRocksSQLParserRULE_decommissionBackendClause) var _alt int p.EnterOuterAlt(localctx, 1) { p.SetState(2817) - p.Match(DorisSQLParserDECOMMISSION) + p.Match(StarRocksSQLParserDECOMMISSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41470,7 +41470,7 @@ func (p *DorisSQLParser) DecommissionBackendClause() (localctx IDecommissionBack } { p.SetState(2818) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41493,7 +41493,7 @@ func (p *DorisSQLParser) DecommissionBackendClause() (localctx IDecommissionBack if _alt == 1 { { p.SetState(2820) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41558,13 +41558,13 @@ type ModifyBackendClauseContext struct { func NewEmptyModifyBackendClauseContext() *ModifyBackendClauseContext { var p = new(ModifyBackendClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyBackendClause + p.RuleIndex = StarRocksSQLParserRULE_modifyBackendClause return p } func InitEmptyModifyBackendClauseContext(p *ModifyBackendClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyBackendClause + p.RuleIndex = StarRocksSQLParserRULE_modifyBackendClause } func (*ModifyBackendClauseContext) IsModifyBackendClauseContext() {} @@ -41575,7 +41575,7 @@ func NewModifyBackendClauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyBackendClause + p.RuleIndex = StarRocksSQLParserRULE_modifyBackendClause return p } @@ -41583,15 +41583,15 @@ func NewModifyBackendClauseContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ModifyBackendClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyBackendClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *ModifyBackendClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *ModifyBackendClauseContext) HOST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOST, 0) + return s.GetToken(StarRocksSQLParserHOST, 0) } func (s *ModifyBackendClauseContext) AllString_() []IStringContext { @@ -41636,11 +41636,11 @@ func (s *ModifyBackendClauseContext) String_(i int) IStringContext { } func (s *ModifyBackendClauseContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *ModifyBackendClauseContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *ModifyBackendClauseContext) PropertyList() IPropertyListContext { @@ -41668,20 +41668,20 @@ func (s *ModifyBackendClauseContext) ToStringTree(ruleNames []string, recog antl } func (s *ModifyBackendClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyBackendClause(s) } } func (s *ModifyBackendClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyBackendClause(s) } } func (s *ModifyBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyBackendClause(s) default: @@ -41689,9 +41689,9 @@ func (s *ModifyBackendClauseContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseContext) { +func (p *StarRocksSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseContext) { localctx = NewModifyBackendClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 244, DorisSQLParserRULE_modifyBackendClause) + p.EnterRule(localctx, 244, StarRocksSQLParserRULE_modifyBackendClause) p.SetState(2840) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -41703,7 +41703,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon p.EnterOuterAlt(localctx, 1) { p.SetState(2827) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41711,7 +41711,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon } { p.SetState(2828) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41719,7 +41719,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon } { p.SetState(2829) - p.Match(DorisSQLParserHOST) + p.Match(StarRocksSQLParserHOST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41731,7 +41731,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon } { p.SetState(2831) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41746,7 +41746,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon p.EnterOuterAlt(localctx, 2) { p.SetState(2834) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41754,7 +41754,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon } { p.SetState(2835) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41766,7 +41766,7 @@ func (p *DorisSQLParser) ModifyBackendClause() (localctx IModifyBackendClauseCon } { p.SetState(2837) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -41839,13 +41839,13 @@ type AddComputeNodeClauseContext struct { func NewEmptyAddComputeNodeClauseContext() *AddComputeNodeClauseContext { var p = new(AddComputeNodeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addComputeNodeClause + p.RuleIndex = StarRocksSQLParserRULE_addComputeNodeClause return p } func InitEmptyAddComputeNodeClauseContext(p *AddComputeNodeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addComputeNodeClause + p.RuleIndex = StarRocksSQLParserRULE_addComputeNodeClause } func (*AddComputeNodeClauseContext) IsAddComputeNodeClauseContext() {} @@ -41856,7 +41856,7 @@ func NewAddComputeNodeClauseContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addComputeNodeClause + p.RuleIndex = StarRocksSQLParserRULE_addComputeNodeClause return p } @@ -41878,15 +41878,15 @@ func (s *AddComputeNodeClauseContext) SetWarehouseName(v IIdentifierOrStringCont func (s *AddComputeNodeClauseContext) SetCngroupName(v IIdentifierOrStringContext) { s.cngroupName = v } func (s *AddComputeNodeClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddComputeNodeClauseContext) COMPUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPUTE, 0) + return s.GetToken(StarRocksSQLParserCOMPUTE, 0) } func (s *AddComputeNodeClauseContext) NODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODE, 0) + return s.GetToken(StarRocksSQLParserNODE, 0) } func (s *AddComputeNodeClauseContext) AllString_() []IStringContext { @@ -41931,11 +41931,11 @@ func (s *AddComputeNodeClauseContext) String_(i int) IStringContext { } func (s *AddComputeNodeClauseContext) INTO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTO, 0) + return s.GetToken(StarRocksSQLParserINTO, 0) } func (s *AddComputeNodeClauseContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *AddComputeNodeClauseContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -41980,7 +41980,7 @@ func (s *AddComputeNodeClauseContext) IdentifierOrString(i int) IIdentifierOrStr } func (s *AddComputeNodeClauseContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *AddComputeNodeClauseContext) GetRuleContext() antlr.RuleContext { @@ -41992,20 +41992,20 @@ func (s *AddComputeNodeClauseContext) ToStringTree(ruleNames []string, recog ant } func (s *AddComputeNodeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddComputeNodeClause(s) } } func (s *AddComputeNodeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddComputeNodeClause(s) } } func (s *AddComputeNodeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddComputeNodeClause(s) default: @@ -42013,9 +42013,9 @@ func (s *AddComputeNodeClauseContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseContext) { +func (p *StarRocksSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseContext) { localctx = NewAddComputeNodeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 246, DorisSQLParserRULE_addComputeNodeClause) + p.EnterRule(localctx, 246, StarRocksSQLParserRULE_addComputeNodeClause) var _la int var _alt int @@ -42023,7 +42023,7 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC p.EnterOuterAlt(localctx, 1) { p.SetState(2842) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42031,7 +42031,7 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC } { p.SetState(2843) - p.Match(DorisSQLParserCOMPUTE) + p.Match(StarRocksSQLParserCOMPUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42039,7 +42039,7 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC } { p.SetState(2844) - p.Match(DorisSQLParserNODE) + p.Match(StarRocksSQLParserNODE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42062,7 +42062,7 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC if _alt == 1 { { p.SetState(2846) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42091,10 +42091,10 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTO { + if _la == StarRocksSQLParserINTO { { p.SetState(2853) - p.Match(DorisSQLParserINTO) + p.Match(StarRocksSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42102,7 +42102,7 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC } { p.SetState(2854) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42122,10 +42122,10 @@ func (p *DorisSQLParser) AddComputeNodeClause() (localctx IAddComputeNodeClauseC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCNGROUP { + if _la == StarRocksSQLParserCNGROUP { { p.SetState(2856) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42201,13 +42201,13 @@ type DropComputeNodeClauseContext struct { func NewEmptyDropComputeNodeClauseContext() *DropComputeNodeClauseContext { var p = new(DropComputeNodeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropComputeNodeClause + p.RuleIndex = StarRocksSQLParserRULE_dropComputeNodeClause return p } func InitEmptyDropComputeNodeClauseContext(p *DropComputeNodeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropComputeNodeClause + p.RuleIndex = StarRocksSQLParserRULE_dropComputeNodeClause } func (*DropComputeNodeClauseContext) IsDropComputeNodeClauseContext() {} @@ -42218,7 +42218,7 @@ func NewDropComputeNodeClauseContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropComputeNodeClause + p.RuleIndex = StarRocksSQLParserRULE_dropComputeNodeClause return p } @@ -42242,15 +42242,15 @@ func (s *DropComputeNodeClauseContext) SetCngroupName(v IIdentifierOrStringConte } func (s *DropComputeNodeClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropComputeNodeClauseContext) COMPUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPUTE, 0) + return s.GetToken(StarRocksSQLParserCOMPUTE, 0) } func (s *DropComputeNodeClauseContext) NODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODE, 0) + return s.GetToken(StarRocksSQLParserNODE, 0) } func (s *DropComputeNodeClauseContext) AllString_() []IStringContext { @@ -42295,11 +42295,11 @@ func (s *DropComputeNodeClauseContext) String_(i int) IStringContext { } func (s *DropComputeNodeClauseContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DropComputeNodeClauseContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *DropComputeNodeClauseContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -42344,7 +42344,7 @@ func (s *DropComputeNodeClauseContext) IdentifierOrString(i int) IIdentifierOrSt } func (s *DropComputeNodeClauseContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *DropComputeNodeClauseContext) GetRuleContext() antlr.RuleContext { @@ -42356,20 +42356,20 @@ func (s *DropComputeNodeClauseContext) ToStringTree(ruleNames []string, recog an } func (s *DropComputeNodeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropComputeNodeClause(s) } } func (s *DropComputeNodeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropComputeNodeClause(s) } } func (s *DropComputeNodeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropComputeNodeClause(s) default: @@ -42377,9 +42377,9 @@ func (s *DropComputeNodeClauseContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClauseContext) { +func (p *StarRocksSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClauseContext) { localctx = NewDropComputeNodeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 248, DorisSQLParserRULE_dropComputeNodeClause) + p.EnterRule(localctx, 248, StarRocksSQLParserRULE_dropComputeNodeClause) var _la int var _alt int @@ -42387,7 +42387,7 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus p.EnterOuterAlt(localctx, 1) { p.SetState(2862) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42395,7 +42395,7 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus } { p.SetState(2863) - p.Match(DorisSQLParserCOMPUTE) + p.Match(StarRocksSQLParserCOMPUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42403,7 +42403,7 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus } { p.SetState(2864) - p.Match(DorisSQLParserNODE) + p.Match(StarRocksSQLParserNODE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42426,7 +42426,7 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus if _alt == 1 { { p.SetState(2866) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42455,10 +42455,10 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(2873) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42466,7 +42466,7 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus } { p.SetState(2874) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42486,10 +42486,10 @@ func (p *DorisSQLParser) DropComputeNodeClause() (localctx IDropComputeNodeClaus } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCNGROUP { + if _la == StarRocksSQLParserCNGROUP { { p.SetState(2876) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42548,13 +42548,13 @@ type ModifyBrokerClauseContext struct { func NewEmptyModifyBrokerClauseContext() *ModifyBrokerClauseContext { var p = new(ModifyBrokerClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyBrokerClause + p.RuleIndex = StarRocksSQLParserRULE_modifyBrokerClause return p } func InitEmptyModifyBrokerClauseContext(p *ModifyBrokerClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyBrokerClause + p.RuleIndex = StarRocksSQLParserRULE_modifyBrokerClause } func (*ModifyBrokerClauseContext) IsModifyBrokerClauseContext() {} @@ -42565,7 +42565,7 @@ func NewModifyBrokerClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyBrokerClause + p.RuleIndex = StarRocksSQLParserRULE_modifyBrokerClause return p } @@ -42573,11 +42573,11 @@ func NewModifyBrokerClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *ModifyBrokerClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyBrokerClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *ModifyBrokerClauseContext) BROKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBROKER, 0) + return s.GetToken(StarRocksSQLParserBROKER, 0) } func (s *ModifyBrokerClauseContext) IdentifierOrString() IIdentifierOrStringContext { @@ -42638,11 +42638,11 @@ func (s *ModifyBrokerClauseContext) String_(i int) IStringContext { } func (s *ModifyBrokerClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *ModifyBrokerClauseContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ModifyBrokerClauseContext) GetRuleContext() antlr.RuleContext { @@ -42654,20 +42654,20 @@ func (s *ModifyBrokerClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *ModifyBrokerClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyBrokerClause(s) } } func (s *ModifyBrokerClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyBrokerClause(s) } } func (s *ModifyBrokerClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyBrokerClause(s) default: @@ -42675,9 +42675,9 @@ func (s *ModifyBrokerClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseContext) { +func (p *StarRocksSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseContext) { localctx = NewModifyBrokerClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 250, DorisSQLParserRULE_modifyBrokerClause) + p.EnterRule(localctx, 250, StarRocksSQLParserRULE_modifyBrokerClause) var _alt int p.SetState(2908) @@ -42691,7 +42691,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte p.EnterOuterAlt(localctx, 1) { p.SetState(2882) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42699,7 +42699,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte } { p.SetState(2883) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42726,7 +42726,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte if _alt == 1 { { p.SetState(2886) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42753,7 +42753,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte p.EnterOuterAlt(localctx, 2) { p.SetState(2893) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42761,7 +42761,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte } { p.SetState(2894) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42788,7 +42788,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte if _alt == 1 { { p.SetState(2897) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42815,7 +42815,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte p.EnterOuterAlt(localctx, 3) { p.SetState(2904) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42823,7 +42823,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte } { p.SetState(2905) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42831,7 +42831,7 @@ func (p *DorisSQLParser) ModifyBrokerClause() (localctx IModifyBrokerClauseConte } { p.SetState(2906) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42885,13 +42885,13 @@ type AlterLoadErrorUrlClauseContext struct { func NewEmptyAlterLoadErrorUrlClauseContext() *AlterLoadErrorUrlClauseContext { var p = new(AlterLoadErrorUrlClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterLoadErrorUrlClause + p.RuleIndex = StarRocksSQLParserRULE_alterLoadErrorUrlClause return p } func InitEmptyAlterLoadErrorUrlClauseContext(p *AlterLoadErrorUrlClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterLoadErrorUrlClause + p.RuleIndex = StarRocksSQLParserRULE_alterLoadErrorUrlClause } func (*AlterLoadErrorUrlClauseContext) IsAlterLoadErrorUrlClauseContext() {} @@ -42902,7 +42902,7 @@ func NewAlterLoadErrorUrlClauseContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterLoadErrorUrlClause + p.RuleIndex = StarRocksSQLParserRULE_alterLoadErrorUrlClause return p } @@ -42910,19 +42910,19 @@ func NewAlterLoadErrorUrlClauseContext(parser antlr.Parser, parent antlr.ParserR func (s *AlterLoadErrorUrlClauseContext) GetParser() antlr.Parser { return s.parser } func (s *AlterLoadErrorUrlClauseContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterLoadErrorUrlClauseContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *AlterLoadErrorUrlClauseContext) ERRORS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserERRORS, 0) + return s.GetToken(StarRocksSQLParserERRORS, 0) } func (s *AlterLoadErrorUrlClauseContext) HUB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHUB, 0) + return s.GetToken(StarRocksSQLParserHUB, 0) } func (s *AlterLoadErrorUrlClauseContext) Properties() IPropertiesContext { @@ -42950,20 +42950,20 @@ func (s *AlterLoadErrorUrlClauseContext) ToStringTree(ruleNames []string, recog } func (s *AlterLoadErrorUrlClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterLoadErrorUrlClause(s) } } func (s *AlterLoadErrorUrlClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterLoadErrorUrlClause(s) } } func (s *AlterLoadErrorUrlClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterLoadErrorUrlClause(s) default: @@ -42971,15 +42971,15 @@ func (s *AlterLoadErrorUrlClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AlterLoadErrorUrlClause() (localctx IAlterLoadErrorUrlClauseContext) { +func (p *StarRocksSQLParser) AlterLoadErrorUrlClause() (localctx IAlterLoadErrorUrlClauseContext) { localctx = NewAlterLoadErrorUrlClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 252, DorisSQLParserRULE_alterLoadErrorUrlClause) + p.EnterRule(localctx, 252, StarRocksSQLParserRULE_alterLoadErrorUrlClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2910) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42987,7 +42987,7 @@ func (p *DorisSQLParser) AlterLoadErrorUrlClause() (localctx IAlterLoadErrorUrlC } { p.SetState(2911) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -42995,7 +42995,7 @@ func (p *DorisSQLParser) AlterLoadErrorUrlClause() (localctx IAlterLoadErrorUrlC } { p.SetState(2912) - p.Match(DorisSQLParserERRORS) + p.Match(StarRocksSQLParserERRORS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43003,7 +43003,7 @@ func (p *DorisSQLParser) AlterLoadErrorUrlClause() (localctx IAlterLoadErrorUrlC } { p.SetState(2913) - p.Match(DorisSQLParserHUB) + p.Match(StarRocksSQLParserHUB) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43016,7 +43016,7 @@ func (p *DorisSQLParser) AlterLoadErrorUrlClause() (localctx IAlterLoadErrorUrlC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(2914) p.Properties() @@ -43060,13 +43060,13 @@ type CreateImageClauseContext struct { func NewEmptyCreateImageClauseContext() *CreateImageClauseContext { var p = new(CreateImageClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createImageClause + p.RuleIndex = StarRocksSQLParserRULE_createImageClause return p } func InitEmptyCreateImageClauseContext(p *CreateImageClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createImageClause + p.RuleIndex = StarRocksSQLParserRULE_createImageClause } func (*CreateImageClauseContext) IsCreateImageClauseContext() {} @@ -43077,7 +43077,7 @@ func NewCreateImageClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createImageClause + p.RuleIndex = StarRocksSQLParserRULE_createImageClause return p } @@ -43085,11 +43085,11 @@ func NewCreateImageClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *CreateImageClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CreateImageClauseContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateImageClauseContext) IMAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMAGE, 0) + return s.GetToken(StarRocksSQLParserIMAGE, 0) } func (s *CreateImageClauseContext) GetRuleContext() antlr.RuleContext { @@ -43101,20 +43101,20 @@ func (s *CreateImageClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *CreateImageClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateImageClause(s) } } func (s *CreateImageClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateImageClause(s) } } func (s *CreateImageClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateImageClause(s) default: @@ -43122,13 +43122,13 @@ func (s *CreateImageClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) CreateImageClause() (localctx ICreateImageClauseContext) { +func (p *StarRocksSQLParser) CreateImageClause() (localctx ICreateImageClauseContext) { localctx = NewCreateImageClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 254, DorisSQLParserRULE_createImageClause) + p.EnterRule(localctx, 254, StarRocksSQLParserRULE_createImageClause) p.EnterOuterAlt(localctx, 1) { p.SetState(2917) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43136,7 +43136,7 @@ func (p *DorisSQLParser) CreateImageClause() (localctx ICreateImageClauseContext } { p.SetState(2918) - p.Match(DorisSQLParserIMAGE) + p.Match(StarRocksSQLParserIMAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43181,13 +43181,13 @@ type CleanTabletSchedQClauseContext struct { func NewEmptyCleanTabletSchedQClauseContext() *CleanTabletSchedQClauseContext { var p = new(CleanTabletSchedQClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cleanTabletSchedQClause + p.RuleIndex = StarRocksSQLParserRULE_cleanTabletSchedQClause return p } func InitEmptyCleanTabletSchedQClauseContext(p *CleanTabletSchedQClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cleanTabletSchedQClause + p.RuleIndex = StarRocksSQLParserRULE_cleanTabletSchedQClause } func (*CleanTabletSchedQClauseContext) IsCleanTabletSchedQClauseContext() {} @@ -43198,7 +43198,7 @@ func NewCleanTabletSchedQClauseContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cleanTabletSchedQClause + p.RuleIndex = StarRocksSQLParserRULE_cleanTabletSchedQClause return p } @@ -43206,19 +43206,19 @@ func NewCleanTabletSchedQClauseContext(parser antlr.Parser, parent antlr.ParserR func (s *CleanTabletSchedQClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CleanTabletSchedQClauseContext) CLEAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLEAN, 0) + return s.GetToken(StarRocksSQLParserCLEAN, 0) } func (s *CleanTabletSchedQClauseContext) TABLET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLET, 0) + return s.GetToken(StarRocksSQLParserTABLET, 0) } func (s *CleanTabletSchedQClauseContext) SCHEDULER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEDULER, 0) + return s.GetToken(StarRocksSQLParserSCHEDULER, 0) } func (s *CleanTabletSchedQClauseContext) QUEUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUEUE, 0) + return s.GetToken(StarRocksSQLParserQUEUE, 0) } func (s *CleanTabletSchedQClauseContext) GetRuleContext() antlr.RuleContext { @@ -43230,20 +43230,20 @@ func (s *CleanTabletSchedQClauseContext) ToStringTree(ruleNames []string, recog } func (s *CleanTabletSchedQClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCleanTabletSchedQClause(s) } } func (s *CleanTabletSchedQClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCleanTabletSchedQClause(s) } } func (s *CleanTabletSchedQClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCleanTabletSchedQClause(s) default: @@ -43251,13 +43251,13 @@ func (s *CleanTabletSchedQClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CleanTabletSchedQClause() (localctx ICleanTabletSchedQClauseContext) { +func (p *StarRocksSQLParser) CleanTabletSchedQClause() (localctx ICleanTabletSchedQClauseContext) { localctx = NewCleanTabletSchedQClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 256, DorisSQLParserRULE_cleanTabletSchedQClause) + p.EnterRule(localctx, 256, StarRocksSQLParserRULE_cleanTabletSchedQClause) p.EnterOuterAlt(localctx, 1) { p.SetState(2920) - p.Match(DorisSQLParserCLEAN) + p.Match(StarRocksSQLParserCLEAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43265,7 +43265,7 @@ func (p *DorisSQLParser) CleanTabletSchedQClause() (localctx ICleanTabletSchedQC } { p.SetState(2921) - p.Match(DorisSQLParserTABLET) + p.Match(StarRocksSQLParserTABLET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43273,7 +43273,7 @@ func (p *DorisSQLParser) CleanTabletSchedQClause() (localctx ICleanTabletSchedQC } { p.SetState(2922) - p.Match(DorisSQLParserSCHEDULER) + p.Match(StarRocksSQLParserSCHEDULER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43281,7 +43281,7 @@ func (p *DorisSQLParser) CleanTabletSchedQClause() (localctx ICleanTabletSchedQC } { p.SetState(2923) - p.Match(DorisSQLParserQUEUE) + p.Match(StarRocksSQLParserQUEUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43328,13 +43328,13 @@ type DecommissionDiskClauseContext struct { func NewEmptyDecommissionDiskClauseContext() *DecommissionDiskClauseContext { var p = new(DecommissionDiskClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_decommissionDiskClause + p.RuleIndex = StarRocksSQLParserRULE_decommissionDiskClause return p } func InitEmptyDecommissionDiskClauseContext(p *DecommissionDiskClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_decommissionDiskClause + p.RuleIndex = StarRocksSQLParserRULE_decommissionDiskClause } func (*DecommissionDiskClauseContext) IsDecommissionDiskClauseContext() {} @@ -43345,7 +43345,7 @@ func NewDecommissionDiskClauseContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_decommissionDiskClause + p.RuleIndex = StarRocksSQLParserRULE_decommissionDiskClause return p } @@ -43353,11 +43353,11 @@ func NewDecommissionDiskClauseContext(parser antlr.Parser, parent antlr.ParserRu func (s *DecommissionDiskClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DecommissionDiskClauseContext) DECOMMISSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECOMMISSION, 0) + return s.GetToken(StarRocksSQLParserDECOMMISSION, 0) } func (s *DecommissionDiskClauseContext) DISK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISK, 0) + return s.GetToken(StarRocksSQLParserDISK, 0) } func (s *DecommissionDiskClauseContext) AllString_() []IStringContext { @@ -43402,11 +43402,11 @@ func (s *DecommissionDiskClauseContext) String_(i int) IStringContext { } func (s *DecommissionDiskClauseContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *DecommissionDiskClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *DecommissionDiskClauseContext) GetRuleContext() antlr.RuleContext { @@ -43418,20 +43418,20 @@ func (s *DecommissionDiskClauseContext) ToStringTree(ruleNames []string, recog a } func (s *DecommissionDiskClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDecommissionDiskClause(s) } } func (s *DecommissionDiskClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDecommissionDiskClause(s) } } func (s *DecommissionDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDecommissionDiskClause(s) default: @@ -43439,15 +43439,15 @@ func (s *DecommissionDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) DecommissionDiskClause() (localctx IDecommissionDiskClauseContext) { +func (p *StarRocksSQLParser) DecommissionDiskClause() (localctx IDecommissionDiskClauseContext) { localctx = NewDecommissionDiskClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 258, DorisSQLParserRULE_decommissionDiskClause) + p.EnterRule(localctx, 258, StarRocksSQLParserRULE_decommissionDiskClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2925) - p.Match(DorisSQLParserDECOMMISSION) + p.Match(StarRocksSQLParserDECOMMISSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43455,7 +43455,7 @@ func (p *DorisSQLParser) DecommissionDiskClause() (localctx IDecommissionDiskCla } { p.SetState(2926) - p.Match(DorisSQLParserDISK) + p.Match(StarRocksSQLParserDISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43472,10 +43472,10 @@ func (p *DorisSQLParser) DecommissionDiskClause() (localctx IDecommissionDiskCla } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2928) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43495,7 +43495,7 @@ func (p *DorisSQLParser) DecommissionDiskClause() (localctx IDecommissionDiskCla } { p.SetState(2935) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43503,7 +43503,7 @@ func (p *DorisSQLParser) DecommissionDiskClause() (localctx IDecommissionDiskCla } { p.SetState(2936) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43555,13 +43555,13 @@ type CancelDecommissionDiskClauseContext struct { func NewEmptyCancelDecommissionDiskClauseContext() *CancelDecommissionDiskClauseContext { var p = new(CancelDecommissionDiskClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelDecommissionDiskClause + p.RuleIndex = StarRocksSQLParserRULE_cancelDecommissionDiskClause return p } func InitEmptyCancelDecommissionDiskClauseContext(p *CancelDecommissionDiskClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelDecommissionDiskClause + p.RuleIndex = StarRocksSQLParserRULE_cancelDecommissionDiskClause } func (*CancelDecommissionDiskClauseContext) IsCancelDecommissionDiskClauseContext() {} @@ -43572,7 +43572,7 @@ func NewCancelDecommissionDiskClauseContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelDecommissionDiskClause + p.RuleIndex = StarRocksSQLParserRULE_cancelDecommissionDiskClause return p } @@ -43580,15 +43580,15 @@ func NewCancelDecommissionDiskClauseContext(parser antlr.Parser, parent antlr.Pa func (s *CancelDecommissionDiskClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CancelDecommissionDiskClauseContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelDecommissionDiskClauseContext) DECOMMISSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECOMMISSION, 0) + return s.GetToken(StarRocksSQLParserDECOMMISSION, 0) } func (s *CancelDecommissionDiskClauseContext) DISK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISK, 0) + return s.GetToken(StarRocksSQLParserDISK, 0) } func (s *CancelDecommissionDiskClauseContext) AllString_() []IStringContext { @@ -43633,11 +43633,11 @@ func (s *CancelDecommissionDiskClauseContext) String_(i int) IStringContext { } func (s *CancelDecommissionDiskClauseContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CancelDecommissionDiskClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *CancelDecommissionDiskClauseContext) GetRuleContext() antlr.RuleContext { @@ -43649,20 +43649,20 @@ func (s *CancelDecommissionDiskClauseContext) ToStringTree(ruleNames []string, r } func (s *CancelDecommissionDiskClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelDecommissionDiskClause(s) } } func (s *CancelDecommissionDiskClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelDecommissionDiskClause(s) } } func (s *CancelDecommissionDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelDecommissionDiskClause(s) default: @@ -43670,15 +43670,15 @@ func (s *CancelDecommissionDiskClauseContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommissionDiskClauseContext) { +func (p *StarRocksSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommissionDiskClauseContext) { localctx = NewCancelDecommissionDiskClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 260, DorisSQLParserRULE_cancelDecommissionDiskClause) + p.EnterRule(localctx, 260, StarRocksSQLParserRULE_cancelDecommissionDiskClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2939) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43686,7 +43686,7 @@ func (p *DorisSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommi } { p.SetState(2940) - p.Match(DorisSQLParserDECOMMISSION) + p.Match(StarRocksSQLParserDECOMMISSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43694,7 +43694,7 @@ func (p *DorisSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommi } { p.SetState(2941) - p.Match(DorisSQLParserDISK) + p.Match(StarRocksSQLParserDISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43711,10 +43711,10 @@ func (p *DorisSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommi } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2943) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43734,7 +43734,7 @@ func (p *DorisSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommi } { p.SetState(2950) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43742,7 +43742,7 @@ func (p *DorisSQLParser) CancelDecommissionDiskClause() (localctx ICancelDecommi } { p.SetState(2951) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43793,13 +43793,13 @@ type DisableDiskClauseContext struct { func NewEmptyDisableDiskClauseContext() *DisableDiskClauseContext { var p = new(DisableDiskClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_disableDiskClause + p.RuleIndex = StarRocksSQLParserRULE_disableDiskClause return p } func InitEmptyDisableDiskClauseContext(p *DisableDiskClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_disableDiskClause + p.RuleIndex = StarRocksSQLParserRULE_disableDiskClause } func (*DisableDiskClauseContext) IsDisableDiskClauseContext() {} @@ -43810,7 +43810,7 @@ func NewDisableDiskClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_disableDiskClause + p.RuleIndex = StarRocksSQLParserRULE_disableDiskClause return p } @@ -43818,11 +43818,11 @@ func NewDisableDiskClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DisableDiskClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DisableDiskClauseContext) DISABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISABLE, 0) + return s.GetToken(StarRocksSQLParserDISABLE, 0) } func (s *DisableDiskClauseContext) DISK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISK, 0) + return s.GetToken(StarRocksSQLParserDISK, 0) } func (s *DisableDiskClauseContext) AllString_() []IStringContext { @@ -43867,11 +43867,11 @@ func (s *DisableDiskClauseContext) String_(i int) IStringContext { } func (s *DisableDiskClauseContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *DisableDiskClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *DisableDiskClauseContext) GetRuleContext() antlr.RuleContext { @@ -43883,20 +43883,20 @@ func (s *DisableDiskClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DisableDiskClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDisableDiskClause(s) } } func (s *DisableDiskClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDisableDiskClause(s) } } func (s *DisableDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDisableDiskClause(s) default: @@ -43904,15 +43904,15 @@ func (s *DisableDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DisableDiskClause() (localctx IDisableDiskClauseContext) { +func (p *StarRocksSQLParser) DisableDiskClause() (localctx IDisableDiskClauseContext) { localctx = NewDisableDiskClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 262, DorisSQLParserRULE_disableDiskClause) + p.EnterRule(localctx, 262, StarRocksSQLParserRULE_disableDiskClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2954) - p.Match(DorisSQLParserDISABLE) + p.Match(StarRocksSQLParserDISABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43920,7 +43920,7 @@ func (p *DorisSQLParser) DisableDiskClause() (localctx IDisableDiskClauseContext } { p.SetState(2955) - p.Match(DorisSQLParserDISK) + p.Match(StarRocksSQLParserDISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43937,10 +43937,10 @@ func (p *DorisSQLParser) DisableDiskClause() (localctx IDisableDiskClauseContext } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2957) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43960,7 +43960,7 @@ func (p *DorisSQLParser) DisableDiskClause() (localctx IDisableDiskClauseContext } { p.SetState(2964) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -43968,7 +43968,7 @@ func (p *DorisSQLParser) DisableDiskClause() (localctx IDisableDiskClauseContext } { p.SetState(2965) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44020,13 +44020,13 @@ type CancelDisableDiskClauseContext struct { func NewEmptyCancelDisableDiskClauseContext() *CancelDisableDiskClauseContext { var p = new(CancelDisableDiskClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelDisableDiskClause + p.RuleIndex = StarRocksSQLParserRULE_cancelDisableDiskClause return p } func InitEmptyCancelDisableDiskClauseContext(p *CancelDisableDiskClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelDisableDiskClause + p.RuleIndex = StarRocksSQLParserRULE_cancelDisableDiskClause } func (*CancelDisableDiskClauseContext) IsCancelDisableDiskClauseContext() {} @@ -44037,7 +44037,7 @@ func NewCancelDisableDiskClauseContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelDisableDiskClause + p.RuleIndex = StarRocksSQLParserRULE_cancelDisableDiskClause return p } @@ -44045,15 +44045,15 @@ func NewCancelDisableDiskClauseContext(parser antlr.Parser, parent antlr.ParserR func (s *CancelDisableDiskClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CancelDisableDiskClauseContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelDisableDiskClauseContext) DISABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISABLE, 0) + return s.GetToken(StarRocksSQLParserDISABLE, 0) } func (s *CancelDisableDiskClauseContext) DISK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISK, 0) + return s.GetToken(StarRocksSQLParserDISK, 0) } func (s *CancelDisableDiskClauseContext) AllString_() []IStringContext { @@ -44098,11 +44098,11 @@ func (s *CancelDisableDiskClauseContext) String_(i int) IStringContext { } func (s *CancelDisableDiskClauseContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CancelDisableDiskClauseContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *CancelDisableDiskClauseContext) GetRuleContext() antlr.RuleContext { @@ -44114,20 +44114,20 @@ func (s *CancelDisableDiskClauseContext) ToStringTree(ruleNames []string, recog } func (s *CancelDisableDiskClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelDisableDiskClause(s) } } func (s *CancelDisableDiskClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelDisableDiskClause(s) } } func (s *CancelDisableDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelDisableDiskClause(s) default: @@ -44135,15 +44135,15 @@ func (s *CancelDisableDiskClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskClauseContext) { +func (p *StarRocksSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskClauseContext) { localctx = NewCancelDisableDiskClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 264, DorisSQLParserRULE_cancelDisableDiskClause) + p.EnterRule(localctx, 264, StarRocksSQLParserRULE_cancelDisableDiskClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2968) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44151,7 +44151,7 @@ func (p *DorisSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskC } { p.SetState(2969) - p.Match(DorisSQLParserDISABLE) + p.Match(StarRocksSQLParserDISABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44159,7 +44159,7 @@ func (p *DorisSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskC } { p.SetState(2970) - p.Match(DorisSQLParserDISK) + p.Match(StarRocksSQLParserDISK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44176,10 +44176,10 @@ func (p *DorisSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskC } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(2972) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44199,7 +44199,7 @@ func (p *DorisSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskC } { p.SetState(2979) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44207,7 +44207,7 @@ func (p *DorisSQLParser) CancelDisableDiskClause() (localctx ICancelDisableDiskC } { p.SetState(2980) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44266,13 +44266,13 @@ type CreateIndexClauseContext struct { func NewEmptyCreateIndexClauseContext() *CreateIndexClauseContext { var p = new(CreateIndexClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createIndexClause + p.RuleIndex = StarRocksSQLParserRULE_createIndexClause return p } func InitEmptyCreateIndexClauseContext(p *CreateIndexClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createIndexClause + p.RuleIndex = StarRocksSQLParserRULE_createIndexClause } func (*CreateIndexClauseContext) IsCreateIndexClauseContext() {} @@ -44283,7 +44283,7 @@ func NewCreateIndexClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createIndexClause + p.RuleIndex = StarRocksSQLParserRULE_createIndexClause return p } @@ -44295,11 +44295,11 @@ func (s *CreateIndexClauseContext) GetIndexName() IIdentifierContext { return s. func (s *CreateIndexClauseContext) SetIndexName(v IIdentifierContext) { s.indexName = v } func (s *CreateIndexClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *CreateIndexClauseContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *CreateIndexClauseContext) IdentifierList() IIdentifierListContext { @@ -44391,20 +44391,20 @@ func (s *CreateIndexClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *CreateIndexClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateIndexClause(s) } } func (s *CreateIndexClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateIndexClause(s) } } func (s *CreateIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateIndexClause(s) default: @@ -44412,15 +44412,15 @@ func (s *CreateIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) CreateIndexClause() (localctx ICreateIndexClauseContext) { +func (p *StarRocksSQLParser) CreateIndexClause() (localctx ICreateIndexClauseContext) { localctx = NewCreateIndexClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 266, DorisSQLParserRULE_createIndexClause) + p.EnterRule(localctx, 266, StarRocksSQLParserRULE_createIndexClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(2983) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44428,7 +44428,7 @@ func (p *DorisSQLParser) CreateIndexClause() (localctx ICreateIndexClauseContext } { p.SetState(2984) - p.Match(DorisSQLParserINDEX) + p.Match(StarRocksSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44452,7 +44452,7 @@ func (p *DorisSQLParser) CreateIndexClause() (localctx ICreateIndexClauseContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserUSING { + if _la == StarRocksSQLParserUSING { { p.SetState(2987) p.IndexType() @@ -44464,7 +44464,7 @@ func (p *DorisSQLParser) CreateIndexClause() (localctx ICreateIndexClauseContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(2988) p.PropertyList() @@ -44480,7 +44480,7 @@ func (p *DorisSQLParser) CreateIndexClause() (localctx ICreateIndexClauseContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(2993) p.Comment() @@ -44532,13 +44532,13 @@ type DropIndexClauseContext struct { func NewEmptyDropIndexClauseContext() *DropIndexClauseContext { var p = new(DropIndexClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropIndexClause + p.RuleIndex = StarRocksSQLParserRULE_dropIndexClause return p } func InitEmptyDropIndexClauseContext(p *DropIndexClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropIndexClause + p.RuleIndex = StarRocksSQLParserRULE_dropIndexClause } func (*DropIndexClauseContext) IsDropIndexClauseContext() {} @@ -44549,7 +44549,7 @@ func NewDropIndexClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropIndexClause + p.RuleIndex = StarRocksSQLParserRULE_dropIndexClause return p } @@ -44561,11 +44561,11 @@ func (s *DropIndexClauseContext) GetIndexName() IIdentifierContext { return s.in func (s *DropIndexClauseContext) SetIndexName(v IIdentifierContext) { s.indexName = v } func (s *DropIndexClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropIndexClauseContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *DropIndexClauseContext) Identifier() IIdentifierContext { @@ -44593,20 +44593,20 @@ func (s *DropIndexClauseContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *DropIndexClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropIndexClause(s) } } func (s *DropIndexClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropIndexClause(s) } } func (s *DropIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropIndexClause(s) default: @@ -44614,13 +44614,13 @@ func (s *DropIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) DropIndexClause() (localctx IDropIndexClauseContext) { +func (p *StarRocksSQLParser) DropIndexClause() (localctx IDropIndexClauseContext) { localctx = NewDropIndexClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 268, DorisSQLParserRULE_dropIndexClause) + p.EnterRule(localctx, 268, StarRocksSQLParserRULE_dropIndexClause) p.EnterOuterAlt(localctx, 1) { p.SetState(2996) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44628,7 +44628,7 @@ func (p *DorisSQLParser) DropIndexClause() (localctx IDropIndexClauseContext) { } { p.SetState(2997) - p.Match(DorisSQLParserINDEX) + p.Match(StarRocksSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44678,13 +44678,13 @@ type TableRenameClauseContext struct { func NewEmptyTableRenameClauseContext() *TableRenameClauseContext { var p = new(TableRenameClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableRenameClause + p.RuleIndex = StarRocksSQLParserRULE_tableRenameClause return p } func InitEmptyTableRenameClauseContext(p *TableRenameClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableRenameClause + p.RuleIndex = StarRocksSQLParserRULE_tableRenameClause } func (*TableRenameClauseContext) IsTableRenameClauseContext() {} @@ -44695,7 +44695,7 @@ func NewTableRenameClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tableRenameClause + p.RuleIndex = StarRocksSQLParserRULE_tableRenameClause return p } @@ -44703,7 +44703,7 @@ func NewTableRenameClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *TableRenameClauseContext) GetParser() antlr.Parser { return s.parser } func (s *TableRenameClauseContext) RENAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRENAME, 0) + return s.GetToken(StarRocksSQLParserRENAME, 0) } func (s *TableRenameClauseContext) Identifier() IIdentifierContext { @@ -44731,20 +44731,20 @@ func (s *TableRenameClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *TableRenameClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTableRenameClause(s) } } func (s *TableRenameClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTableRenameClause(s) } } func (s *TableRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTableRenameClause(s) default: @@ -44752,13 +44752,13 @@ func (s *TableRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) TableRenameClause() (localctx ITableRenameClauseContext) { +func (p *StarRocksSQLParser) TableRenameClause() (localctx ITableRenameClauseContext) { localctx = NewTableRenameClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 270, DorisSQLParserRULE_tableRenameClause) + p.EnterRule(localctx, 270, StarRocksSQLParserRULE_tableRenameClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3000) - p.Match(DorisSQLParserRENAME) + p.Match(StarRocksSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44806,13 +44806,13 @@ type SwapTableClauseContext struct { func NewEmptySwapTableClauseContext() *SwapTableClauseContext { var p = new(SwapTableClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_swapTableClause + p.RuleIndex = StarRocksSQLParserRULE_swapTableClause return p } func InitEmptySwapTableClauseContext(p *SwapTableClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_swapTableClause + p.RuleIndex = StarRocksSQLParserRULE_swapTableClause } func (*SwapTableClauseContext) IsSwapTableClauseContext() {} @@ -44823,7 +44823,7 @@ func NewSwapTableClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_swapTableClause + p.RuleIndex = StarRocksSQLParserRULE_swapTableClause return p } @@ -44831,11 +44831,11 @@ func NewSwapTableClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *SwapTableClauseContext) GetParser() antlr.Parser { return s.parser } func (s *SwapTableClauseContext) SWAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSWAP, 0) + return s.GetToken(StarRocksSQLParserSWAP, 0) } func (s *SwapTableClauseContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *SwapTableClauseContext) Identifier() IIdentifierContext { @@ -44863,20 +44863,20 @@ func (s *SwapTableClauseContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *SwapTableClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSwapTableClause(s) } } func (s *SwapTableClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSwapTableClause(s) } } func (s *SwapTableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSwapTableClause(s) default: @@ -44884,13 +44884,13 @@ func (s *SwapTableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) SwapTableClause() (localctx ISwapTableClauseContext) { +func (p *StarRocksSQLParser) SwapTableClause() (localctx ISwapTableClauseContext) { localctx = NewSwapTableClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 272, DorisSQLParserRULE_swapTableClause) + p.EnterRule(localctx, 272, StarRocksSQLParserRULE_swapTableClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3003) - p.Match(DorisSQLParserSWAP) + p.Match(StarRocksSQLParserSWAP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44898,7 +44898,7 @@ func (p *DorisSQLParser) SwapTableClause() (localctx ISwapTableClauseContext) { } { p.SetState(3004) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -44945,13 +44945,13 @@ type ModifyPropertiesClauseContext struct { func NewEmptyModifyPropertiesClauseContext() *ModifyPropertiesClauseContext { var p = new(ModifyPropertiesClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyPropertiesClause + p.RuleIndex = StarRocksSQLParserRULE_modifyPropertiesClause return p } func InitEmptyModifyPropertiesClauseContext(p *ModifyPropertiesClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyPropertiesClause + p.RuleIndex = StarRocksSQLParserRULE_modifyPropertiesClause } func (*ModifyPropertiesClauseContext) IsModifyPropertiesClauseContext() {} @@ -44962,7 +44962,7 @@ func NewModifyPropertiesClauseContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyPropertiesClause + p.RuleIndex = StarRocksSQLParserRULE_modifyPropertiesClause return p } @@ -44970,7 +44970,7 @@ func NewModifyPropertiesClauseContext(parser antlr.Parser, parent antlr.ParserRu func (s *ModifyPropertiesClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyPropertiesClauseContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *ModifyPropertiesClauseContext) PropertyList() IPropertyListContext { @@ -44998,20 +44998,20 @@ func (s *ModifyPropertiesClauseContext) ToStringTree(ruleNames []string, recog a } func (s *ModifyPropertiesClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyPropertiesClause(s) } } func (s *ModifyPropertiesClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyPropertiesClause(s) } } func (s *ModifyPropertiesClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyPropertiesClause(s) default: @@ -45019,13 +45019,13 @@ func (s *ModifyPropertiesClauseContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ModifyPropertiesClause() (localctx IModifyPropertiesClauseContext) { +func (p *StarRocksSQLParser) ModifyPropertiesClause() (localctx IModifyPropertiesClauseContext) { localctx = NewModifyPropertiesClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 274, DorisSQLParserRULE_modifyPropertiesClause) + p.EnterRule(localctx, 274, StarRocksSQLParserRULE_modifyPropertiesClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3007) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45073,13 +45073,13 @@ type ModifyCommentClauseContext struct { func NewEmptyModifyCommentClauseContext() *ModifyCommentClauseContext { var p = new(ModifyCommentClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyCommentClause return p } func InitEmptyModifyCommentClauseContext(p *ModifyCommentClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyCommentClause } func (*ModifyCommentClauseContext) IsModifyCommentClauseContext() {} @@ -45090,7 +45090,7 @@ func NewModifyCommentClauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyCommentClause return p } @@ -45098,11 +45098,11 @@ func NewModifyCommentClauseContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ModifyCommentClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyCommentClauseContext) COMMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMENT, 0) + return s.GetToken(StarRocksSQLParserCOMMENT, 0) } func (s *ModifyCommentClauseContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *ModifyCommentClauseContext) String_() IStringContext { @@ -45130,20 +45130,20 @@ func (s *ModifyCommentClauseContext) ToStringTree(ruleNames []string, recog antl } func (s *ModifyCommentClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyCommentClause(s) } } func (s *ModifyCommentClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyCommentClause(s) } } func (s *ModifyCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyCommentClause(s) default: @@ -45151,13 +45151,13 @@ func (s *ModifyCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ModifyCommentClause() (localctx IModifyCommentClauseContext) { +func (p *StarRocksSQLParser) ModifyCommentClause() (localctx IModifyCommentClauseContext) { localctx = NewModifyCommentClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 276, DorisSQLParserRULE_modifyCommentClause) + p.EnterRule(localctx, 276, StarRocksSQLParserRULE_modifyCommentClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3010) - p.Match(DorisSQLParserCOMMENT) + p.Match(StarRocksSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45165,7 +45165,7 @@ func (p *DorisSQLParser) ModifyCommentClause() (localctx IModifyCommentClauseCon } { p.SetState(3011) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45228,13 +45228,13 @@ type OptimizeRangeContext struct { func NewEmptyOptimizeRangeContext() *OptimizeRangeContext { var p = new(OptimizeRangeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_optimizeRange + p.RuleIndex = StarRocksSQLParserRULE_optimizeRange return p } func InitEmptyOptimizeRangeContext(p *OptimizeRangeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_optimizeRange + p.RuleIndex = StarRocksSQLParserRULE_optimizeRange } func (*OptimizeRangeContext) IsOptimizeRangeContext() {} @@ -45245,7 +45245,7 @@ func NewOptimizeRangeContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_optimizeRange + p.RuleIndex = StarRocksSQLParserRULE_optimizeRange return p } @@ -45261,11 +45261,11 @@ func (s *OptimizeRangeContext) SetStart_(v IStringContext) { s.start_ = v } func (s *OptimizeRangeContext) SetEnd(v IStringContext) { s.end = v } func (s *OptimizeRangeContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBETWEEN, 0) + return s.GetToken(StarRocksSQLParserBETWEEN, 0) } func (s *OptimizeRangeContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *OptimizeRangeContext) AllString_() []IStringContext { @@ -45318,20 +45318,20 @@ func (s *OptimizeRangeContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *OptimizeRangeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOptimizeRange(s) } } func (s *OptimizeRangeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOptimizeRange(s) } } func (s *OptimizeRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOptimizeRange(s) default: @@ -45339,13 +45339,13 @@ func (s *OptimizeRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) OptimizeRange() (localctx IOptimizeRangeContext) { +func (p *StarRocksSQLParser) OptimizeRange() (localctx IOptimizeRangeContext) { localctx = NewOptimizeRangeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 278, DorisSQLParserRULE_optimizeRange) + p.EnterRule(localctx, 278, StarRocksSQLParserRULE_optimizeRange) p.EnterOuterAlt(localctx, 1) { p.SetState(3014) - p.Match(DorisSQLParserBETWEEN) + p.Match(StarRocksSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45360,7 +45360,7 @@ func (p *DorisSQLParser) OptimizeRange() (localctx IOptimizeRangeContext) { } { p.SetState(3016) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45414,13 +45414,13 @@ type OptimizeClauseContext struct { func NewEmptyOptimizeClauseContext() *OptimizeClauseContext { var p = new(OptimizeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_optimizeClause + p.RuleIndex = StarRocksSQLParserRULE_optimizeClause return p } func InitEmptyOptimizeClauseContext(p *OptimizeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_optimizeClause + p.RuleIndex = StarRocksSQLParserRULE_optimizeClause } func (*OptimizeClauseContext) IsOptimizeClauseContext() {} @@ -45431,7 +45431,7 @@ func NewOptimizeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_optimizeClause + p.RuleIndex = StarRocksSQLParserRULE_optimizeClause return p } @@ -45543,20 +45543,20 @@ func (s *OptimizeClauseContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *OptimizeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOptimizeClause(s) } } func (s *OptimizeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOptimizeClause(s) } } func (s *OptimizeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOptimizeClause(s) default: @@ -45564,9 +45564,9 @@ func (s *OptimizeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { +func (p *StarRocksSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { localctx = NewOptimizeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 280, DorisSQLParserRULE_optimizeClause) + p.EnterRule(localctx, 280, StarRocksSQLParserRULE_optimizeClause) var _la int p.EnterOuterAlt(localctx, 1) @@ -45589,7 +45589,7 @@ func (p *DorisSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAGGREGATE || _la == DorisSQLParserDUPLICATE || _la == DorisSQLParserPRIMARY || _la == DorisSQLParserUNIQUE { + if _la == StarRocksSQLParserAGGREGATE || _la == StarRocksSQLParserDUPLICATE || _la == StarRocksSQLParserPRIMARY || _la == StarRocksSQLParserUNIQUE { { p.SetState(3022) p.KeyDesc() @@ -45603,7 +45603,7 @@ func (p *DorisSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(3025) p.PartitionDesc() @@ -45617,7 +45617,7 @@ func (p *DorisSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(3028) p.OrderByDesc() @@ -45631,7 +45631,7 @@ func (p *DorisSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDISTRIBUTED { + if _la == StarRocksSQLParserDISTRIBUTED { { p.SetState(3031) p.DistributionDesc() @@ -45645,7 +45645,7 @@ func (p *DorisSQLParser) OptimizeClause() (localctx IOptimizeClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBETWEEN { + if _la == StarRocksSQLParserBETWEEN { { p.SetState(3034) p.OptimizeRange() @@ -45704,13 +45704,13 @@ type AddColumnClauseContext struct { func NewEmptyAddColumnClauseContext() *AddColumnClauseContext { var p = new(AddColumnClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addColumnClause + p.RuleIndex = StarRocksSQLParserRULE_addColumnClause return p } func InitEmptyAddColumnClauseContext(p *AddColumnClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addColumnClause + p.RuleIndex = StarRocksSQLParserRULE_addColumnClause } func (*AddColumnClauseContext) IsAddColumnClauseContext() {} @@ -45721,7 +45721,7 @@ func NewAddColumnClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addColumnClause + p.RuleIndex = StarRocksSQLParserRULE_addColumnClause return p } @@ -45733,11 +45733,11 @@ func (s *AddColumnClauseContext) GetRollupName() IIdentifierContext { return s.r func (s *AddColumnClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } func (s *AddColumnClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddColumnClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *AddColumnClauseContext) ColumnDesc() IColumnDescContext { @@ -45757,11 +45757,11 @@ func (s *AddColumnClauseContext) ColumnDesc() IColumnDescContext { } func (s *AddColumnClauseContext) FIRST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIRST, 0) + return s.GetToken(StarRocksSQLParserFIRST, 0) } func (s *AddColumnClauseContext) AFTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAFTER, 0) + return s.GetToken(StarRocksSQLParserAFTER, 0) } func (s *AddColumnClauseContext) AllIdentifier() []IIdentifierContext { @@ -45822,11 +45822,11 @@ func (s *AddColumnClauseContext) Properties() IPropertiesContext { } func (s *AddColumnClauseContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *AddColumnClauseContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *AddColumnClauseContext) GetRuleContext() antlr.RuleContext { @@ -45838,20 +45838,20 @@ func (s *AddColumnClauseContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *AddColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddColumnClause(s) } } func (s *AddColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddColumnClause(s) } } func (s *AddColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddColumnClause(s) default: @@ -45859,15 +45859,15 @@ func (s *AddColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { +func (p *StarRocksSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { localctx = NewAddColumnClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 282, DorisSQLParserRULE_addColumnClause) + p.EnterRule(localctx, 282, StarRocksSQLParserRULE_addColumnClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3037) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45875,7 +45875,7 @@ func (p *DorisSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { } { p.SetState(3038) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45891,20 +45891,20 @@ func (p *DorisSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserFIRST: + case StarRocksSQLParserFIRST: { p.SetState(3040) - p.Match(DorisSQLParserFIRST) + p.Match(StarRocksSQLParserFIRST) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserAFTER: + case StarRocksSQLParserAFTER: { p.SetState(3041) - p.Match(DorisSQLParserAFTER) + p.Match(StarRocksSQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -45915,7 +45915,7 @@ func (p *DorisSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { p.Identifier() } - case DorisSQLParserEOF, DorisSQLParserT__2, DorisSQLParserIN, DorisSQLParserPROPERTIES, DorisSQLParserTO, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserT__2, StarRocksSQLParserIN, StarRocksSQLParserPROPERTIES, StarRocksSQLParserTO, StarRocksSQLParserSEMICOLON: default: } @@ -45926,12 +45926,12 @@ func (p *DorisSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIN || _la == DorisSQLParserTO { + if _la == StarRocksSQLParserIN || _la == StarRocksSQLParserTO { { p.SetState(3045) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserIN || _la == DorisSQLParserTO) { + if !(_la == StarRocksSQLParserIN || _la == StarRocksSQLParserTO) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -45954,7 +45954,7 @@ func (p *DorisSQLParser) AddColumnClause() (localctx IAddColumnClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3049) p.Properties() @@ -46011,13 +46011,13 @@ type AddColumnsClauseContext struct { func NewEmptyAddColumnsClauseContext() *AddColumnsClauseContext { var p = new(AddColumnsClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addColumnsClause + p.RuleIndex = StarRocksSQLParserRULE_addColumnsClause return p } func InitEmptyAddColumnsClauseContext(p *AddColumnsClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addColumnsClause + p.RuleIndex = StarRocksSQLParserRULE_addColumnsClause } func (*AddColumnsClauseContext) IsAddColumnsClauseContext() {} @@ -46028,7 +46028,7 @@ func NewAddColumnsClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addColumnsClause + p.RuleIndex = StarRocksSQLParserRULE_addColumnsClause return p } @@ -46040,11 +46040,11 @@ func (s *AddColumnsClauseContext) GetRollupName() IIdentifierContext { return s. func (s *AddColumnsClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } func (s *AddColumnsClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddColumnsClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *AddColumnsClauseContext) AllColumnDesc() []IColumnDescContext { @@ -46105,11 +46105,11 @@ func (s *AddColumnsClauseContext) Properties() IPropertiesContext { } func (s *AddColumnsClauseContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *AddColumnsClauseContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *AddColumnsClauseContext) Identifier() IIdentifierContext { @@ -46137,20 +46137,20 @@ func (s *AddColumnsClauseContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *AddColumnsClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddColumnsClause(s) } } func (s *AddColumnsClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddColumnsClause(s) } } func (s *AddColumnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddColumnsClause(s) default: @@ -46158,15 +46158,15 @@ func (s *AddColumnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) { +func (p *StarRocksSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) { localctx = NewAddColumnsClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 284, DorisSQLParserRULE_addColumnsClause) + p.EnterRule(localctx, 284, StarRocksSQLParserRULE_addColumnsClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3052) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46174,7 +46174,7 @@ func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) } { p.SetState(3053) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46182,7 +46182,7 @@ func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) } { p.SetState(3054) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46199,10 +46199,10 @@ func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3056) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46222,7 +46222,7 @@ func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) } { p.SetState(3063) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46235,12 +46235,12 @@ func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIN || _la == DorisSQLParserTO { + if _la == StarRocksSQLParserIN || _la == StarRocksSQLParserTO { { p.SetState(3064) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserIN || _la == DorisSQLParserTO) { + if !(_la == StarRocksSQLParserIN || _la == StarRocksSQLParserTO) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -46263,7 +46263,7 @@ func (p *DorisSQLParser) AddColumnsClause() (localctx IAddColumnsClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3068) p.Properties() @@ -46318,13 +46318,13 @@ type DropColumnClauseContext struct { func NewEmptyDropColumnClauseContext() *DropColumnClauseContext { var p = new(DropColumnClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropColumnClause + p.RuleIndex = StarRocksSQLParserRULE_dropColumnClause return p } func InitEmptyDropColumnClauseContext(p *DropColumnClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropColumnClause + p.RuleIndex = StarRocksSQLParserRULE_dropColumnClause } func (*DropColumnClauseContext) IsDropColumnClauseContext() {} @@ -46335,7 +46335,7 @@ func NewDropColumnClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropColumnClause + p.RuleIndex = StarRocksSQLParserRULE_dropColumnClause return p } @@ -46347,11 +46347,11 @@ func (s *DropColumnClauseContext) GetRollupName() IIdentifierContext { return s. func (s *DropColumnClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } func (s *DropColumnClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropColumnClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *DropColumnClauseContext) AllIdentifier() []IIdentifierContext { @@ -46396,7 +46396,7 @@ func (s *DropColumnClauseContext) Identifier(i int) IIdentifierContext { } func (s *DropColumnClauseContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DropColumnClauseContext) Properties() IPropertiesContext { @@ -46424,20 +46424,20 @@ func (s *DropColumnClauseContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *DropColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropColumnClause(s) } } func (s *DropColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropColumnClause(s) } } func (s *DropColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropColumnClause(s) default: @@ -46445,15 +46445,15 @@ func (s *DropColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) DropColumnClause() (localctx IDropColumnClauseContext) { +func (p *StarRocksSQLParser) DropColumnClause() (localctx IDropColumnClauseContext) { localctx = NewDropColumnClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 286, DorisSQLParserRULE_dropColumnClause) + p.EnterRule(localctx, 286, StarRocksSQLParserRULE_dropColumnClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3071) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46461,7 +46461,7 @@ func (p *DorisSQLParser) DropColumnClause() (localctx IDropColumnClauseContext) } { p.SetState(3072) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46478,10 +46478,10 @@ func (p *DorisSQLParser) DropColumnClause() (localctx IDropColumnClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3074) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46503,7 +46503,7 @@ func (p *DorisSQLParser) DropColumnClause() (localctx IDropColumnClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3078) p.Properties() @@ -46561,13 +46561,13 @@ type ModifyColumnClauseContext struct { func NewEmptyModifyColumnClauseContext() *ModifyColumnClauseContext { var p = new(ModifyColumnClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyColumnClause + p.RuleIndex = StarRocksSQLParserRULE_modifyColumnClause return p } func InitEmptyModifyColumnClauseContext(p *ModifyColumnClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyColumnClause + p.RuleIndex = StarRocksSQLParserRULE_modifyColumnClause } func (*ModifyColumnClauseContext) IsModifyColumnClauseContext() {} @@ -46578,7 +46578,7 @@ func NewModifyColumnClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyColumnClause + p.RuleIndex = StarRocksSQLParserRULE_modifyColumnClause return p } @@ -46590,11 +46590,11 @@ func (s *ModifyColumnClauseContext) GetRollupName() IIdentifierContext { return func (s *ModifyColumnClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } func (s *ModifyColumnClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *ModifyColumnClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *ModifyColumnClauseContext) ColumnDesc() IColumnDescContext { @@ -46614,11 +46614,11 @@ func (s *ModifyColumnClauseContext) ColumnDesc() IColumnDescContext { } func (s *ModifyColumnClauseContext) FIRST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIRST, 0) + return s.GetToken(StarRocksSQLParserFIRST, 0) } func (s *ModifyColumnClauseContext) AFTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAFTER, 0) + return s.GetToken(StarRocksSQLParserAFTER, 0) } func (s *ModifyColumnClauseContext) AllIdentifier() []IIdentifierContext { @@ -46663,7 +46663,7 @@ func (s *ModifyColumnClauseContext) Identifier(i int) IIdentifierContext { } func (s *ModifyColumnClauseContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ModifyColumnClauseContext) Properties() IPropertiesContext { @@ -46691,20 +46691,20 @@ func (s *ModifyColumnClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *ModifyColumnClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyColumnClause(s) } } func (s *ModifyColumnClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyColumnClause(s) } } func (s *ModifyColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyColumnClause(s) default: @@ -46712,15 +46712,15 @@ func (s *ModifyColumnClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseContext) { +func (p *StarRocksSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseContext) { localctx = NewModifyColumnClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 288, DorisSQLParserRULE_modifyColumnClause) + p.EnterRule(localctx, 288, StarRocksSQLParserRULE_modifyColumnClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3081) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46728,7 +46728,7 @@ func (p *DorisSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseConte } { p.SetState(3082) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46744,20 +46744,20 @@ func (p *DorisSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseConte goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserFIRST: + case StarRocksSQLParserFIRST: { p.SetState(3084) - p.Match(DorisSQLParserFIRST) + p.Match(StarRocksSQLParserFIRST) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserAFTER: + case StarRocksSQLParserAFTER: { p.SetState(3085) - p.Match(DorisSQLParserAFTER) + p.Match(StarRocksSQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46768,7 +46768,7 @@ func (p *DorisSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseConte p.Identifier() } - case DorisSQLParserEOF, DorisSQLParserT__2, DorisSQLParserFROM, DorisSQLParserPROPERTIES, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserT__2, StarRocksSQLParserFROM, StarRocksSQLParserPROPERTIES, StarRocksSQLParserSEMICOLON: default: } @@ -46779,10 +46779,10 @@ func (p *DorisSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3089) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46804,7 +46804,7 @@ func (p *DorisSQLParser) ModifyColumnClause() (localctx IModifyColumnClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3093) p.Properties() @@ -46850,13 +46850,13 @@ type ModifyColumnCommentClauseContext struct { func NewEmptyModifyColumnCommentClauseContext() *ModifyColumnCommentClauseContext { var p = new(ModifyColumnCommentClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyColumnCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyColumnCommentClause return p } func InitEmptyModifyColumnCommentClauseContext(p *ModifyColumnCommentClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyColumnCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyColumnCommentClause } func (*ModifyColumnCommentClauseContext) IsModifyColumnCommentClauseContext() {} @@ -46867,7 +46867,7 @@ func NewModifyColumnCommentClauseContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyColumnCommentClause + p.RuleIndex = StarRocksSQLParserRULE_modifyColumnCommentClause return p } @@ -46875,11 +46875,11 @@ func NewModifyColumnCommentClauseContext(parser antlr.Parser, parent antlr.Parse func (s *ModifyColumnCommentClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyColumnCommentClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *ModifyColumnCommentClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *ModifyColumnCommentClauseContext) Identifier() IIdentifierContext { @@ -46923,20 +46923,20 @@ func (s *ModifyColumnCommentClauseContext) ToStringTree(ruleNames []string, reco } func (s *ModifyColumnCommentClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyColumnCommentClause(s) } } func (s *ModifyColumnCommentClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyColumnCommentClause(s) } } func (s *ModifyColumnCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyColumnCommentClause(s) default: @@ -46944,13 +46944,13 @@ func (s *ModifyColumnCommentClauseContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ModifyColumnCommentClause() (localctx IModifyColumnCommentClauseContext) { +func (p *StarRocksSQLParser) ModifyColumnCommentClause() (localctx IModifyColumnCommentClauseContext) { localctx = NewModifyColumnCommentClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 290, DorisSQLParserRULE_modifyColumnCommentClause) + p.EnterRule(localctx, 290, StarRocksSQLParserRULE_modifyColumnCommentClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3096) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -46958,7 +46958,7 @@ func (p *DorisSQLParser) ModifyColumnCommentClause() (localctx IModifyColumnComm } { p.SetState(3097) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47026,13 +47026,13 @@ type ColumnRenameClauseContext struct { func NewEmptyColumnRenameClauseContext() *ColumnRenameClauseContext { var p = new(ColumnRenameClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnRenameClause + p.RuleIndex = StarRocksSQLParserRULE_columnRenameClause return p } func InitEmptyColumnRenameClauseContext(p *ColumnRenameClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnRenameClause + p.RuleIndex = StarRocksSQLParserRULE_columnRenameClause } func (*ColumnRenameClauseContext) IsColumnRenameClauseContext() {} @@ -47043,7 +47043,7 @@ func NewColumnRenameClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnRenameClause + p.RuleIndex = StarRocksSQLParserRULE_columnRenameClause return p } @@ -47059,15 +47059,15 @@ func (s *ColumnRenameClauseContext) SetOldColumn(v IIdentifierContext) { s.oldCo func (s *ColumnRenameClauseContext) SetNewColumn(v IIdentifierContext) { s.newColumn = v } func (s *ColumnRenameClauseContext) RENAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRENAME, 0) + return s.GetToken(StarRocksSQLParserRENAME, 0) } func (s *ColumnRenameClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *ColumnRenameClauseContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *ColumnRenameClauseContext) AllIdentifier() []IIdentifierContext { @@ -47120,20 +47120,20 @@ func (s *ColumnRenameClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *ColumnRenameClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnRenameClause(s) } } func (s *ColumnRenameClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnRenameClause(s) } } func (s *ColumnRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnRenameClause(s) default: @@ -47141,13 +47141,13 @@ func (s *ColumnRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ColumnRenameClause() (localctx IColumnRenameClauseContext) { +func (p *StarRocksSQLParser) ColumnRenameClause() (localctx IColumnRenameClauseContext) { localctx = NewColumnRenameClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 292, DorisSQLParserRULE_columnRenameClause) + p.EnterRule(localctx, 292, StarRocksSQLParserRULE_columnRenameClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3101) - p.Match(DorisSQLParserRENAME) + p.Match(StarRocksSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47155,7 +47155,7 @@ func (p *DorisSQLParser) ColumnRenameClause() (localctx IColumnRenameClauseConte } { p.SetState(3102) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47170,7 +47170,7 @@ func (p *DorisSQLParser) ColumnRenameClause() (localctx IColumnRenameClauseConte } { p.SetState(3104) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47231,13 +47231,13 @@ type ReorderColumnsClauseContext struct { func NewEmptyReorderColumnsClauseContext() *ReorderColumnsClauseContext { var p = new(ReorderColumnsClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_reorderColumnsClause + p.RuleIndex = StarRocksSQLParserRULE_reorderColumnsClause return p } func InitEmptyReorderColumnsClauseContext(p *ReorderColumnsClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_reorderColumnsClause + p.RuleIndex = StarRocksSQLParserRULE_reorderColumnsClause } func (*ReorderColumnsClauseContext) IsReorderColumnsClauseContext() {} @@ -47248,7 +47248,7 @@ func NewReorderColumnsClauseContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_reorderColumnsClause + p.RuleIndex = StarRocksSQLParserRULE_reorderColumnsClause return p } @@ -47260,11 +47260,11 @@ func (s *ReorderColumnsClauseContext) GetRollupName() IIdentifierContext { retur func (s *ReorderColumnsClauseContext) SetRollupName(v IIdentifierContext) { s.rollupName = v } func (s *ReorderColumnsClauseContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ReorderColumnsClauseContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ReorderColumnsClauseContext) IdentifierList() IIdentifierListContext { @@ -47284,7 +47284,7 @@ func (s *ReorderColumnsClauseContext) IdentifierList() IIdentifierListContext { } func (s *ReorderColumnsClauseContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ReorderColumnsClauseContext) Properties() IPropertiesContext { @@ -47328,20 +47328,20 @@ func (s *ReorderColumnsClauseContext) ToStringTree(ruleNames []string, recog ant } func (s *ReorderColumnsClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterReorderColumnsClause(s) } } func (s *ReorderColumnsClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitReorderColumnsClause(s) } } func (s *ReorderColumnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitReorderColumnsClause(s) default: @@ -47349,15 +47349,15 @@ func (s *ReorderColumnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ReorderColumnsClause() (localctx IReorderColumnsClauseContext) { +func (p *StarRocksSQLParser) ReorderColumnsClause() (localctx IReorderColumnsClauseContext) { localctx = NewReorderColumnsClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 294, DorisSQLParserRULE_reorderColumnsClause) + p.EnterRule(localctx, 294, StarRocksSQLParserRULE_reorderColumnsClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3107) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47365,7 +47365,7 @@ func (p *DorisSQLParser) ReorderColumnsClause() (localctx IReorderColumnsClauseC } { p.SetState(3108) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47382,10 +47382,10 @@ func (p *DorisSQLParser) ReorderColumnsClause() (localctx IReorderColumnsClauseC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3110) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47407,7 +47407,7 @@ func (p *DorisSQLParser) ReorderColumnsClause() (localctx IReorderColumnsClauseC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3114) p.Properties() @@ -47467,13 +47467,13 @@ type RollupRenameClauseContext struct { func NewEmptyRollupRenameClauseContext() *RollupRenameClauseContext { var p = new(RollupRenameClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollupRenameClause + p.RuleIndex = StarRocksSQLParserRULE_rollupRenameClause return p } func InitEmptyRollupRenameClauseContext(p *RollupRenameClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollupRenameClause + p.RuleIndex = StarRocksSQLParserRULE_rollupRenameClause } func (*RollupRenameClauseContext) IsRollupRenameClauseContext() {} @@ -47484,7 +47484,7 @@ func NewRollupRenameClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rollupRenameClause + p.RuleIndex = StarRocksSQLParserRULE_rollupRenameClause return p } @@ -47500,11 +47500,11 @@ func (s *RollupRenameClauseContext) SetRollupName(v IIdentifierContext) { s.roll func (s *RollupRenameClauseContext) SetNewRollupName(v IIdentifierContext) { s.newRollupName = v } func (s *RollupRenameClauseContext) RENAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRENAME, 0) + return s.GetToken(StarRocksSQLParserRENAME, 0) } func (s *RollupRenameClauseContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *RollupRenameClauseContext) AllIdentifier() []IIdentifierContext { @@ -47557,20 +47557,20 @@ func (s *RollupRenameClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *RollupRenameClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRollupRenameClause(s) } } func (s *RollupRenameClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRollupRenameClause(s) } } func (s *RollupRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRollupRenameClause(s) default: @@ -47578,13 +47578,13 @@ func (s *RollupRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) RollupRenameClause() (localctx IRollupRenameClauseContext) { +func (p *StarRocksSQLParser) RollupRenameClause() (localctx IRollupRenameClauseContext) { localctx = NewRollupRenameClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 296, DorisSQLParserRULE_rollupRenameClause) + p.EnterRule(localctx, 296, StarRocksSQLParserRULE_rollupRenameClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3117) - p.Match(DorisSQLParserRENAME) + p.Match(StarRocksSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47592,7 +47592,7 @@ func (p *DorisSQLParser) RollupRenameClause() (localctx IRollupRenameClauseConte } { p.SetState(3118) - p.Match(DorisSQLParserROLLUP) + p.Match(StarRocksSQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47652,13 +47652,13 @@ type CompactionClauseContext struct { func NewEmptyCompactionClauseContext() *CompactionClauseContext { var p = new(CompactionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_compactionClause + p.RuleIndex = StarRocksSQLParserRULE_compactionClause return p } func InitEmptyCompactionClauseContext(p *CompactionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_compactionClause + p.RuleIndex = StarRocksSQLParserRULE_compactionClause } func (*CompactionClauseContext) IsCompactionClauseContext() {} @@ -47669,7 +47669,7 @@ func NewCompactionClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_compactionClause + p.RuleIndex = StarRocksSQLParserRULE_compactionClause return p } @@ -47677,7 +47677,7 @@ func NewCompactionClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *CompactionClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CompactionClauseContext) COMPACT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPACT, 0) + return s.GetToken(StarRocksSQLParserCOMPACT, 0) } func (s *CompactionClauseContext) Identifier() IIdentifierContext { @@ -47713,11 +47713,11 @@ func (s *CompactionClauseContext) IdentifierList() IIdentifierListContext { } func (s *CompactionClauseContext) BASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBASE, 0) + return s.GetToken(StarRocksSQLParserBASE, 0) } func (s *CompactionClauseContext) CUMULATIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCUMULATIVE, 0) + return s.GetToken(StarRocksSQLParserCUMULATIVE, 0) } func (s *CompactionClauseContext) GetRuleContext() antlr.RuleContext { @@ -47729,20 +47729,20 @@ func (s *CompactionClauseContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *CompactionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCompactionClause(s) } } func (s *CompactionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCompactionClause(s) } } func (s *CompactionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCompactionClause(s) default: @@ -47750,9 +47750,9 @@ func (s *CompactionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) CompactionClause() (localctx ICompactionClauseContext) { +func (p *StarRocksSQLParser) CompactionClause() (localctx ICompactionClauseContext) { localctx = NewCompactionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 298, DorisSQLParserRULE_compactionClause) + p.EnterRule(localctx, 298, StarRocksSQLParserRULE_compactionClause) var _la int p.EnterOuterAlt(localctx, 1) @@ -47763,12 +47763,12 @@ func (p *DorisSQLParser) CompactionClause() (localctx ICompactionClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBASE || _la == DorisSQLParserCUMULATIVE { + if _la == StarRocksSQLParserBASE || _la == StarRocksSQLParserCUMULATIVE { { p.SetState(3122) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserBASE || _la == DorisSQLParserCUMULATIVE) { + if !(_la == StarRocksSQLParserBASE || _la == StarRocksSQLParserCUMULATIVE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -47779,7 +47779,7 @@ func (p *DorisSQLParser) CompactionClause() (localctx ICompactionClauseContext) } { p.SetState(3125) - p.Match(DorisSQLParserCOMPACT) + p.Match(StarRocksSQLParserCOMPACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47791,19 +47791,19 @@ func (p *DorisSQLParser) CompactionClause() (localctx ICompactionClauseContext) goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(3126) p.Identifier() } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(3127) p.IdentifierList() } - case DorisSQLParserEOF, DorisSQLParserT__2, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserT__2, StarRocksSQLParserSEMICOLON: default: } @@ -47844,13 +47844,13 @@ type SubfieldNameContext struct { func NewEmptySubfieldNameContext() *SubfieldNameContext { var p = new(SubfieldNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subfieldName + p.RuleIndex = StarRocksSQLParserRULE_subfieldName return p } func InitEmptySubfieldNameContext(p *SubfieldNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subfieldName + p.RuleIndex = StarRocksSQLParserRULE_subfieldName } func (*SubfieldNameContext) IsSubfieldNameContext() {} @@ -47861,7 +47861,7 @@ func NewSubfieldNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_subfieldName + p.RuleIndex = StarRocksSQLParserRULE_subfieldName return p } @@ -47885,7 +47885,7 @@ func (s *SubfieldNameContext) Identifier() IIdentifierContext { } func (s *SubfieldNameContext) ARRAY_ELEMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY_ELEMENT, 0) + return s.GetToken(StarRocksSQLParserARRAY_ELEMENT, 0) } func (s *SubfieldNameContext) GetRuleContext() antlr.RuleContext { @@ -47897,20 +47897,20 @@ func (s *SubfieldNameContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *SubfieldNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubfieldName(s) } } func (s *SubfieldNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubfieldName(s) } } func (s *SubfieldNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubfieldName(s) default: @@ -47918,9 +47918,9 @@ func (s *SubfieldNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) SubfieldName() (localctx ISubfieldNameContext) { +func (p *StarRocksSQLParser) SubfieldName() (localctx ISubfieldNameContext) { localctx = NewSubfieldNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 300, DorisSQLParserRULE_subfieldName) + p.EnterRule(localctx, 300, StarRocksSQLParserRULE_subfieldName) p.SetState(3132) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -47939,7 +47939,7 @@ func (p *DorisSQLParser) SubfieldName() (localctx ISubfieldNameContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(3131) - p.Match(DorisSQLParserARRAY_ELEMENT) + p.Match(StarRocksSQLParserARRAY_ELEMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -47988,13 +47988,13 @@ type NestedFieldNameContext struct { func NewEmptyNestedFieldNameContext() *NestedFieldNameContext { var p = new(NestedFieldNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_nestedFieldName + p.RuleIndex = StarRocksSQLParserRULE_nestedFieldName return p } func InitEmptyNestedFieldNameContext(p *NestedFieldNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_nestedFieldName + p.RuleIndex = StarRocksSQLParserRULE_nestedFieldName } func (*NestedFieldNameContext) IsNestedFieldNameContext() {} @@ -48005,7 +48005,7 @@ func NewNestedFieldNameContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_nestedFieldName + p.RuleIndex = StarRocksSQLParserRULE_nestedFieldName return p } @@ -48054,11 +48054,11 @@ func (s *NestedFieldNameContext) SubfieldName(i int) ISubfieldNameContext { } func (s *NestedFieldNameContext) AllDOT_IDENTIFIER() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserDOT_IDENTIFIER) + return s.GetTokens(StarRocksSQLParserDOT_IDENTIFIER) } func (s *NestedFieldNameContext) DOT_IDENTIFIER(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOT_IDENTIFIER, i) + return s.GetToken(StarRocksSQLParserDOT_IDENTIFIER, i) } func (s *NestedFieldNameContext) GetRuleContext() antlr.RuleContext { @@ -48070,20 +48070,20 @@ func (s *NestedFieldNameContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *NestedFieldNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNestedFieldName(s) } } func (s *NestedFieldNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNestedFieldName(s) } } func (s *NestedFieldNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNestedFieldName(s) default: @@ -48091,9 +48091,9 @@ func (s *NestedFieldNameContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) NestedFieldName() (localctx INestedFieldNameContext) { +func (p *StarRocksSQLParser) NestedFieldName() (localctx INestedFieldNameContext) { localctx = NewNestedFieldNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 302, DorisSQLParserRULE_nestedFieldName) + p.EnterRule(localctx, 302, StarRocksSQLParserRULE_nestedFieldName) var _la int p.EnterOuterAlt(localctx, 1) @@ -48108,7 +48108,7 @@ func (p *DorisSQLParser) NestedFieldName() (localctx INestedFieldNameContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__0 || _la == DorisSQLParserDOT_IDENTIFIER { + for _la == StarRocksSQLParserT__0 || _la == StarRocksSQLParserDOT_IDENTIFIER { p.SetState(3138) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -48116,20 +48116,20 @@ func (p *DorisSQLParser) NestedFieldName() (localctx INestedFieldNameContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDOT_IDENTIFIER: + case StarRocksSQLParserDOT_IDENTIFIER: { p.SetState(3135) - p.Match(DorisSQLParserDOT_IDENTIFIER) + p.Match(StarRocksSQLParserDOT_IDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserT__0: + case StarRocksSQLParserT__0: { p.SetState(3136) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48197,13 +48197,13 @@ type AddFieldClauseContext struct { func NewEmptyAddFieldClauseContext() *AddFieldClauseContext { var p = new(AddFieldClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addFieldClause + p.RuleIndex = StarRocksSQLParserRULE_addFieldClause return p } func InitEmptyAddFieldClauseContext(p *AddFieldClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addFieldClause + p.RuleIndex = StarRocksSQLParserRULE_addFieldClause } func (*AddFieldClauseContext) IsAddFieldClauseContext() {} @@ -48214,7 +48214,7 @@ func NewAddFieldClauseContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addFieldClause + p.RuleIndex = StarRocksSQLParserRULE_addFieldClause return p } @@ -48222,11 +48222,11 @@ func NewAddFieldClauseContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *AddFieldClauseContext) GetParser() antlr.Parser { return s.parser } func (s *AddFieldClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *AddFieldClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *AddFieldClauseContext) AllIdentifier() []IIdentifierContext { @@ -48271,11 +48271,11 @@ func (s *AddFieldClauseContext) Identifier(i int) IIdentifierContext { } func (s *AddFieldClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddFieldClauseContext) FIELD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIELD, 0) + return s.GetToken(StarRocksSQLParserFIELD, 0) } func (s *AddFieldClauseContext) SubfieldDesc() ISubfieldDescContext { @@ -48295,11 +48295,11 @@ func (s *AddFieldClauseContext) SubfieldDesc() ISubfieldDescContext { } func (s *AddFieldClauseContext) FIRST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIRST, 0) + return s.GetToken(StarRocksSQLParserFIRST, 0) } func (s *AddFieldClauseContext) AFTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAFTER, 0) + return s.GetToken(StarRocksSQLParserAFTER, 0) } func (s *AddFieldClauseContext) Properties() IPropertiesContext { @@ -48327,20 +48327,20 @@ func (s *AddFieldClauseContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *AddFieldClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddFieldClause(s) } } func (s *AddFieldClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddFieldClause(s) } } func (s *AddFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddFieldClause(s) default: @@ -48348,15 +48348,15 @@ func (s *AddFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { +func (p *StarRocksSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { localctx = NewAddFieldClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 304, DorisSQLParserRULE_addFieldClause) + p.EnterRule(localctx, 304, StarRocksSQLParserRULE_addFieldClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3143) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48364,7 +48364,7 @@ func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { } { p.SetState(3144) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48376,7 +48376,7 @@ func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { } { p.SetState(3146) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48384,7 +48384,7 @@ func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { } { p.SetState(3147) - p.Match(DorisSQLParserFIELD) + p.Match(StarRocksSQLParserFIELD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48400,20 +48400,20 @@ func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserFIRST: + case StarRocksSQLParserFIRST: { p.SetState(3149) - p.Match(DorisSQLParserFIRST) + p.Match(StarRocksSQLParserFIRST) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserAFTER: + case StarRocksSQLParserAFTER: { p.SetState(3150) - p.Match(DorisSQLParserAFTER) + p.Match(StarRocksSQLParserAFTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48424,7 +48424,7 @@ func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { p.Identifier() } - case DorisSQLParserEOF, DorisSQLParserT__2, DorisSQLParserPROPERTIES, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserT__2, StarRocksSQLParserPROPERTIES, StarRocksSQLParserSEMICOLON: default: } @@ -48435,7 +48435,7 @@ func (p *DorisSQLParser) AddFieldClause() (localctx IAddFieldClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3154) p.Properties() @@ -48484,13 +48484,13 @@ type DropFieldClauseContext struct { func NewEmptyDropFieldClauseContext() *DropFieldClauseContext { var p = new(DropFieldClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFieldClause + p.RuleIndex = StarRocksSQLParserRULE_dropFieldClause return p } func InitEmptyDropFieldClauseContext(p *DropFieldClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFieldClause + p.RuleIndex = StarRocksSQLParserRULE_dropFieldClause } func (*DropFieldClauseContext) IsDropFieldClauseContext() {} @@ -48501,7 +48501,7 @@ func NewDropFieldClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropFieldClause + p.RuleIndex = StarRocksSQLParserRULE_dropFieldClause return p } @@ -48509,11 +48509,11 @@ func NewDropFieldClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *DropFieldClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DropFieldClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *DropFieldClauseContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *DropFieldClauseContext) Identifier() IIdentifierContext { @@ -48533,11 +48533,11 @@ func (s *DropFieldClauseContext) Identifier() IIdentifierContext { } func (s *DropFieldClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropFieldClauseContext) FIELD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIELD, 0) + return s.GetToken(StarRocksSQLParserFIELD, 0) } func (s *DropFieldClauseContext) NestedFieldName() INestedFieldNameContext { @@ -48581,20 +48581,20 @@ func (s *DropFieldClauseContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *DropFieldClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropFieldClause(s) } } func (s *DropFieldClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropFieldClause(s) } } func (s *DropFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropFieldClause(s) default: @@ -48602,15 +48602,15 @@ func (s *DropFieldClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) DropFieldClause() (localctx IDropFieldClauseContext) { +func (p *StarRocksSQLParser) DropFieldClause() (localctx IDropFieldClauseContext) { localctx = NewDropFieldClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 306, DorisSQLParserRULE_dropFieldClause) + p.EnterRule(localctx, 306, StarRocksSQLParserRULE_dropFieldClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3157) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48618,7 +48618,7 @@ func (p *DorisSQLParser) DropFieldClause() (localctx IDropFieldClauseContext) { } { p.SetState(3158) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48630,7 +48630,7 @@ func (p *DorisSQLParser) DropFieldClause() (localctx IDropFieldClauseContext) { } { p.SetState(3160) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48638,7 +48638,7 @@ func (p *DorisSQLParser) DropFieldClause() (localctx IDropFieldClauseContext) { } { p.SetState(3161) - p.Match(DorisSQLParserFIELD) + p.Match(StarRocksSQLParserFIELD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48655,7 +48655,7 @@ func (p *DorisSQLParser) DropFieldClause() (localctx IDropFieldClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3163) p.Properties() @@ -48706,13 +48706,13 @@ type CreateOrReplaceTagClauseContext struct { func NewEmptyCreateOrReplaceTagClauseContext() *CreateOrReplaceTagClauseContext { var p = new(CreateOrReplaceTagClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createOrReplaceTagClause + p.RuleIndex = StarRocksSQLParserRULE_createOrReplaceTagClause return p } func InitEmptyCreateOrReplaceTagClauseContext(p *CreateOrReplaceTagClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createOrReplaceTagClause + p.RuleIndex = StarRocksSQLParserRULE_createOrReplaceTagClause } func (*CreateOrReplaceTagClauseContext) IsCreateOrReplaceTagClauseContext() {} @@ -48723,7 +48723,7 @@ func NewCreateOrReplaceTagClauseContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createOrReplaceTagClause + p.RuleIndex = StarRocksSQLParserRULE_createOrReplaceTagClause return p } @@ -48731,11 +48731,11 @@ func NewCreateOrReplaceTagClauseContext(parser antlr.Parser, parent antlr.Parser func (s *CreateOrReplaceTagClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CreateOrReplaceTagClauseContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *CreateOrReplaceTagClauseContext) TAG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTAG, 0) + return s.GetToken(StarRocksSQLParserTAG, 0) } func (s *CreateOrReplaceTagClauseContext) Identifier() IIdentifierContext { @@ -48771,23 +48771,23 @@ func (s *CreateOrReplaceTagClauseContext) TagOptions() ITagOptionsContext { } func (s *CreateOrReplaceTagClauseContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateOrReplaceTagClauseContext) OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOR, 0) + return s.GetToken(StarRocksSQLParserOR, 0) } func (s *CreateOrReplaceTagClauseContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateOrReplaceTagClauseContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateOrReplaceTagClauseContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateOrReplaceTagClauseContext) GetRuleContext() antlr.RuleContext { @@ -48799,20 +48799,20 @@ func (s *CreateOrReplaceTagClauseContext) ToStringTree(ruleNames []string, recog } func (s *CreateOrReplaceTagClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateOrReplaceTagClause(s) } } func (s *CreateOrReplaceTagClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateOrReplaceTagClause(s) } } func (s *CreateOrReplaceTagClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateOrReplaceTagClause(s) default: @@ -48820,9 +48820,9 @@ func (s *CreateOrReplaceTagClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTagClauseContext) { +func (p *StarRocksSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTagClauseContext) { localctx = NewCreateOrReplaceTagClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 308, DorisSQLParserRULE_createOrReplaceTagClause) + p.EnterRule(localctx, 308, StarRocksSQLParserRULE_createOrReplaceTagClause) var _la int p.SetState(3185) @@ -48841,10 +48841,10 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCREATE { + if _la == StarRocksSQLParserCREATE { { p.SetState(3166) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48852,7 +48852,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } { p.SetState(3167) - p.Match(DorisSQLParserOR) + p.Match(StarRocksSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48862,7 +48862,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } { p.SetState(3170) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48870,7 +48870,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } { p.SetState(3171) - p.Match(DorisSQLParserTAG) + p.Match(StarRocksSQLParserTAG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48889,7 +48889,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa p.EnterOuterAlt(localctx, 2) { p.SetState(3175) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48897,7 +48897,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } { p.SetState(3176) - p.Match(DorisSQLParserTAG) + p.Match(StarRocksSQLParserTAG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48910,10 +48910,10 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3177) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48921,7 +48921,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } { p.SetState(3178) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48929,7 +48929,7 @@ func (p *DorisSQLParser) CreateOrReplaceTagClause() (localctx ICreateOrReplaceTa } { p.SetState(3179) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -48993,13 +48993,13 @@ type CreateOrReplaceBranchClauseContext struct { func NewEmptyCreateOrReplaceBranchClauseContext() *CreateOrReplaceBranchClauseContext { var p = new(CreateOrReplaceBranchClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createOrReplaceBranchClause + p.RuleIndex = StarRocksSQLParserRULE_createOrReplaceBranchClause return p } func InitEmptyCreateOrReplaceBranchClauseContext(p *CreateOrReplaceBranchClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createOrReplaceBranchClause + p.RuleIndex = StarRocksSQLParserRULE_createOrReplaceBranchClause } func (*CreateOrReplaceBranchClauseContext) IsCreateOrReplaceBranchClauseContext() {} @@ -49010,7 +49010,7 @@ func NewCreateOrReplaceBranchClauseContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createOrReplaceBranchClause + p.RuleIndex = StarRocksSQLParserRULE_createOrReplaceBranchClause return p } @@ -49018,11 +49018,11 @@ func NewCreateOrReplaceBranchClauseContext(parser antlr.Parser, parent antlr.Par func (s *CreateOrReplaceBranchClauseContext) GetParser() antlr.Parser { return s.parser } func (s *CreateOrReplaceBranchClauseContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *CreateOrReplaceBranchClauseContext) BRANCH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBRANCH, 0) + return s.GetToken(StarRocksSQLParserBRANCH, 0) } func (s *CreateOrReplaceBranchClauseContext) Identifier() IIdentifierContext { @@ -49058,23 +49058,23 @@ func (s *CreateOrReplaceBranchClauseContext) BranchOptions() IBranchOptionsConte } func (s *CreateOrReplaceBranchClauseContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateOrReplaceBranchClauseContext) OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOR, 0) + return s.GetToken(StarRocksSQLParserOR, 0) } func (s *CreateOrReplaceBranchClauseContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateOrReplaceBranchClauseContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateOrReplaceBranchClauseContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateOrReplaceBranchClauseContext) GetRuleContext() antlr.RuleContext { @@ -49086,20 +49086,20 @@ func (s *CreateOrReplaceBranchClauseContext) ToStringTree(ruleNames []string, re } func (s *CreateOrReplaceBranchClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateOrReplaceBranchClause(s) } } func (s *CreateOrReplaceBranchClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateOrReplaceBranchClause(s) } } func (s *CreateOrReplaceBranchClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateOrReplaceBranchClause(s) default: @@ -49107,9 +49107,9 @@ func (s *CreateOrReplaceBranchClauseContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplaceBranchClauseContext) { +func (p *StarRocksSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplaceBranchClauseContext) { localctx = NewCreateOrReplaceBranchClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 310, DorisSQLParserRULE_createOrReplaceBranchClause) + p.EnterRule(localctx, 310, StarRocksSQLParserRULE_createOrReplaceBranchClause) var _la int p.SetState(3206) @@ -49128,10 +49128,10 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCREATE { + if _la == StarRocksSQLParserCREATE { { p.SetState(3187) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49139,7 +49139,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } { p.SetState(3188) - p.Match(DorisSQLParserOR) + p.Match(StarRocksSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49149,7 +49149,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } { p.SetState(3191) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49157,7 +49157,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } { p.SetState(3192) - p.Match(DorisSQLParserBRANCH) + p.Match(StarRocksSQLParserBRANCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49176,7 +49176,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac p.EnterOuterAlt(localctx, 2) { p.SetState(3196) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49184,7 +49184,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } { p.SetState(3197) - p.Match(DorisSQLParserBRANCH) + p.Match(StarRocksSQLParserBRANCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49197,10 +49197,10 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3198) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49208,7 +49208,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } { p.SetState(3199) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49216,7 +49216,7 @@ func (p *DorisSQLParser) CreateOrReplaceBranchClause() (localctx ICreateOrReplac } { p.SetState(3200) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49276,13 +49276,13 @@ type DropBranchClauseContext struct { func NewEmptyDropBranchClauseContext() *DropBranchClauseContext { var p = new(DropBranchClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropBranchClause + p.RuleIndex = StarRocksSQLParserRULE_dropBranchClause return p } func InitEmptyDropBranchClauseContext(p *DropBranchClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropBranchClause + p.RuleIndex = StarRocksSQLParserRULE_dropBranchClause } func (*DropBranchClauseContext) IsDropBranchClauseContext() {} @@ -49293,7 +49293,7 @@ func NewDropBranchClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropBranchClause + p.RuleIndex = StarRocksSQLParserRULE_dropBranchClause return p } @@ -49301,11 +49301,11 @@ func NewDropBranchClauseContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *DropBranchClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DropBranchClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropBranchClauseContext) BRANCH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBRANCH, 0) + return s.GetToken(StarRocksSQLParserBRANCH, 0) } func (s *DropBranchClauseContext) Identifier() IIdentifierContext { @@ -49325,11 +49325,11 @@ func (s *DropBranchClauseContext) Identifier() IIdentifierContext { } func (s *DropBranchClauseContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropBranchClauseContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropBranchClauseContext) GetRuleContext() antlr.RuleContext { @@ -49341,20 +49341,20 @@ func (s *DropBranchClauseContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *DropBranchClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropBranchClause(s) } } func (s *DropBranchClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropBranchClause(s) } } func (s *DropBranchClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropBranchClause(s) default: @@ -49362,15 +49362,15 @@ func (s *DropBranchClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) DropBranchClause() (localctx IDropBranchClauseContext) { +func (p *StarRocksSQLParser) DropBranchClause() (localctx IDropBranchClauseContext) { localctx = NewDropBranchClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 312, DorisSQLParserRULE_dropBranchClause) + p.EnterRule(localctx, 312, StarRocksSQLParserRULE_dropBranchClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3208) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49378,7 +49378,7 @@ func (p *DorisSQLParser) DropBranchClause() (localctx IDropBranchClauseContext) } { p.SetState(3209) - p.Match(DorisSQLParserBRANCH) + p.Match(StarRocksSQLParserBRANCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49391,10 +49391,10 @@ func (p *DorisSQLParser) DropBranchClause() (localctx IDropBranchClauseContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3210) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49402,7 +49402,7 @@ func (p *DorisSQLParser) DropBranchClause() (localctx IDropBranchClauseContext) } { p.SetState(3211) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49454,13 +49454,13 @@ type DropTagClauseContext struct { func NewEmptyDropTagClauseContext() *DropTagClauseContext { var p = new(DropTagClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropTagClause + p.RuleIndex = StarRocksSQLParserRULE_dropTagClause return p } func InitEmptyDropTagClauseContext(p *DropTagClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropTagClause + p.RuleIndex = StarRocksSQLParserRULE_dropTagClause } func (*DropTagClauseContext) IsDropTagClauseContext() {} @@ -49471,7 +49471,7 @@ func NewDropTagClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropTagClause + p.RuleIndex = StarRocksSQLParserRULE_dropTagClause return p } @@ -49479,11 +49479,11 @@ func NewDropTagClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *DropTagClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DropTagClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropTagClauseContext) TAG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTAG, 0) + return s.GetToken(StarRocksSQLParserTAG, 0) } func (s *DropTagClauseContext) Identifier() IIdentifierContext { @@ -49503,11 +49503,11 @@ func (s *DropTagClauseContext) Identifier() IIdentifierContext { } func (s *DropTagClauseContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropTagClauseContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropTagClauseContext) GetRuleContext() antlr.RuleContext { @@ -49519,20 +49519,20 @@ func (s *DropTagClauseContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *DropTagClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropTagClause(s) } } func (s *DropTagClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropTagClause(s) } } func (s *DropTagClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropTagClause(s) default: @@ -49540,15 +49540,15 @@ func (s *DropTagClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) DropTagClause() (localctx IDropTagClauseContext) { +func (p *StarRocksSQLParser) DropTagClause() (localctx IDropTagClauseContext) { localctx = NewDropTagClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 314, DorisSQLParserRULE_dropTagClause) + p.EnterRule(localctx, 314, StarRocksSQLParserRULE_dropTagClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3216) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49556,7 +49556,7 @@ func (p *DorisSQLParser) DropTagClause() (localctx IDropTagClauseContext) { } { p.SetState(3217) - p.Match(DorisSQLParserTAG) + p.Match(StarRocksSQLParserTAG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49569,10 +49569,10 @@ func (p *DorisSQLParser) DropTagClause() (localctx IDropTagClauseContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3218) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49580,7 +49580,7 @@ func (p *DorisSQLParser) DropTagClause() (localctx IDropTagClauseContext) { } { p.SetState(3219) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49629,13 +49629,13 @@ type TableOperationClauseContext struct { func NewEmptyTableOperationClauseContext() *TableOperationClauseContext { var p = new(TableOperationClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableOperationClause + p.RuleIndex = StarRocksSQLParserRULE_tableOperationClause return p } func InitEmptyTableOperationClauseContext(p *TableOperationClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableOperationClause + p.RuleIndex = StarRocksSQLParserRULE_tableOperationClause } func (*TableOperationClauseContext) IsTableOperationClauseContext() {} @@ -49646,7 +49646,7 @@ func NewTableOperationClauseContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tableOperationClause + p.RuleIndex = StarRocksSQLParserRULE_tableOperationClause return p } @@ -49654,7 +49654,7 @@ func NewTableOperationClauseContext(parser antlr.Parser, parent antlr.ParserRule func (s *TableOperationClauseContext) GetParser() antlr.Parser { return s.parser } func (s *TableOperationClauseContext) EXECUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXECUTE, 0) + return s.GetToken(StarRocksSQLParserEXECUTE, 0) } func (s *TableOperationClauseContext) FunctionCall() IFunctionCallContext { @@ -49682,20 +49682,20 @@ func (s *TableOperationClauseContext) ToStringTree(ruleNames []string, recog ant } func (s *TableOperationClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTableOperationClause(s) } } func (s *TableOperationClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTableOperationClause(s) } } func (s *TableOperationClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTableOperationClause(s) default: @@ -49703,13 +49703,13 @@ func (s *TableOperationClauseContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) TableOperationClause() (localctx ITableOperationClauseContext) { +func (p *StarRocksSQLParser) TableOperationClause() (localctx ITableOperationClauseContext) { localctx = NewTableOperationClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 316, DorisSQLParserRULE_tableOperationClause) + p.EnterRule(localctx, 316, StarRocksSQLParserRULE_tableOperationClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3224) - p.Match(DorisSQLParserEXECUTE) + p.Match(StarRocksSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49759,13 +49759,13 @@ type TagOptionsContext struct { func NewEmptyTagOptionsContext() *TagOptionsContext { var p = new(TagOptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tagOptions + p.RuleIndex = StarRocksSQLParserRULE_tagOptions return p } func InitEmptyTagOptionsContext(p *TagOptionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tagOptions + p.RuleIndex = StarRocksSQLParserRULE_tagOptions } func (*TagOptionsContext) IsTagOptionsContext() {} @@ -49776,7 +49776,7 @@ func NewTagOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tagOptions + p.RuleIndex = StarRocksSQLParserRULE_tagOptions return p } @@ -49784,15 +49784,15 @@ func NewTagOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *TagOptionsContext) GetParser() antlr.Parser { return s.parser } func (s *TagOptionsContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *TagOptionsContext) OF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOF, 0) + return s.GetToken(StarRocksSQLParserOF, 0) } func (s *TagOptionsContext) VERSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERSION, 0) + return s.GetToken(StarRocksSQLParserVERSION, 0) } func (s *TagOptionsContext) SnapshotId() ISnapshotIdContext { @@ -49836,20 +49836,20 @@ func (s *TagOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *TagOptionsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTagOptions(s) } } func (s *TagOptionsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTagOptions(s) } } func (s *TagOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTagOptions(s) default: @@ -49857,9 +49857,9 @@ func (s *TagOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TagOptions() (localctx ITagOptionsContext) { +func (p *StarRocksSQLParser) TagOptions() (localctx ITagOptionsContext) { localctx = NewTagOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 318, DorisSQLParserRULE_tagOptions) + p.EnterRule(localctx, 318, StarRocksSQLParserRULE_tagOptions) var _la int p.EnterOuterAlt(localctx, 1) @@ -49870,10 +49870,10 @@ func (p *DorisSQLParser) TagOptions() (localctx ITagOptionsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(3227) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49881,7 +49881,7 @@ func (p *DorisSQLParser) TagOptions() (localctx ITagOptionsContext) { } { p.SetState(3228) - p.Match(DorisSQLParserOF) + p.Match(StarRocksSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49889,7 +49889,7 @@ func (p *DorisSQLParser) TagOptions() (localctx ITagOptionsContext) { } { p.SetState(3229) - p.Match(DorisSQLParserVERSION) + p.Match(StarRocksSQLParserVERSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -49908,7 +49908,7 @@ func (p *DorisSQLParser) TagOptions() (localctx ITagOptionsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserRETAIN { + if _la == StarRocksSQLParserRETAIN { { p.SetState(3233) p.RefRetain() @@ -49956,13 +49956,13 @@ type BranchOptionsContext struct { func NewEmptyBranchOptionsContext() *BranchOptionsContext { var p = new(BranchOptionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_branchOptions + p.RuleIndex = StarRocksSQLParserRULE_branchOptions return p } func InitEmptyBranchOptionsContext(p *BranchOptionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_branchOptions + p.RuleIndex = StarRocksSQLParserRULE_branchOptions } func (*BranchOptionsContext) IsBranchOptionsContext() {} @@ -49973,7 +49973,7 @@ func NewBranchOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_branchOptions + p.RuleIndex = StarRocksSQLParserRULE_branchOptions return p } @@ -49981,15 +49981,15 @@ func NewBranchOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *BranchOptionsContext) GetParser() antlr.Parser { return s.parser } func (s *BranchOptionsContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *BranchOptionsContext) OF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOF, 0) + return s.GetToken(StarRocksSQLParserOF, 0) } func (s *BranchOptionsContext) VERSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERSION, 0) + return s.GetToken(StarRocksSQLParserVERSION, 0) } func (s *BranchOptionsContext) SnapshotId() ISnapshotIdContext { @@ -50049,20 +50049,20 @@ func (s *BranchOptionsContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *BranchOptionsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBranchOptions(s) } } func (s *BranchOptionsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBranchOptions(s) } } func (s *BranchOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBranchOptions(s) default: @@ -50070,9 +50070,9 @@ func (s *BranchOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) BranchOptions() (localctx IBranchOptionsContext) { +func (p *StarRocksSQLParser) BranchOptions() (localctx IBranchOptionsContext) { localctx = NewBranchOptionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 320, DorisSQLParserRULE_branchOptions) + p.EnterRule(localctx, 320, StarRocksSQLParserRULE_branchOptions) var _la int p.EnterOuterAlt(localctx, 1) @@ -50083,10 +50083,10 @@ func (p *DorisSQLParser) BranchOptions() (localctx IBranchOptionsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(3236) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50094,7 +50094,7 @@ func (p *DorisSQLParser) BranchOptions() (localctx IBranchOptionsContext) { } { p.SetState(3237) - p.Match(DorisSQLParserOF) + p.Match(StarRocksSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50102,7 +50102,7 @@ func (p *DorisSQLParser) BranchOptions() (localctx IBranchOptionsContext) { } { p.SetState(3238) - p.Match(DorisSQLParserVERSION) + p.Match(StarRocksSQLParserVERSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50121,7 +50121,7 @@ func (p *DorisSQLParser) BranchOptions() (localctx IBranchOptionsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserRETAIN { + if _la == StarRocksSQLParserRETAIN { { p.SetState(3242) p.RefRetain() @@ -50135,7 +50135,7 @@ func (p *DorisSQLParser) BranchOptions() (localctx IBranchOptionsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(3245) p.SnapshotRetention() @@ -50182,13 +50182,13 @@ type SnapshotRetentionContext struct { func NewEmptySnapshotRetentionContext() *SnapshotRetentionContext { var p = new(SnapshotRetentionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_snapshotRetention + p.RuleIndex = StarRocksSQLParserRULE_snapshotRetention return p } func InitEmptySnapshotRetentionContext(p *SnapshotRetentionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_snapshotRetention + p.RuleIndex = StarRocksSQLParserRULE_snapshotRetention } func (*SnapshotRetentionContext) IsSnapshotRetentionContext() {} @@ -50199,7 +50199,7 @@ func NewSnapshotRetentionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_snapshotRetention + p.RuleIndex = StarRocksSQLParserRULE_snapshotRetention return p } @@ -50207,15 +50207,15 @@ func NewSnapshotRetentionContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *SnapshotRetentionContext) GetParser() antlr.Parser { return s.parser } func (s *SnapshotRetentionContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *SnapshotRetentionContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *SnapshotRetentionContext) RETENTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETENTION, 0) + return s.GetToken(StarRocksSQLParserRETENTION, 0) } func (s *SnapshotRetentionContext) MinSnapshotsToKeep() IMinSnapshotsToKeepContext { @@ -50259,20 +50259,20 @@ func (s *SnapshotRetentionContext) ToStringTree(ruleNames []string, recog antlr. } func (s *SnapshotRetentionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSnapshotRetention(s) } } func (s *SnapshotRetentionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSnapshotRetention(s) } } func (s *SnapshotRetentionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSnapshotRetention(s) default: @@ -50280,9 +50280,9 @@ func (s *SnapshotRetentionContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext) { +func (p *StarRocksSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext) { localctx = NewSnapshotRetentionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 322, DorisSQLParserRULE_snapshotRetention) + p.EnterRule(localctx, 322, StarRocksSQLParserRULE_snapshotRetention) p.SetState(3262) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -50294,7 +50294,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext p.EnterOuterAlt(localctx, 1) { p.SetState(3248) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50302,7 +50302,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext } { p.SetState(3249) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50310,7 +50310,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext } { p.SetState(3250) - p.Match(DorisSQLParserRETENTION) + p.Match(StarRocksSQLParserRETENTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50325,7 +50325,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext p.EnterOuterAlt(localctx, 2) { p.SetState(3252) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50333,7 +50333,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext } { p.SetState(3253) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50341,7 +50341,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext } { p.SetState(3254) - p.Match(DorisSQLParserRETENTION) + p.Match(StarRocksSQLParserRETENTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50356,7 +50356,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext p.EnterOuterAlt(localctx, 3) { p.SetState(3256) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50364,7 +50364,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext } { p.SetState(3257) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50372,7 +50372,7 @@ func (p *DorisSQLParser) SnapshotRetention() (localctx ISnapshotRetentionContext } { p.SetState(3258) - p.Match(DorisSQLParserRETENTION) + p.Match(StarRocksSQLParserRETENTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50428,13 +50428,13 @@ type RefRetainContext struct { func NewEmptyRefRetainContext() *RefRetainContext { var p = new(RefRetainContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refRetain + p.RuleIndex = StarRocksSQLParserRULE_refRetain return p } func InitEmptyRefRetainContext(p *RefRetainContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refRetain + p.RuleIndex = StarRocksSQLParserRULE_refRetain } func (*RefRetainContext) IsRefRetainContext() {} @@ -50445,7 +50445,7 @@ func NewRefRetainContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_refRetain + p.RuleIndex = StarRocksSQLParserRULE_refRetain return p } @@ -50453,7 +50453,7 @@ func NewRefRetainContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *RefRetainContext) GetParser() antlr.Parser { return s.parser } func (s *RefRetainContext) RETAIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETAIN, 0) + return s.GetToken(StarRocksSQLParserRETAIN, 0) } func (s *RefRetainContext) Number() INumberContext { @@ -50497,20 +50497,20 @@ func (s *RefRetainContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *RefRetainContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRefRetain(s) } } func (s *RefRetainContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRefRetain(s) } } func (s *RefRetainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRefRetain(s) default: @@ -50518,13 +50518,13 @@ func (s *RefRetainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) RefRetain() (localctx IRefRetainContext) { +func (p *StarRocksSQLParser) RefRetain() (localctx IRefRetainContext) { localctx = NewRefRetainContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 324, DorisSQLParserRULE_refRetain) + p.EnterRule(localctx, 324, StarRocksSQLParserRULE_refRetain) p.EnterOuterAlt(localctx, 1) { p.SetState(3264) - p.Match(DorisSQLParserRETAIN) + p.Match(StarRocksSQLParserRETAIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50575,13 +50575,13 @@ type MaxSnapshotAgeContext struct { func NewEmptyMaxSnapshotAgeContext() *MaxSnapshotAgeContext { var p = new(MaxSnapshotAgeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_maxSnapshotAge + p.RuleIndex = StarRocksSQLParserRULE_maxSnapshotAge return p } func InitEmptyMaxSnapshotAgeContext(p *MaxSnapshotAgeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_maxSnapshotAge + p.RuleIndex = StarRocksSQLParserRULE_maxSnapshotAge } func (*MaxSnapshotAgeContext) IsMaxSnapshotAgeContext() {} @@ -50592,7 +50592,7 @@ func NewMaxSnapshotAgeContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_maxSnapshotAge + p.RuleIndex = StarRocksSQLParserRULE_maxSnapshotAge return p } @@ -50640,20 +50640,20 @@ func (s *MaxSnapshotAgeContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *MaxSnapshotAgeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMaxSnapshotAge(s) } } func (s *MaxSnapshotAgeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMaxSnapshotAge(s) } } func (s *MaxSnapshotAgeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMaxSnapshotAge(s) default: @@ -50661,9 +50661,9 @@ func (s *MaxSnapshotAgeContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) MaxSnapshotAge() (localctx IMaxSnapshotAgeContext) { +func (p *StarRocksSQLParser) MaxSnapshotAge() (localctx IMaxSnapshotAgeContext) { localctx = NewMaxSnapshotAgeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 326, DorisSQLParserRULE_maxSnapshotAge) + p.EnterRule(localctx, 326, StarRocksSQLParserRULE_maxSnapshotAge) p.EnterOuterAlt(localctx, 1) { p.SetState(3268) @@ -50710,13 +50710,13 @@ type MinSnapshotsToKeepContext struct { func NewEmptyMinSnapshotsToKeepContext() *MinSnapshotsToKeepContext { var p = new(MinSnapshotsToKeepContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_minSnapshotsToKeep + p.RuleIndex = StarRocksSQLParserRULE_minSnapshotsToKeep return p } func InitEmptyMinSnapshotsToKeepContext(p *MinSnapshotsToKeepContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_minSnapshotsToKeep + p.RuleIndex = StarRocksSQLParserRULE_minSnapshotsToKeep } func (*MinSnapshotsToKeepContext) IsMinSnapshotsToKeepContext() {} @@ -50727,7 +50727,7 @@ func NewMinSnapshotsToKeepContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_minSnapshotsToKeep + p.RuleIndex = StarRocksSQLParserRULE_minSnapshotsToKeep return p } @@ -50751,7 +50751,7 @@ func (s *MinSnapshotsToKeepContext) Number() INumberContext { } func (s *MinSnapshotsToKeepContext) SNAPSHOTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOTS, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOTS, 0) } func (s *MinSnapshotsToKeepContext) GetRuleContext() antlr.RuleContext { @@ -50763,20 +50763,20 @@ func (s *MinSnapshotsToKeepContext) ToStringTree(ruleNames []string, recog antlr } func (s *MinSnapshotsToKeepContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMinSnapshotsToKeep(s) } } func (s *MinSnapshotsToKeepContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMinSnapshotsToKeep(s) } } func (s *MinSnapshotsToKeepContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMinSnapshotsToKeep(s) default: @@ -50784,9 +50784,9 @@ func (s *MinSnapshotsToKeepContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) MinSnapshotsToKeep() (localctx IMinSnapshotsToKeepContext) { +func (p *StarRocksSQLParser) MinSnapshotsToKeep() (localctx IMinSnapshotsToKeepContext) { localctx = NewMinSnapshotsToKeepContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 328, DorisSQLParserRULE_minSnapshotsToKeep) + p.EnterRule(localctx, 328, StarRocksSQLParserRULE_minSnapshotsToKeep) p.EnterOuterAlt(localctx, 1) { p.SetState(3271) @@ -50794,7 +50794,7 @@ func (p *DorisSQLParser) MinSnapshotsToKeep() (localctx IMinSnapshotsToKeepConte } { p.SetState(3272) - p.Match(DorisSQLParserSNAPSHOTS) + p.Match(StarRocksSQLParserSNAPSHOTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -50836,13 +50836,13 @@ type SnapshotIdContext struct { func NewEmptySnapshotIdContext() *SnapshotIdContext { var p = new(SnapshotIdContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_snapshotId + p.RuleIndex = StarRocksSQLParserRULE_snapshotId return p } func InitEmptySnapshotIdContext(p *SnapshotIdContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_snapshotId + p.RuleIndex = StarRocksSQLParserRULE_snapshotId } func (*SnapshotIdContext) IsSnapshotIdContext() {} @@ -50853,7 +50853,7 @@ func NewSnapshotIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_snapshotId + p.RuleIndex = StarRocksSQLParserRULE_snapshotId return p } @@ -50885,20 +50885,20 @@ func (s *SnapshotIdContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *SnapshotIdContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSnapshotId(s) } } func (s *SnapshotIdContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSnapshotId(s) } } func (s *SnapshotIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSnapshotId(s) default: @@ -50906,9 +50906,9 @@ func (s *SnapshotIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) SnapshotId() (localctx ISnapshotIdContext) { +func (p *StarRocksSQLParser) SnapshotId() (localctx ISnapshotIdContext) { localctx = NewSnapshotIdContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 330, DorisSQLParserRULE_snapshotId) + p.EnterRule(localctx, 330, StarRocksSQLParserRULE_snapshotId) p.EnterOuterAlt(localctx, 1) { p.SetState(3274) @@ -50952,13 +50952,13 @@ type TimeUnitContext struct { func NewEmptyTimeUnitContext() *TimeUnitContext { var p = new(TimeUnitContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_timeUnit + p.RuleIndex = StarRocksSQLParserRULE_timeUnit return p } func InitEmptyTimeUnitContext(p *TimeUnitContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_timeUnit + p.RuleIndex = StarRocksSQLParserRULE_timeUnit } func (*TimeUnitContext) IsTimeUnitContext() {} @@ -50969,7 +50969,7 @@ func NewTimeUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_timeUnit + p.RuleIndex = StarRocksSQLParserRULE_timeUnit return p } @@ -50977,15 +50977,15 @@ func NewTimeUnitContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *TimeUnitContext) GetParser() antlr.Parser { return s.parser } func (s *TimeUnitContext) DAYS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDAYS, 0) + return s.GetToken(StarRocksSQLParserDAYS, 0) } func (s *TimeUnitContext) HOURS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOURS, 0) + return s.GetToken(StarRocksSQLParserHOURS, 0) } func (s *TimeUnitContext) MINUTES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUTES, 0) + return s.GetToken(StarRocksSQLParserMINUTES, 0) } func (s *TimeUnitContext) GetRuleContext() antlr.RuleContext { @@ -50997,20 +50997,20 @@ func (s *TimeUnitContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *TimeUnitContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTimeUnit(s) } } func (s *TimeUnitContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTimeUnit(s) } } func (s *TimeUnitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTimeUnit(s) default: @@ -51018,9 +51018,9 @@ func (s *TimeUnitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TimeUnit() (localctx ITimeUnitContext) { +func (p *StarRocksSQLParser) TimeUnit() (localctx ITimeUnitContext) { localctx = NewTimeUnitContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 332, DorisSQLParserRULE_timeUnit) + p.EnterRule(localctx, 332, StarRocksSQLParserRULE_timeUnit) var _la int p.EnterOuterAlt(localctx, 1) @@ -51028,7 +51028,7 @@ func (p *DorisSQLParser) TimeUnit() (localctx ITimeUnitContext) { p.SetState(3276) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDAYS || _la == DorisSQLParserHOURS || _la == DorisSQLParserMINUTES) { + if !(_la == StarRocksSQLParserDAYS || _la == StarRocksSQLParserHOURS || _la == StarRocksSQLParserMINUTES) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -51072,13 +51072,13 @@ type Integer_listContext struct { func NewEmptyInteger_listContext() *Integer_listContext { var p = new(Integer_listContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_integer_list + p.RuleIndex = StarRocksSQLParserRULE_integer_list return p } func InitEmptyInteger_listContext(p *Integer_listContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_integer_list + p.RuleIndex = StarRocksSQLParserRULE_integer_list } func (*Integer_listContext) IsInteger_listContext() {} @@ -51089,7 +51089,7 @@ func NewInteger_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_integer_list + p.RuleIndex = StarRocksSQLParserRULE_integer_list return p } @@ -51097,11 +51097,11 @@ func NewInteger_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *Integer_listContext) GetParser() antlr.Parser { return s.parser } func (s *Integer_listContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *Integer_listContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *Integer_listContext) GetRuleContext() antlr.RuleContext { @@ -51113,20 +51113,20 @@ func (s *Integer_listContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *Integer_listContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInteger_list(s) } } func (s *Integer_listContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInteger_list(s) } } func (s *Integer_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInteger_list(s) default: @@ -51134,15 +51134,15 @@ func (s *Integer_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) Integer_list() (localctx IInteger_listContext) { +func (p *StarRocksSQLParser) Integer_list() (localctx IInteger_listContext) { localctx = NewInteger_listContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 334, DorisSQLParserRULE_integer_list) + p.EnterRule(localctx, 334, StarRocksSQLParserRULE_integer_list) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3278) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51150,7 +51150,7 @@ func (p *DorisSQLParser) Integer_list() (localctx IInteger_listContext) { } { p.SetState(3279) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51163,10 +51163,10 @@ func (p *DorisSQLParser) Integer_list() (localctx IInteger_listContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3280) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51174,7 +51174,7 @@ func (p *DorisSQLParser) Integer_list() (localctx IInteger_listContext) { } { p.SetState(3281) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51190,7 +51190,7 @@ func (p *DorisSQLParser) Integer_list() (localctx IInteger_listContext) { } { p.SetState(3287) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51237,13 +51237,13 @@ type DropPersistentIndexClauseContext struct { func NewEmptyDropPersistentIndexClauseContext() *DropPersistentIndexClauseContext { var p = new(DropPersistentIndexClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropPersistentIndexClause + p.RuleIndex = StarRocksSQLParserRULE_dropPersistentIndexClause return p } func InitEmptyDropPersistentIndexClauseContext(p *DropPersistentIndexClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropPersistentIndexClause + p.RuleIndex = StarRocksSQLParserRULE_dropPersistentIndexClause } func (*DropPersistentIndexClauseContext) IsDropPersistentIndexClauseContext() {} @@ -51254,7 +51254,7 @@ func NewDropPersistentIndexClauseContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropPersistentIndexClause + p.RuleIndex = StarRocksSQLParserRULE_dropPersistentIndexClause return p } @@ -51262,23 +51262,23 @@ func NewDropPersistentIndexClauseContext(parser antlr.Parser, parent antlr.Parse func (s *DropPersistentIndexClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DropPersistentIndexClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropPersistentIndexClauseContext) PERSISTENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERSISTENT, 0) + return s.GetToken(StarRocksSQLParserPERSISTENT, 0) } func (s *DropPersistentIndexClauseContext) INDEX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEX, 0) + return s.GetToken(StarRocksSQLParserINDEX, 0) } func (s *DropPersistentIndexClauseContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *DropPersistentIndexClauseContext) TABLETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLETS, 0) + return s.GetToken(StarRocksSQLParserTABLETS, 0) } func (s *DropPersistentIndexClauseContext) Integer_list() IInteger_listContext { @@ -51306,20 +51306,20 @@ func (s *DropPersistentIndexClauseContext) ToStringTree(ruleNames []string, reco } func (s *DropPersistentIndexClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropPersistentIndexClause(s) } } func (s *DropPersistentIndexClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropPersistentIndexClause(s) } } func (s *DropPersistentIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropPersistentIndexClause(s) default: @@ -51327,13 +51327,13 @@ func (s *DropPersistentIndexClauseContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) DropPersistentIndexClause() (localctx IDropPersistentIndexClauseContext) { +func (p *StarRocksSQLParser) DropPersistentIndexClause() (localctx IDropPersistentIndexClauseContext) { localctx = NewDropPersistentIndexClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 336, DorisSQLParserRULE_dropPersistentIndexClause) + p.EnterRule(localctx, 336, StarRocksSQLParserRULE_dropPersistentIndexClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3289) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51341,7 +51341,7 @@ func (p *DorisSQLParser) DropPersistentIndexClause() (localctx IDropPersistentIn } { p.SetState(3290) - p.Match(DorisSQLParserPERSISTENT) + p.Match(StarRocksSQLParserPERSISTENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51349,7 +51349,7 @@ func (p *DorisSQLParser) DropPersistentIndexClause() (localctx IDropPersistentIn } { p.SetState(3291) - p.Match(DorisSQLParserINDEX) + p.Match(StarRocksSQLParserINDEX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51357,7 +51357,7 @@ func (p *DorisSQLParser) DropPersistentIndexClause() (localctx IDropPersistentIn } { p.SetState(3292) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51365,7 +51365,7 @@ func (p *DorisSQLParser) DropPersistentIndexClause() (localctx IDropPersistentIn } { p.SetState(3293) - p.Match(DorisSQLParserTABLETS) + p.Match(StarRocksSQLParserTABLETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51419,13 +51419,13 @@ type AddPartitionClauseContext struct { func NewEmptyAddPartitionClauseContext() *AddPartitionClauseContext { var p = new(AddPartitionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_addPartitionClause return p } func InitEmptyAddPartitionClauseContext(p *AddPartitionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_addPartitionClause } func (*AddPartitionClauseContext) IsAddPartitionClauseContext() {} @@ -51436,7 +51436,7 @@ func NewAddPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_addPartitionClause return p } @@ -51444,7 +51444,7 @@ func NewAddPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *AddPartitionClauseContext) GetParser() antlr.Parser { return s.parser } func (s *AddPartitionClauseContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddPartitionClauseContext) SingleRangePartition() ISingleRangePartitionContext { @@ -51464,7 +51464,7 @@ func (s *AddPartitionClauseContext) SingleRangePartition() ISingleRangePartition } func (s *AddPartitionClauseContext) PARTITIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITIONS, 0) + return s.GetToken(StarRocksSQLParserPARTITIONS, 0) } func (s *AddPartitionClauseContext) MultiRangePartition() IMultiRangePartitionContext { @@ -51484,7 +51484,7 @@ func (s *AddPartitionClauseContext) MultiRangePartition() IMultiRangePartitionCo } func (s *AddPartitionClauseContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *AddPartitionClauseContext) DistributionDesc() IDistributionDescContext { @@ -51560,20 +51560,20 @@ func (s *AddPartitionClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *AddPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddPartitionClause(s) } } func (s *AddPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddPartitionClause(s) } } func (s *AddPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddPartitionClause(s) default: @@ -51581,9 +51581,9 @@ func (s *AddPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseContext) { +func (p *StarRocksSQLParser) AddPartitionClause() (localctx IAddPartitionClauseContext) { localctx = NewAddPartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 338, DorisSQLParserRULE_addPartitionClause) + p.EnterRule(localctx, 338, StarRocksSQLParserRULE_addPartitionClause) var _la int p.SetState(3325) @@ -51597,7 +51597,7 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte p.EnterOuterAlt(localctx, 1) { p.SetState(3296) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51610,10 +51610,10 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(3297) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51628,16 +51628,16 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } switch p.GetTokenStream().LA(1) { - case DorisSQLParserPARTITION: + case StarRocksSQLParserPARTITION: { p.SetState(3300) p.SingleRangePartition() } - case DorisSQLParserPARTITIONS: + case StarRocksSQLParserPARTITIONS: { p.SetState(3301) - p.Match(DorisSQLParserPARTITIONS) + p.Match(StarRocksSQLParserPARTITIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51659,7 +51659,7 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDISTRIBUTED { + if _la == StarRocksSQLParserDISTRIBUTED { { p.SetState(3305) p.DistributionDesc() @@ -51673,7 +51673,7 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3308) p.Properties() @@ -51685,7 +51685,7 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte p.EnterOuterAlt(localctx, 2) { p.SetState(3311) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51698,10 +51698,10 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(3312) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -51738,7 +51738,7 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDISTRIBUTED { + if _la == StarRocksSQLParserDISTRIBUTED { { p.SetState(3319) p.DistributionDesc() @@ -51752,7 +51752,7 @@ func (p *DorisSQLParser) AddPartitionClause() (localctx IAddPartitionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3322) p.Properties() @@ -51818,13 +51818,13 @@ type DropPartitionClauseContext struct { func NewEmptyDropPartitionClauseContext() *DropPartitionClauseContext { var p = new(DropPartitionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_dropPartitionClause return p } func InitEmptyDropPartitionClauseContext(p *DropPartitionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_dropPartitionClause } func (*DropPartitionClauseContext) IsDropPartitionClauseContext() {} @@ -51835,7 +51835,7 @@ func NewDropPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_dropPartitionClause return p } @@ -51847,11 +51847,11 @@ func (s *DropPartitionClauseContext) GetWhere() IExpressionContext { return s.wh func (s *DropPartitionClauseContext) SetWhere(v IExpressionContext) { s.where = v } func (s *DropPartitionClauseContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropPartitionClauseContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *DropPartitionClauseContext) Identifier() IIdentifierContext { @@ -51871,7 +51871,7 @@ func (s *DropPartitionClauseContext) Identifier() IIdentifierContext { } func (s *DropPartitionClauseContext) PARTITIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITIONS, 0) + return s.GetToken(StarRocksSQLParserPARTITIONS, 0) } func (s *DropPartitionClauseContext) IdentifierList() IIdentifierListContext { @@ -51891,19 +51891,19 @@ func (s *DropPartitionClauseContext) IdentifierList() IIdentifierListContext { } func (s *DropPartitionClauseContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *DropPartitionClauseContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *DropPartitionClauseContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropPartitionClauseContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropPartitionClauseContext) MultiRangePartition() IMultiRangePartitionContext { @@ -51923,7 +51923,7 @@ func (s *DropPartitionClauseContext) MultiRangePartition() IMultiRangePartitionC } func (s *DropPartitionClauseContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *DropPartitionClauseContext) Expression() IExpressionContext { @@ -51943,7 +51943,7 @@ func (s *DropPartitionClauseContext) Expression() IExpressionContext { } func (s *DropPartitionClauseContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *DropPartitionClauseContext) GetRuleContext() antlr.RuleContext { @@ -51955,20 +51955,20 @@ func (s *DropPartitionClauseContext) ToStringTree(ruleNames []string, recog antl } func (s *DropPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropPartitionClause(s) } } func (s *DropPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropPartitionClause(s) } } func (s *DropPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropPartitionClause(s) default: @@ -51976,9 +51976,9 @@ func (s *DropPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseContext) { +func (p *StarRocksSQLParser) DropPartitionClause() (localctx IDropPartitionClauseContext) { localctx = NewDropPartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 340, DorisSQLParserRULE_dropPartitionClause) + p.EnterRule(localctx, 340, StarRocksSQLParserRULE_dropPartitionClause) var _la int p.SetState(3382) @@ -51992,7 +51992,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon p.EnterOuterAlt(localctx, 1) { p.SetState(3327) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52005,10 +52005,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(3328) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52023,10 +52023,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } switch p.GetTokenStream().LA(1) { - case DorisSQLParserPARTITION: + case StarRocksSQLParserPARTITION: { p.SetState(3331) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52039,10 +52039,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3332) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52050,7 +52050,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3333) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52063,10 +52063,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon p.Identifier() } - case DorisSQLParserPARTITIONS: + case StarRocksSQLParserPARTITIONS: { p.SetState(3337) - p.Match(DorisSQLParserPARTITIONS) + p.Match(StarRocksSQLParserPARTITIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52079,10 +52079,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3338) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52090,7 +52090,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3339) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52114,10 +52114,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(3345) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52130,7 +52130,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon p.EnterOuterAlt(localctx, 2) { p.SetState(3348) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52143,10 +52143,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(3349) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52156,7 +52156,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3352) - p.Match(DorisSQLParserPARTITIONS) + p.Match(StarRocksSQLParserPARTITIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52169,10 +52169,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3353) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52180,7 +52180,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3354) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52199,10 +52199,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(3358) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52215,7 +52215,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon p.EnterOuterAlt(localctx, 3) { p.SetState(3361) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52228,10 +52228,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(3362) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52241,7 +52241,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3365) - p.Match(DorisSQLParserPARTITIONS) + p.Match(StarRocksSQLParserPARTITIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52254,10 +52254,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(3366) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52265,7 +52265,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3367) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52275,7 +52275,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3370) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52295,10 +52295,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(3372) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52311,7 +52311,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon p.EnterOuterAlt(localctx, 4) { p.SetState(3375) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52319,7 +52319,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3376) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52327,7 +52327,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3377) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52335,7 +52335,7 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } { p.SetState(3378) - p.Match(DorisSQLParserPARTITIONS) + p.Match(StarRocksSQLParserPARTITIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52348,10 +52348,10 @@ func (p *DorisSQLParser) DropPartitionClause() (localctx IDropPartitionClauseCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(3379) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52400,13 +52400,13 @@ type TruncatePartitionClauseContext struct { func NewEmptyTruncatePartitionClauseContext() *TruncatePartitionClauseContext { var p = new(TruncatePartitionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_truncatePartitionClause + p.RuleIndex = StarRocksSQLParserRULE_truncatePartitionClause return p } func InitEmptyTruncatePartitionClauseContext(p *TruncatePartitionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_truncatePartitionClause + p.RuleIndex = StarRocksSQLParserRULE_truncatePartitionClause } func (*TruncatePartitionClauseContext) IsTruncatePartitionClauseContext() {} @@ -52417,7 +52417,7 @@ func NewTruncatePartitionClauseContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_truncatePartitionClause + p.RuleIndex = StarRocksSQLParserRULE_truncatePartitionClause return p } @@ -52425,7 +52425,7 @@ func NewTruncatePartitionClauseContext(parser antlr.Parser, parent antlr.ParserR func (s *TruncatePartitionClauseContext) GetParser() antlr.Parser { return s.parser } func (s *TruncatePartitionClauseContext) TRUNCATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRUNCATE, 0) + return s.GetToken(StarRocksSQLParserTRUNCATE, 0) } func (s *TruncatePartitionClauseContext) PartitionNames() IPartitionNamesContext { @@ -52453,20 +52453,20 @@ func (s *TruncatePartitionClauseContext) ToStringTree(ruleNames []string, recog } func (s *TruncatePartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTruncatePartitionClause(s) } } func (s *TruncatePartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTruncatePartitionClause(s) } } func (s *TruncatePartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTruncatePartitionClause(s) default: @@ -52474,13 +52474,13 @@ func (s *TruncatePartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) TruncatePartitionClause() (localctx ITruncatePartitionClauseContext) { +func (p *StarRocksSQLParser) TruncatePartitionClause() (localctx ITruncatePartitionClauseContext) { localctx = NewTruncatePartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 342, DorisSQLParserRULE_truncatePartitionClause) + p.EnterRule(localctx, 342, StarRocksSQLParserRULE_truncatePartitionClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3384) - p.Match(DorisSQLParserTRUNCATE) + p.Match(StarRocksSQLParserTRUNCATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52533,13 +52533,13 @@ type ModifyPartitionClauseContext struct { func NewEmptyModifyPartitionClauseContext() *ModifyPartitionClauseContext { var p = new(ModifyPartitionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_modifyPartitionClause return p } func InitEmptyModifyPartitionClauseContext(p *ModifyPartitionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_modifyPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_modifyPartitionClause } func (*ModifyPartitionClauseContext) IsModifyPartitionClauseContext() {} @@ -52550,7 +52550,7 @@ func NewModifyPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_modifyPartitionClause + p.RuleIndex = StarRocksSQLParserRULE_modifyPartitionClause return p } @@ -52558,15 +52558,15 @@ func NewModifyPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRul func (s *ModifyPartitionClauseContext) GetParser() antlr.Parser { return s.parser } func (s *ModifyPartitionClauseContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *ModifyPartitionClauseContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *ModifyPartitionClauseContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *ModifyPartitionClauseContext) PropertyList() IPropertyListContext { @@ -52618,7 +52618,7 @@ func (s *ModifyPartitionClauseContext) IdentifierList() IIdentifierListContext { } func (s *ModifyPartitionClauseContext) ASTERISK_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASTERISK_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserASTERISK_SYMBOL, 0) } func (s *ModifyPartitionClauseContext) DistributionDesc() IDistributionDescContext { @@ -52646,20 +52646,20 @@ func (s *ModifyPartitionClauseContext) ToStringTree(ruleNames []string, recog an } func (s *ModifyPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterModifyPartitionClause(s) } } func (s *ModifyPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitModifyPartitionClause(s) } } func (s *ModifyPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitModifyPartitionClause(s) default: @@ -52667,9 +52667,9 @@ func (s *ModifyPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClauseContext) { +func (p *StarRocksSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClauseContext) { localctx = NewModifyPartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 344, DorisSQLParserRULE_modifyPartitionClause) + p.EnterRule(localctx, 344, StarRocksSQLParserRULE_modifyPartitionClause) p.SetState(3401) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -52681,7 +52681,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus p.EnterOuterAlt(localctx, 1) { p.SetState(3387) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52689,7 +52689,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus } { p.SetState(3388) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52717,7 +52717,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus case 3: { p.SetState(3391) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52725,7 +52725,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus } { p.SetState(3392) - p.Match(DorisSQLParserASTERISK_SYMBOL) + p.Match(StarRocksSQLParserASTERISK_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52733,7 +52733,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus } { p.SetState(3393) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52745,7 +52745,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus } { p.SetState(3396) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52760,7 +52760,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus p.EnterOuterAlt(localctx, 2) { p.SetState(3398) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52768,7 +52768,7 @@ func (p *DorisSQLParser) ModifyPartitionClause() (localctx IModifyPartitionClaus } { p.SetState(3399) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52836,13 +52836,13 @@ type ReplacePartitionClauseContext struct { func NewEmptyReplacePartitionClauseContext() *ReplacePartitionClauseContext { var p = new(ReplacePartitionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_replacePartitionClause + p.RuleIndex = StarRocksSQLParserRULE_replacePartitionClause return p } func InitEmptyReplacePartitionClauseContext(p *ReplacePartitionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_replacePartitionClause + p.RuleIndex = StarRocksSQLParserRULE_replacePartitionClause } func (*ReplacePartitionClauseContext) IsReplacePartitionClauseContext() {} @@ -52853,7 +52853,7 @@ func NewReplacePartitionClauseContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_replacePartitionClause + p.RuleIndex = StarRocksSQLParserRULE_replacePartitionClause return p } @@ -52869,11 +52869,11 @@ func (s *ReplacePartitionClauseContext) SetParName(v IPartitionNamesContext) { s func (s *ReplacePartitionClauseContext) SetTempParName(v IPartitionNamesContext) { s.tempParName = v } func (s *ReplacePartitionClauseContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *ReplacePartitionClauseContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *ReplacePartitionClauseContext) AllPartitionNames() []IPartitionNamesContext { @@ -52942,20 +52942,20 @@ func (s *ReplacePartitionClauseContext) ToStringTree(ruleNames []string, recog a } func (s *ReplacePartitionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterReplacePartitionClause(s) } } func (s *ReplacePartitionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitReplacePartitionClause(s) } } func (s *ReplacePartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitReplacePartitionClause(s) default: @@ -52963,15 +52963,15 @@ func (s *ReplacePartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ReplacePartitionClause() (localctx IReplacePartitionClauseContext) { +func (p *StarRocksSQLParser) ReplacePartitionClause() (localctx IReplacePartitionClauseContext) { localctx = NewReplacePartitionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 346, DorisSQLParserRULE_replacePartitionClause) + p.EnterRule(localctx, 346, StarRocksSQLParserRULE_replacePartitionClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3403) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -52986,7 +52986,7 @@ func (p *DorisSQLParser) ReplacePartitionClause() (localctx IReplacePartitionCla } { p.SetState(3405) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53006,7 +53006,7 @@ func (p *DorisSQLParser) ReplacePartitionClause() (localctx IReplacePartitionCla } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3407) p.Properties() @@ -53066,13 +53066,13 @@ type PartitionRenameClauseContext struct { func NewEmptyPartitionRenameClauseContext() *PartitionRenameClauseContext { var p = new(PartitionRenameClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionRenameClause + p.RuleIndex = StarRocksSQLParserRULE_partitionRenameClause return p } func InitEmptyPartitionRenameClauseContext(p *PartitionRenameClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionRenameClause + p.RuleIndex = StarRocksSQLParserRULE_partitionRenameClause } func (*PartitionRenameClauseContext) IsPartitionRenameClauseContext() {} @@ -53083,7 +53083,7 @@ func NewPartitionRenameClauseContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionRenameClause + p.RuleIndex = StarRocksSQLParserRULE_partitionRenameClause return p } @@ -53099,11 +53099,11 @@ func (s *PartitionRenameClauseContext) SetParName(v IIdentifierContext) { s.parN func (s *PartitionRenameClauseContext) SetNewParName(v IIdentifierContext) { s.newParName = v } func (s *PartitionRenameClauseContext) RENAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRENAME, 0) + return s.GetToken(StarRocksSQLParserRENAME, 0) } func (s *PartitionRenameClauseContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *PartitionRenameClauseContext) AllIdentifier() []IIdentifierContext { @@ -53156,20 +53156,20 @@ func (s *PartitionRenameClauseContext) ToStringTree(ruleNames []string, recog an } func (s *PartitionRenameClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionRenameClause(s) } } func (s *PartitionRenameClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionRenameClause(s) } } func (s *PartitionRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionRenameClause(s) default: @@ -53177,13 +53177,13 @@ func (s *PartitionRenameClauseContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) PartitionRenameClause() (localctx IPartitionRenameClauseContext) { +func (p *StarRocksSQLParser) PartitionRenameClause() (localctx IPartitionRenameClauseContext) { localctx = NewPartitionRenameClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 348, DorisSQLParserRULE_partitionRenameClause) + p.EnterRule(localctx, 348, StarRocksSQLParserRULE_partitionRenameClause) p.EnterOuterAlt(localctx, 1) { p.SetState(3410) - p.Match(DorisSQLParserRENAME) + p.Match(StarRocksSQLParserRENAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53191,7 +53191,7 @@ func (p *DorisSQLParser) PartitionRenameClause() (localctx IPartitionRenameClaus } { p.SetState(3411) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53263,13 +53263,13 @@ type InsertStatementContext struct { func NewEmptyInsertStatementContext() *InsertStatementContext { var p = new(InsertStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_insertStatement + p.RuleIndex = StarRocksSQLParserRULE_insertStatement return p } func InitEmptyInsertStatementContext(p *InsertStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_insertStatement + p.RuleIndex = StarRocksSQLParserRULE_insertStatement } func (*InsertStatementContext) IsInsertStatementContext() {} @@ -53280,7 +53280,7 @@ func NewInsertStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_insertStatement + p.RuleIndex = StarRocksSQLParserRULE_insertStatement return p } @@ -53288,15 +53288,15 @@ func NewInsertStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *InsertStatementContext) GetParser() antlr.Parser { return s.parser } func (s *InsertStatementContext) INSERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINSERT, 0) + return s.GetToken(StarRocksSQLParserINSERT, 0) } func (s *InsertStatementContext) INTO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTO, 0) + return s.GetToken(StarRocksSQLParserINTO, 0) } func (s *InsertStatementContext) OVERWRITE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOVERWRITE, 0) + return s.GetToken(StarRocksSQLParserOVERWRITE, 0) } func (s *InsertStatementContext) QualifiedName() IQualifiedNameContext { @@ -53405,7 +53405,7 @@ func (s *InsertStatementContext) Properties() IPropertiesContext { } func (s *InsertStatementContext) FILES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILES, 0) + return s.GetToken(StarRocksSQLParserFILES, 0) } func (s *InsertStatementContext) PropertyList() IPropertyListContext { @@ -53425,11 +53425,11 @@ func (s *InsertStatementContext) PropertyList() IPropertyListContext { } func (s *InsertStatementContext) BLACKHOLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKHOLE, 0) + return s.GetToken(StarRocksSQLParserBLACKHOLE, 0) } func (s *InsertStatementContext) VALUES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUES, 0) + return s.GetToken(StarRocksSQLParserVALUES, 0) } func (s *InsertStatementContext) AllExpressionsWithDefault() []IExpressionsWithDefaultContext { @@ -53514,20 +53514,20 @@ func (s *InsertStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *InsertStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInsertStatement(s) } } func (s *InsertStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInsertStatement(s) } } func (s *InsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInsertStatement(s) default: @@ -53535,9 +53535,9 @@ func (s *InsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { +func (p *StarRocksSQLParser) InsertStatement() (localctx IInsertStatementContext) { localctx = NewInsertStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 350, DorisSQLParserRULE_insertStatement) + p.EnterRule(localctx, 350, StarRocksSQLParserRULE_insertStatement) var _la int var _alt int @@ -53559,7 +53559,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } { p.SetState(3418) - p.Match(DorisSQLParserINSERT) + p.Match(StarRocksSQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53569,7 +53569,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { p.SetState(3419) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserINTO || _la == DorisSQLParserOVERWRITE) { + if !(_la == StarRocksSQLParserINTO || _la == StarRocksSQLParserOVERWRITE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -53595,7 +53595,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR || _la == DorisSQLParserVERSION { + if _la == StarRocksSQLParserFOR || _la == StarRocksSQLParserVERSION { { p.SetState(3421) p.WriteBranch() @@ -53609,7 +53609,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(3424) p.PartitionNames() @@ -53620,7 +53620,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { case 2: { p.SetState(3427) - p.Match(DorisSQLParserFILES) + p.Match(StarRocksSQLParserFILES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53634,7 +53634,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { case 3: { p.SetState(3429) - p.Match(DorisSQLParserBLACKHOLE) + p.Match(StarRocksSQLParserBLACKHOLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53642,7 +53642,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } { p.SetState(3430) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53650,7 +53650,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } { p.SetState(3431) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53694,7 +53694,7 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3440) p.Properties() @@ -53708,16 +53708,16 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1, DorisSQLParserDESC, DorisSQLParserDESCRIBE, DorisSQLParserEXPLAIN, DorisSQLParserSELECT, DorisSQLParserTRACE, DorisSQLParserWITH: + case StarRocksSQLParserT__1, StarRocksSQLParserDESC, StarRocksSQLParserDESCRIBE, StarRocksSQLParserEXPLAIN, StarRocksSQLParserSELECT, StarRocksSQLParserTRACE, StarRocksSQLParserWITH: { p.SetState(3443) p.QueryStatement() } - case DorisSQLParserVALUES: + case StarRocksSQLParserVALUES: { p.SetState(3444) - p.Match(DorisSQLParserVALUES) + p.Match(StarRocksSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53734,10 +53734,10 @@ func (p *DorisSQLParser) InsertStatement() (localctx IInsertStatementContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3446) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53806,13 +53806,13 @@ type InsertLabelOrColumnAliasesContext struct { func NewEmptyInsertLabelOrColumnAliasesContext() *InsertLabelOrColumnAliasesContext { var p = new(InsertLabelOrColumnAliasesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_insertLabelOrColumnAliases + p.RuleIndex = StarRocksSQLParserRULE_insertLabelOrColumnAliases return p } func InitEmptyInsertLabelOrColumnAliasesContext(p *InsertLabelOrColumnAliasesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_insertLabelOrColumnAliases + p.RuleIndex = StarRocksSQLParserRULE_insertLabelOrColumnAliases } func (*InsertLabelOrColumnAliasesContext) IsInsertLabelOrColumnAliasesContext() {} @@ -53823,7 +53823,7 @@ func NewInsertLabelOrColumnAliasesContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_insertLabelOrColumnAliases + p.RuleIndex = StarRocksSQLParserRULE_insertLabelOrColumnAliases return p } @@ -53851,11 +53851,11 @@ func (s *InsertLabelOrColumnAliasesContext) ColumnAliasesOrByName() IColumnAlias } func (s *InsertLabelOrColumnAliasesContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *InsertLabelOrColumnAliasesContext) LABEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLABEL, 0) + return s.GetToken(StarRocksSQLParserLABEL, 0) } func (s *InsertLabelOrColumnAliasesContext) Identifier() IIdentifierContext { @@ -53883,20 +53883,20 @@ func (s *InsertLabelOrColumnAliasesContext) ToStringTree(ruleNames []string, rec } func (s *InsertLabelOrColumnAliasesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInsertLabelOrColumnAliases(s) } } func (s *InsertLabelOrColumnAliasesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInsertLabelOrColumnAliases(s) } } func (s *InsertLabelOrColumnAliasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInsertLabelOrColumnAliases(s) default: @@ -53904,9 +53904,9 @@ func (s *InsertLabelOrColumnAliasesContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) InsertLabelOrColumnAliases() (localctx IInsertLabelOrColumnAliasesContext) { +func (p *StarRocksSQLParser) InsertLabelOrColumnAliases() (localctx IInsertLabelOrColumnAliasesContext) { localctx = NewInsertLabelOrColumnAliasesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 352, DorisSQLParserRULE_insertLabelOrColumnAliases) + p.EnterRule(localctx, 352, StarRocksSQLParserRULE_insertLabelOrColumnAliases) p.SetState(3459) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -53914,18 +53914,18 @@ func (p *DorisSQLParser) InsertLabelOrColumnAliases() (localctx IInsertLabelOrCo } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1, DorisSQLParserBY: + case StarRocksSQLParserT__1, StarRocksSQLParserBY: p.EnterOuterAlt(localctx, 1) { p.SetState(3455) p.ColumnAliasesOrByName() } - case DorisSQLParserWITH: + case StarRocksSQLParserWITH: p.EnterOuterAlt(localctx, 2) { p.SetState(3456) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53933,7 +53933,7 @@ func (p *DorisSQLParser) InsertLabelOrColumnAliases() (localctx IInsertLabelOrCo } { p.SetState(3457) - p.Match(DorisSQLParserLABEL) + p.Match(StarRocksSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -53989,13 +53989,13 @@ type ColumnAliasesOrByNameContext struct { func NewEmptyColumnAliasesOrByNameContext() *ColumnAliasesOrByNameContext { var p = new(ColumnAliasesOrByNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnAliasesOrByName + p.RuleIndex = StarRocksSQLParserRULE_columnAliasesOrByName return p } func InitEmptyColumnAliasesOrByNameContext(p *ColumnAliasesOrByNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnAliasesOrByName + p.RuleIndex = StarRocksSQLParserRULE_columnAliasesOrByName } func (*ColumnAliasesOrByNameContext) IsColumnAliasesOrByNameContext() {} @@ -54006,7 +54006,7 @@ func NewColumnAliasesOrByNameContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnAliasesOrByName + p.RuleIndex = StarRocksSQLParserRULE_columnAliasesOrByName return p } @@ -54030,11 +54030,11 @@ func (s *ColumnAliasesOrByNameContext) ColumnAliases() IColumnAliasesContext { } func (s *ColumnAliasesOrByNameContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ColumnAliasesOrByNameContext) NAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNAME, 0) + return s.GetToken(StarRocksSQLParserNAME, 0) } func (s *ColumnAliasesOrByNameContext) GetRuleContext() antlr.RuleContext { @@ -54046,20 +54046,20 @@ func (s *ColumnAliasesOrByNameContext) ToStringTree(ruleNames []string, recog an } func (s *ColumnAliasesOrByNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnAliasesOrByName(s) } } func (s *ColumnAliasesOrByNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnAliasesOrByName(s) } } func (s *ColumnAliasesOrByNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnAliasesOrByName(s) default: @@ -54067,9 +54067,9 @@ func (s *ColumnAliasesOrByNameContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ColumnAliasesOrByName() (localctx IColumnAliasesOrByNameContext) { +func (p *StarRocksSQLParser) ColumnAliasesOrByName() (localctx IColumnAliasesOrByNameContext) { localctx = NewColumnAliasesOrByNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 354, DorisSQLParserRULE_columnAliasesOrByName) + p.EnterRule(localctx, 354, StarRocksSQLParserRULE_columnAliasesOrByName) p.SetState(3464) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -54077,18 +54077,18 @@ func (p *DorisSQLParser) ColumnAliasesOrByName() (localctx IColumnAliasesOrByNam } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: p.EnterOuterAlt(localctx, 1) { p.SetState(3461) p.ColumnAliases() } - case DorisSQLParserBY: + case StarRocksSQLParserBY: p.EnterOuterAlt(localctx, 2) { p.SetState(3462) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54096,7 +54096,7 @@ func (p *DorisSQLParser) ColumnAliasesOrByName() (localctx IColumnAliasesOrByNam } { p.SetState(3463) - p.Match(DorisSQLParserNAME) + p.Match(StarRocksSQLParserNAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54158,13 +54158,13 @@ type UpdateStatementContext struct { func NewEmptyUpdateStatementContext() *UpdateStatementContext { var p = new(UpdateStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_updateStatement + p.RuleIndex = StarRocksSQLParserRULE_updateStatement return p } func InitEmptyUpdateStatementContext(p *UpdateStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_updateStatement + p.RuleIndex = StarRocksSQLParserRULE_updateStatement } func (*UpdateStatementContext) IsUpdateStatementContext() {} @@ -54175,7 +54175,7 @@ func NewUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_updateStatement + p.RuleIndex = StarRocksSQLParserRULE_updateStatement return p } @@ -54187,7 +54187,7 @@ func (s *UpdateStatementContext) GetWhere() IExpressionContext { return s.where func (s *UpdateStatementContext) SetWhere(v IExpressionContext) { s.where = v } func (s *UpdateStatementContext) UPDATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUPDATE, 0) + return s.GetToken(StarRocksSQLParserUPDATE, 0) } func (s *UpdateStatementContext) QualifiedName() IQualifiedNameContext { @@ -54207,7 +54207,7 @@ func (s *UpdateStatementContext) QualifiedName() IQualifiedNameContext { } func (s *UpdateStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *UpdateStatementContext) AssignmentList() IAssignmentListContext { @@ -54275,7 +54275,7 @@ func (s *UpdateStatementContext) WithClause() IWithClauseContext { } func (s *UpdateStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *UpdateStatementContext) Expression() IExpressionContext { @@ -54303,20 +54303,20 @@ func (s *UpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *UpdateStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUpdateStatement(s) } } func (s *UpdateStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUpdateStatement(s) } } func (s *UpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUpdateStatement(s) default: @@ -54324,9 +54324,9 @@ func (s *UpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) UpdateStatement() (localctx IUpdateStatementContext) { +func (p *StarRocksSQLParser) UpdateStatement() (localctx IUpdateStatementContext) { localctx = NewUpdateStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 356, DorisSQLParserRULE_updateStatement) + p.EnterRule(localctx, 356, StarRocksSQLParserRULE_updateStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -54351,7 +54351,7 @@ func (p *DorisSQLParser) UpdateStatement() (localctx IUpdateStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(3469) p.WithClause() @@ -54360,7 +54360,7 @@ func (p *DorisSQLParser) UpdateStatement() (localctx IUpdateStatementContext) { } { p.SetState(3472) - p.Match(DorisSQLParserUPDATE) + p.Match(StarRocksSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54372,7 +54372,7 @@ func (p *DorisSQLParser) UpdateStatement() (localctx IUpdateStatementContext) { } { p.SetState(3474) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54393,10 +54393,10 @@ func (p *DorisSQLParser) UpdateStatement() (localctx IUpdateStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3477) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54470,13 +54470,13 @@ type DeleteStatementContext struct { func NewEmptyDeleteStatementContext() *DeleteStatementContext { var p = new(DeleteStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_deleteStatement + p.RuleIndex = StarRocksSQLParserRULE_deleteStatement return p } func InitEmptyDeleteStatementContext(p *DeleteStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_deleteStatement + p.RuleIndex = StarRocksSQLParserRULE_deleteStatement } func (*DeleteStatementContext) IsDeleteStatementContext() {} @@ -54487,7 +54487,7 @@ func NewDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_deleteStatement + p.RuleIndex = StarRocksSQLParserRULE_deleteStatement return p } @@ -54503,11 +54503,11 @@ func (s *DeleteStatementContext) SetUsing(v IRelationsContext) { s.using = v } func (s *DeleteStatementContext) SetWhere(v IExpressionContext) { s.where = v } func (s *DeleteStatementContext) DELETE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDELETE, 0) + return s.GetToken(StarRocksSQLParserDELETE, 0) } func (s *DeleteStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DeleteStatementContext) QualifiedName() IQualifiedNameContext { @@ -54575,11 +54575,11 @@ func (s *DeleteStatementContext) PartitionNames() IPartitionNamesContext { } func (s *DeleteStatementContext) USING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSING, 0) + return s.GetToken(StarRocksSQLParserUSING, 0) } func (s *DeleteStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *DeleteStatementContext) Relations() IRelationsContext { @@ -54623,20 +54623,20 @@ func (s *DeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *DeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDeleteStatement(s) } } func (s *DeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDeleteStatement(s) } } func (s *DeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDeleteStatement(s) default: @@ -54644,9 +54644,9 @@ func (s *DeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { +func (p *StarRocksSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { localctx = NewDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 358, DorisSQLParserRULE_deleteStatement) + p.EnterRule(localctx, 358, StarRocksSQLParserRULE_deleteStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -54671,7 +54671,7 @@ func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(3484) p.WithClause() @@ -54680,7 +54680,7 @@ func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { } { p.SetState(3487) - p.Match(DorisSQLParserDELETE) + p.Match(StarRocksSQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54688,7 +54688,7 @@ func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { } { p.SetState(3488) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54705,7 +54705,7 @@ func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(3490) p.PartitionNames() @@ -54719,10 +54719,10 @@ func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserUSING { + if _la == StarRocksSQLParserUSING { { p.SetState(3493) - p.Match(DorisSQLParserUSING) + p.Match(StarRocksSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54744,10 +54744,10 @@ func (p *DorisSQLParser) DeleteStatement() (localctx IDeleteStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3497) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -54838,13 +54838,13 @@ type CreateRoutineLoadStatementContext struct { func NewEmptyCreateRoutineLoadStatementContext() *CreateRoutineLoadStatementContext { var p = new(CreateRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_createRoutineLoadStatement return p } func InitEmptyCreateRoutineLoadStatementContext(p *CreateRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_createRoutineLoadStatement } func (*CreateRoutineLoadStatementContext) IsCreateRoutineLoadStatementContext() {} @@ -54855,7 +54855,7 @@ func NewCreateRoutineLoadStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_createRoutineLoadStatement return p } @@ -54879,23 +54879,23 @@ func (s *CreateRoutineLoadStatementContext) SetTable(v IQualifiedNameContext) { func (s *CreateRoutineLoadStatementContext) SetSource(v IIdentifierContext) { s.source = v } func (s *CreateRoutineLoadStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *CreateRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *CreateRoutineLoadStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CreateRoutineLoadStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CreateRoutineLoadStatementContext) AllIdentifier() []IIdentifierContext { @@ -55062,20 +55062,20 @@ func (s *CreateRoutineLoadStatementContext) ToStringTree(ruleNames []string, rec } func (s *CreateRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateRoutineLoadStatement(s) } } func (s *CreateRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateRoutineLoadStatement(s) } } func (s *CreateRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateRoutineLoadStatement(s) default: @@ -55083,15 +55083,15 @@ func (s *CreateRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLoadStatementContext) { localctx = NewCreateRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 360, DorisSQLParserRULE_createRoutineLoadStatement) + p.EnterRule(localctx, 360, StarRocksSQLParserRULE_createRoutineLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3501) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55099,7 +55099,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } { p.SetState(3502) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55107,7 +55107,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } { p.SetState(3503) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55126,7 +55126,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } { p.SetState(3505) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55145,7 +55145,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } { p.SetState(3510) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55165,7 +55165,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOLUMNS || _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserROWS || _la == DorisSQLParserTEMPORARY || _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserCOLUMNS || _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserROWS || _la == StarRocksSQLParserTEMPORARY || _la == StarRocksSQLParserWHERE { { p.SetState(3512) p.LoadProperties() @@ -55177,10 +55177,10 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3513) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55207,7 +55207,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3522) p.JobProperties() @@ -55216,7 +55216,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } { p.SetState(3525) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55236,7 +55236,7 @@ func (p *DorisSQLParser) CreateRoutineLoadStatement() (localctx ICreateRoutineLo } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(3527) p.DataSourceProperties() @@ -55302,13 +55302,13 @@ type AlterRoutineLoadStatementContext struct { func NewEmptyAlterRoutineLoadStatementContext() *AlterRoutineLoadStatementContext { var p = new(AlterRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_alterRoutineLoadStatement return p } func InitEmptyAlterRoutineLoadStatementContext(p *AlterRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_alterRoutineLoadStatement } func (*AlterRoutineLoadStatementContext) IsAlterRoutineLoadStatementContext() {} @@ -55319,7 +55319,7 @@ func NewAlterRoutineLoadStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_alterRoutineLoadStatement return p } @@ -55335,19 +55335,19 @@ func (s *AlterRoutineLoadStatementContext) SetDb(v IQualifiedNameContext) { s.db func (s *AlterRoutineLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *AlterRoutineLoadStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *AlterRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *AlterRoutineLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *AlterRoutineLoadStatementContext) Identifier() IIdentifierContext { @@ -55464,20 +55464,20 @@ func (s *AlterRoutineLoadStatementContext) ToStringTree(ruleNames []string, reco } func (s *AlterRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterRoutineLoadStatement(s) } } func (s *AlterRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterRoutineLoadStatement(s) } } func (s *AlterRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterRoutineLoadStatement(s) default: @@ -55485,15 +55485,15 @@ func (s *AlterRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoadStatementContext) { localctx = NewAlterRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 362, DorisSQLParserRULE_alterRoutineLoadStatement) + p.EnterRule(localctx, 362, StarRocksSQLParserRULE_alterRoutineLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3530) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55501,7 +55501,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } { p.SetState(3531) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55509,7 +55509,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } { p.SetState(3532) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55517,7 +55517,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } { p.SetState(3533) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55536,7 +55536,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } { p.SetState(3535) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55560,7 +55560,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOLUMNS || _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserROWS || _la == DorisSQLParserTEMPORARY || _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserCOLUMNS || _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserROWS || _la == StarRocksSQLParserTEMPORARY || _la == StarRocksSQLParserWHERE { { p.SetState(3540) p.LoadProperties() @@ -55572,10 +55572,10 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3541) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55602,7 +55602,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3550) p.JobProperties() @@ -55616,7 +55616,7 @@ func (p *DorisSQLParser) AlterRoutineLoadStatement() (localctx IAlterRoutineLoad } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3553) p.DataSource() @@ -55668,13 +55668,13 @@ type DataSourceContext struct { func NewEmptyDataSourceContext() *DataSourceContext { var p = new(DataSourceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataSource + p.RuleIndex = StarRocksSQLParserRULE_dataSource return p } func InitEmptyDataSourceContext(p *DataSourceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataSource + p.RuleIndex = StarRocksSQLParserRULE_dataSource } func (*DataSourceContext) IsDataSourceContext() {} @@ -55685,7 +55685,7 @@ func NewDataSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dataSource + p.RuleIndex = StarRocksSQLParserRULE_dataSource return p } @@ -55697,7 +55697,7 @@ func (s *DataSourceContext) GetSource() IIdentifierContext { return s.source } func (s *DataSourceContext) SetSource(v IIdentifierContext) { s.source = v } func (s *DataSourceContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DataSourceContext) DataSourceProperties() IDataSourcePropertiesContext { @@ -55741,20 +55741,20 @@ func (s *DataSourceContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *DataSourceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDataSource(s) } } func (s *DataSourceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDataSource(s) } } func (s *DataSourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDataSource(s) default: @@ -55762,13 +55762,13 @@ func (s *DataSourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) DataSource() (localctx IDataSourceContext) { +func (p *StarRocksSQLParser) DataSource() (localctx IDataSourceContext) { localctx = NewDataSourceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 364, DorisSQLParserRULE_dataSource) + p.EnterRule(localctx, 364, StarRocksSQLParserRULE_dataSource) p.EnterOuterAlt(localctx, 1) { p.SetState(3556) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -55826,13 +55826,13 @@ type LoadPropertiesContext struct { func NewEmptyLoadPropertiesContext() *LoadPropertiesContext { var p = new(LoadPropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_loadProperties + p.RuleIndex = StarRocksSQLParserRULE_loadProperties return p } func InitEmptyLoadPropertiesContext(p *LoadPropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_loadProperties + p.RuleIndex = StarRocksSQLParserRULE_loadProperties } func (*LoadPropertiesContext) IsLoadPropertiesContext() {} @@ -55843,7 +55843,7 @@ func NewLoadPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_loadProperties + p.RuleIndex = StarRocksSQLParserRULE_loadProperties return p } @@ -55899,7 +55899,7 @@ func (s *LoadPropertiesContext) ImportColumns() IImportColumnsContext { } func (s *LoadPropertiesContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *LoadPropertiesContext) Expression() IExpressionContext { @@ -55943,20 +55943,20 @@ func (s *LoadPropertiesContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *LoadPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLoadProperties(s) } } func (s *LoadPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLoadProperties(s) } } func (s *LoadPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLoadProperties(s) default: @@ -55964,9 +55964,9 @@ func (s *LoadPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) LoadProperties() (localctx ILoadPropertiesContext) { +func (p *StarRocksSQLParser) LoadProperties() (localctx ILoadPropertiesContext) { localctx = NewLoadPropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 366, DorisSQLParserRULE_loadProperties) + p.EnterRule(localctx, 366, StarRocksSQLParserRULE_loadProperties) p.SetState(3566) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -55999,7 +55999,7 @@ func (p *DorisSQLParser) LoadProperties() (localctx ILoadPropertiesContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(3563) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56059,13 +56059,13 @@ type ColSeparatorPropertyContext struct { func NewEmptyColSeparatorPropertyContext() *ColSeparatorPropertyContext { var p = new(ColSeparatorPropertyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_colSeparatorProperty + p.RuleIndex = StarRocksSQLParserRULE_colSeparatorProperty return p } func InitEmptyColSeparatorPropertyContext(p *ColSeparatorPropertyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_colSeparatorProperty + p.RuleIndex = StarRocksSQLParserRULE_colSeparatorProperty } func (*ColSeparatorPropertyContext) IsColSeparatorPropertyContext() {} @@ -56076,7 +56076,7 @@ func NewColSeparatorPropertyContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_colSeparatorProperty + p.RuleIndex = StarRocksSQLParserRULE_colSeparatorProperty return p } @@ -56084,15 +56084,15 @@ func NewColSeparatorPropertyContext(parser antlr.Parser, parent antlr.ParserRule func (s *ColSeparatorPropertyContext) GetParser() antlr.Parser { return s.parser } func (s *ColSeparatorPropertyContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *ColSeparatorPropertyContext) TERMINATED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTERMINATED, 0) + return s.GetToken(StarRocksSQLParserTERMINATED, 0) } func (s *ColSeparatorPropertyContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ColSeparatorPropertyContext) String_() IStringContext { @@ -56120,20 +56120,20 @@ func (s *ColSeparatorPropertyContext) ToStringTree(ruleNames []string, recog ant } func (s *ColSeparatorPropertyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColSeparatorProperty(s) } } func (s *ColSeparatorPropertyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColSeparatorProperty(s) } } func (s *ColSeparatorPropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColSeparatorProperty(s) default: @@ -56141,13 +56141,13 @@ func (s *ColSeparatorPropertyContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ColSeparatorProperty() (localctx IColSeparatorPropertyContext) { +func (p *StarRocksSQLParser) ColSeparatorProperty() (localctx IColSeparatorPropertyContext) { localctx = NewColSeparatorPropertyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 368, DorisSQLParserRULE_colSeparatorProperty) + p.EnterRule(localctx, 368, StarRocksSQLParserRULE_colSeparatorProperty) p.EnterOuterAlt(localctx, 1) { p.SetState(3568) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56155,7 +56155,7 @@ func (p *DorisSQLParser) ColSeparatorProperty() (localctx IColSeparatorPropertyC } { p.SetState(3569) - p.Match(DorisSQLParserTERMINATED) + p.Match(StarRocksSQLParserTERMINATED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56163,7 +56163,7 @@ func (p *DorisSQLParser) ColSeparatorProperty() (localctx IColSeparatorPropertyC } { p.SetState(3570) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56212,13 +56212,13 @@ type RowDelimiterPropertyContext struct { func NewEmptyRowDelimiterPropertyContext() *RowDelimiterPropertyContext { var p = new(RowDelimiterPropertyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rowDelimiterProperty + p.RuleIndex = StarRocksSQLParserRULE_rowDelimiterProperty return p } func InitEmptyRowDelimiterPropertyContext(p *RowDelimiterPropertyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rowDelimiterProperty + p.RuleIndex = StarRocksSQLParserRULE_rowDelimiterProperty } func (*RowDelimiterPropertyContext) IsRowDelimiterPropertyContext() {} @@ -56229,7 +56229,7 @@ func NewRowDelimiterPropertyContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rowDelimiterProperty + p.RuleIndex = StarRocksSQLParserRULE_rowDelimiterProperty return p } @@ -56237,15 +56237,15 @@ func NewRowDelimiterPropertyContext(parser antlr.Parser, parent antlr.ParserRule func (s *RowDelimiterPropertyContext) GetParser() antlr.Parser { return s.parser } func (s *RowDelimiterPropertyContext) ROWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROWS, 0) + return s.GetToken(StarRocksSQLParserROWS, 0) } func (s *RowDelimiterPropertyContext) TERMINATED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTERMINATED, 0) + return s.GetToken(StarRocksSQLParserTERMINATED, 0) } func (s *RowDelimiterPropertyContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *RowDelimiterPropertyContext) String_() IStringContext { @@ -56273,20 +56273,20 @@ func (s *RowDelimiterPropertyContext) ToStringTree(ruleNames []string, recog ant } func (s *RowDelimiterPropertyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRowDelimiterProperty(s) } } func (s *RowDelimiterPropertyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRowDelimiterProperty(s) } } func (s *RowDelimiterPropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRowDelimiterProperty(s) default: @@ -56294,13 +56294,13 @@ func (s *RowDelimiterPropertyContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) RowDelimiterProperty() (localctx IRowDelimiterPropertyContext) { +func (p *StarRocksSQLParser) RowDelimiterProperty() (localctx IRowDelimiterPropertyContext) { localctx = NewRowDelimiterPropertyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 370, DorisSQLParserRULE_rowDelimiterProperty) + p.EnterRule(localctx, 370, StarRocksSQLParserRULE_rowDelimiterProperty) p.EnterOuterAlt(localctx, 1) { p.SetState(3573) - p.Match(DorisSQLParserROWS) + p.Match(StarRocksSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56308,7 +56308,7 @@ func (p *DorisSQLParser) RowDelimiterProperty() (localctx IRowDelimiterPropertyC } { p.SetState(3574) - p.Match(DorisSQLParserTERMINATED) + p.Match(StarRocksSQLParserTERMINATED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56316,7 +56316,7 @@ func (p *DorisSQLParser) RowDelimiterProperty() (localctx IRowDelimiterPropertyC } { p.SetState(3575) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56363,13 +56363,13 @@ type ImportColumnsContext struct { func NewEmptyImportColumnsContext() *ImportColumnsContext { var p = new(ImportColumnsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_importColumns + p.RuleIndex = StarRocksSQLParserRULE_importColumns return p } func InitEmptyImportColumnsContext(p *ImportColumnsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_importColumns + p.RuleIndex = StarRocksSQLParserRULE_importColumns } func (*ImportColumnsContext) IsImportColumnsContext() {} @@ -56380,7 +56380,7 @@ func NewImportColumnsContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_importColumns + p.RuleIndex = StarRocksSQLParserRULE_importColumns return p } @@ -56388,7 +56388,7 @@ func NewImportColumnsContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *ImportColumnsContext) GetParser() antlr.Parser { return s.parser } func (s *ImportColumnsContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *ImportColumnsContext) ColumnProperties() IColumnPropertiesContext { @@ -56416,20 +56416,20 @@ func (s *ImportColumnsContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *ImportColumnsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterImportColumns(s) } } func (s *ImportColumnsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitImportColumns(s) } } func (s *ImportColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitImportColumns(s) default: @@ -56437,13 +56437,13 @@ func (s *ImportColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) ImportColumns() (localctx IImportColumnsContext) { +func (p *StarRocksSQLParser) ImportColumns() (localctx IImportColumnsContext) { localctx = NewImportColumnsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 372, DorisSQLParserRULE_importColumns) + p.EnterRule(localctx, 372, StarRocksSQLParserRULE_importColumns) p.EnterOuterAlt(localctx, 1) { p.SetState(3578) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56492,13 +56492,13 @@ type ColumnPropertiesContext struct { func NewEmptyColumnPropertiesContext() *ColumnPropertiesContext { var p = new(ColumnPropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnProperties + p.RuleIndex = StarRocksSQLParserRULE_columnProperties return p } func InitEmptyColumnPropertiesContext(p *ColumnPropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnProperties + p.RuleIndex = StarRocksSQLParserRULE_columnProperties } func (*ColumnPropertiesContext) IsColumnPropertiesContext() {} @@ -56509,7 +56509,7 @@ func NewColumnPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnProperties + p.RuleIndex = StarRocksSQLParserRULE_columnProperties return p } @@ -56607,20 +56607,20 @@ func (s *ColumnPropertiesContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *ColumnPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnProperties(s) } } func (s *ColumnPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnProperties(s) } } func (s *ColumnPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnProperties(s) default: @@ -56628,15 +56628,15 @@ func (s *ColumnPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) ColumnProperties() (localctx IColumnPropertiesContext) { +func (p *StarRocksSQLParser) ColumnProperties() (localctx IColumnPropertiesContext) { localctx = NewColumnPropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 374, DorisSQLParserRULE_columnProperties) + p.EnterRule(localctx, 374, StarRocksSQLParserRULE_columnProperties) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3581) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56671,10 +56671,10 @@ func (p *DorisSQLParser) ColumnProperties() (localctx IColumnPropertiesContext) } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3586) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56712,7 +56712,7 @@ func (p *DorisSQLParser) ColumnProperties() (localctx IColumnPropertiesContext) } { p.SetState(3596) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -56754,13 +56754,13 @@ type JobPropertiesContext struct { func NewEmptyJobPropertiesContext() *JobPropertiesContext { var p = new(JobPropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_jobProperties + p.RuleIndex = StarRocksSQLParserRULE_jobProperties return p } func InitEmptyJobPropertiesContext(p *JobPropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_jobProperties + p.RuleIndex = StarRocksSQLParserRULE_jobProperties } func (*JobPropertiesContext) IsJobPropertiesContext() {} @@ -56771,7 +56771,7 @@ func NewJobPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_jobProperties + p.RuleIndex = StarRocksSQLParserRULE_jobProperties return p } @@ -56803,20 +56803,20 @@ func (s *JobPropertiesContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *JobPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterJobProperties(s) } } func (s *JobPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitJobProperties(s) } } func (s *JobPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitJobProperties(s) default: @@ -56824,9 +56824,9 @@ func (s *JobPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) JobProperties() (localctx IJobPropertiesContext) { +func (p *StarRocksSQLParser) JobProperties() (localctx IJobPropertiesContext) { localctx = NewJobPropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 376, DorisSQLParserRULE_jobProperties) + p.EnterRule(localctx, 376, StarRocksSQLParserRULE_jobProperties) p.EnterOuterAlt(localctx, 1) { p.SetState(3598) @@ -56868,13 +56868,13 @@ type DataSourcePropertiesContext struct { func NewEmptyDataSourcePropertiesContext() *DataSourcePropertiesContext { var p = new(DataSourcePropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataSourceProperties + p.RuleIndex = StarRocksSQLParserRULE_dataSourceProperties return p } func InitEmptyDataSourcePropertiesContext(p *DataSourcePropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataSourceProperties + p.RuleIndex = StarRocksSQLParserRULE_dataSourceProperties } func (*DataSourcePropertiesContext) IsDataSourcePropertiesContext() {} @@ -56885,7 +56885,7 @@ func NewDataSourcePropertiesContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dataSourceProperties + p.RuleIndex = StarRocksSQLParserRULE_dataSourceProperties return p } @@ -56917,20 +56917,20 @@ func (s *DataSourcePropertiesContext) ToStringTree(ruleNames []string, recog ant } func (s *DataSourcePropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDataSourceProperties(s) } } func (s *DataSourcePropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDataSourceProperties(s) } } func (s *DataSourcePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDataSourceProperties(s) default: @@ -56938,9 +56938,9 @@ func (s *DataSourcePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) DataSourceProperties() (localctx IDataSourcePropertiesContext) { +func (p *StarRocksSQLParser) DataSourceProperties() (localctx IDataSourcePropertiesContext) { localctx = NewDataSourcePropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 378, DorisSQLParserRULE_dataSourceProperties) + p.EnterRule(localctx, 378, StarRocksSQLParserRULE_dataSourceProperties) p.EnterOuterAlt(localctx, 1) { p.SetState(3600) @@ -57001,13 +57001,13 @@ type StopRoutineLoadStatementContext struct { func NewEmptyStopRoutineLoadStatementContext() *StopRoutineLoadStatementContext { var p = new(StopRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_stopRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_stopRoutineLoadStatement return p } func InitEmptyStopRoutineLoadStatementContext(p *StopRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_stopRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_stopRoutineLoadStatement } func (*StopRoutineLoadStatementContext) IsStopRoutineLoadStatementContext() {} @@ -57018,7 +57018,7 @@ func NewStopRoutineLoadStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_stopRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_stopRoutineLoadStatement return p } @@ -57034,19 +57034,19 @@ func (s *StopRoutineLoadStatementContext) SetDb(v IQualifiedNameContext) { s.db func (s *StopRoutineLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *StopRoutineLoadStatementContext) STOP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTOP, 0) + return s.GetToken(StarRocksSQLParserSTOP, 0) } func (s *StopRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *StopRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *StopRoutineLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *StopRoutineLoadStatementContext) Identifier() IIdentifierContext { @@ -57090,20 +57090,20 @@ func (s *StopRoutineLoadStatementContext) ToStringTree(ruleNames []string, recog } func (s *StopRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterStopRoutineLoadStatement(s) } } func (s *StopRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitStopRoutineLoadStatement(s) } } func (s *StopRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitStopRoutineLoadStatement(s) default: @@ -57111,13 +57111,13 @@ func (s *StopRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) StopRoutineLoadStatement() (localctx IStopRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) StopRoutineLoadStatement() (localctx IStopRoutineLoadStatementContext) { localctx = NewStopRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 380, DorisSQLParserRULE_stopRoutineLoadStatement) + p.EnterRule(localctx, 380, StarRocksSQLParserRULE_stopRoutineLoadStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(3602) - p.Match(DorisSQLParserSTOP) + p.Match(StarRocksSQLParserSTOP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57125,7 +57125,7 @@ func (p *DorisSQLParser) StopRoutineLoadStatement() (localctx IStopRoutineLoadSt } { p.SetState(3603) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57133,7 +57133,7 @@ func (p *DorisSQLParser) StopRoutineLoadStatement() (localctx IStopRoutineLoadSt } { p.SetState(3604) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57141,7 +57141,7 @@ func (p *DorisSQLParser) StopRoutineLoadStatement() (localctx IStopRoutineLoadSt } { p.SetState(3605) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57160,7 +57160,7 @@ func (p *DorisSQLParser) StopRoutineLoadStatement() (localctx IStopRoutineLoadSt } { p.SetState(3607) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57232,13 +57232,13 @@ type ResumeRoutineLoadStatementContext struct { func NewEmptyResumeRoutineLoadStatementContext() *ResumeRoutineLoadStatementContext { var p = new(ResumeRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_resumeRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_resumeRoutineLoadStatement return p } func InitEmptyResumeRoutineLoadStatementContext(p *ResumeRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_resumeRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_resumeRoutineLoadStatement } func (*ResumeRoutineLoadStatementContext) IsResumeRoutineLoadStatementContext() {} @@ -57249,7 +57249,7 @@ func NewResumeRoutineLoadStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_resumeRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_resumeRoutineLoadStatement return p } @@ -57265,19 +57265,19 @@ func (s *ResumeRoutineLoadStatementContext) SetDb(v IQualifiedNameContext) { s.d func (s *ResumeRoutineLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *ResumeRoutineLoadStatementContext) RESUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESUME, 0) + return s.GetToken(StarRocksSQLParserRESUME, 0) } func (s *ResumeRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *ResumeRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ResumeRoutineLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ResumeRoutineLoadStatementContext) Identifier() IIdentifierContext { @@ -57321,20 +57321,20 @@ func (s *ResumeRoutineLoadStatementContext) ToStringTree(ruleNames []string, rec } func (s *ResumeRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterResumeRoutineLoadStatement(s) } } func (s *ResumeRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitResumeRoutineLoadStatement(s) } } func (s *ResumeRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitResumeRoutineLoadStatement(s) default: @@ -57342,13 +57342,13 @@ func (s *ResumeRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) ResumeRoutineLoadStatement() (localctx IResumeRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) ResumeRoutineLoadStatement() (localctx IResumeRoutineLoadStatementContext) { localctx = NewResumeRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 382, DorisSQLParserRULE_resumeRoutineLoadStatement) + p.EnterRule(localctx, 382, StarRocksSQLParserRULE_resumeRoutineLoadStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(3613) - p.Match(DorisSQLParserRESUME) + p.Match(StarRocksSQLParserRESUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57356,7 +57356,7 @@ func (p *DorisSQLParser) ResumeRoutineLoadStatement() (localctx IResumeRoutineLo } { p.SetState(3614) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57364,7 +57364,7 @@ func (p *DorisSQLParser) ResumeRoutineLoadStatement() (localctx IResumeRoutineLo } { p.SetState(3615) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57372,7 +57372,7 @@ func (p *DorisSQLParser) ResumeRoutineLoadStatement() (localctx IResumeRoutineLo } { p.SetState(3616) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57391,7 +57391,7 @@ func (p *DorisSQLParser) ResumeRoutineLoadStatement() (localctx IResumeRoutineLo } { p.SetState(3618) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57463,13 +57463,13 @@ type PauseRoutineLoadStatementContext struct { func NewEmptyPauseRoutineLoadStatementContext() *PauseRoutineLoadStatementContext { var p = new(PauseRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pauseRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_pauseRoutineLoadStatement return p } func InitEmptyPauseRoutineLoadStatementContext(p *PauseRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pauseRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_pauseRoutineLoadStatement } func (*PauseRoutineLoadStatementContext) IsPauseRoutineLoadStatementContext() {} @@ -57480,7 +57480,7 @@ func NewPauseRoutineLoadStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_pauseRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_pauseRoutineLoadStatement return p } @@ -57496,19 +57496,19 @@ func (s *PauseRoutineLoadStatementContext) SetDb(v IQualifiedNameContext) { s.db func (s *PauseRoutineLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *PauseRoutineLoadStatementContext) PAUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPAUSE, 0) + return s.GetToken(StarRocksSQLParserPAUSE, 0) } func (s *PauseRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *PauseRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *PauseRoutineLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *PauseRoutineLoadStatementContext) Identifier() IIdentifierContext { @@ -57552,20 +57552,20 @@ func (s *PauseRoutineLoadStatementContext) ToStringTree(ruleNames []string, reco } func (s *PauseRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPauseRoutineLoadStatement(s) } } func (s *PauseRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPauseRoutineLoadStatement(s) } } func (s *PauseRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPauseRoutineLoadStatement(s) default: @@ -57573,13 +57573,13 @@ func (s *PauseRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) PauseRoutineLoadStatement() (localctx IPauseRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) PauseRoutineLoadStatement() (localctx IPauseRoutineLoadStatementContext) { localctx = NewPauseRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 384, DorisSQLParserRULE_pauseRoutineLoadStatement) + p.EnterRule(localctx, 384, StarRocksSQLParserRULE_pauseRoutineLoadStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(3624) - p.Match(DorisSQLParserPAUSE) + p.Match(StarRocksSQLParserPAUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57587,7 +57587,7 @@ func (p *DorisSQLParser) PauseRoutineLoadStatement() (localctx IPauseRoutineLoad } { p.SetState(3625) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57595,7 +57595,7 @@ func (p *DorisSQLParser) PauseRoutineLoadStatement() (localctx IPauseRoutineLoad } { p.SetState(3626) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57603,7 +57603,7 @@ func (p *DorisSQLParser) PauseRoutineLoadStatement() (localctx IPauseRoutineLoad } { p.SetState(3627) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57622,7 +57622,7 @@ func (p *DorisSQLParser) PauseRoutineLoadStatement() (localctx IPauseRoutineLoad } { p.SetState(3629) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57704,13 +57704,13 @@ type ShowRoutineLoadStatementContext struct { func NewEmptyShowRoutineLoadStatementContext() *ShowRoutineLoadStatementContext { var p = new(ShowRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showRoutineLoadStatement return p } func InitEmptyShowRoutineLoadStatementContext(p *ShowRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showRoutineLoadStatement } func (*ShowRoutineLoadStatementContext) IsShowRoutineLoadStatementContext() {} @@ -57721,7 +57721,7 @@ func NewShowRoutineLoadStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showRoutineLoadStatement return p } @@ -57737,31 +57737,31 @@ func (s *ShowRoutineLoadStatementContext) SetDb(v IQualifiedNameContext) { s.db func (s *ShowRoutineLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *ShowRoutineLoadStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *ShowRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowRoutineLoadStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ShowRoutineLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowRoutineLoadStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowRoutineLoadStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowRoutineLoadStatementContext) Expression() IExpressionContext { @@ -57781,11 +57781,11 @@ func (s *ShowRoutineLoadStatementContext) Expression() IExpressionContext { } func (s *ShowRoutineLoadStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowRoutineLoadStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowRoutineLoadStatementContext) AllSortItem() []ISortItemContext { @@ -57911,20 +57911,20 @@ func (s *ShowRoutineLoadStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowRoutineLoadStatement(s) } } func (s *ShowRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowRoutineLoadStatement(s) } } func (s *ShowRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowRoutineLoadStatement(s) default: @@ -57932,15 +57932,15 @@ func (s *ShowRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadStatementContext) { localctx = NewShowRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 386, DorisSQLParserRULE_showRoutineLoadStatement) + p.EnterRule(localctx, 386, StarRocksSQLParserRULE_showRoutineLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3635) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57953,10 +57953,10 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL { + if _la == StarRocksSQLParserALL { { p.SetState(3636) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57966,7 +57966,7 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } { p.SetState(3639) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57974,7 +57974,7 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } { p.SetState(3640) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -57987,10 +57987,10 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(3641) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58009,7 +58009,7 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } { p.SetState(3643) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58035,10 +58035,10 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3650) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58060,10 +58060,10 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3654) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58082,10 +58082,10 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(3658) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58093,7 +58093,7 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } { p.SetState(3659) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58110,10 +58110,10 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3661) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58140,7 +58140,7 @@ func (p *DorisSQLParser) ShowRoutineLoadStatement() (localctx IShowRoutineLoadSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(3670) p.LimitElement() @@ -58197,13 +58197,13 @@ type ShowRoutineLoadTaskStatementContext struct { func NewEmptyShowRoutineLoadTaskStatementContext() *ShowRoutineLoadTaskStatementContext { var p = new(ShowRoutineLoadTaskStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRoutineLoadTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_showRoutineLoadTaskStatement return p } func InitEmptyShowRoutineLoadTaskStatementContext(p *ShowRoutineLoadTaskStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRoutineLoadTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_showRoutineLoadTaskStatement } func (*ShowRoutineLoadTaskStatementContext) IsShowRoutineLoadTaskStatementContext() {} @@ -58214,7 +58214,7 @@ func NewShowRoutineLoadTaskStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showRoutineLoadTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_showRoutineLoadTaskStatement return p } @@ -58226,23 +58226,23 @@ func (s *ShowRoutineLoadTaskStatementContext) GetDb() IQualifiedNameContext { re func (s *ShowRoutineLoadTaskStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowRoutineLoadTaskStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowRoutineLoadTaskStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *ShowRoutineLoadTaskStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowRoutineLoadTaskStatementContext) TASK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTASK, 0) + return s.GetToken(StarRocksSQLParserTASK, 0) } func (s *ShowRoutineLoadTaskStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowRoutineLoadTaskStatementContext) Expression() IExpressionContext { @@ -58262,7 +58262,7 @@ func (s *ShowRoutineLoadTaskStatementContext) Expression() IExpressionContext { } func (s *ShowRoutineLoadTaskStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowRoutineLoadTaskStatementContext) QualifiedName() IQualifiedNameContext { @@ -58290,20 +58290,20 @@ func (s *ShowRoutineLoadTaskStatementContext) ToStringTree(ruleNames []string, r } func (s *ShowRoutineLoadTaskStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowRoutineLoadTaskStatement(s) } } func (s *ShowRoutineLoadTaskStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowRoutineLoadTaskStatement(s) } } func (s *ShowRoutineLoadTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowRoutineLoadTaskStatement(s) default: @@ -58311,15 +58311,15 @@ func (s *ShowRoutineLoadTaskStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLoadTaskStatementContext) { +func (p *StarRocksSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLoadTaskStatementContext) { localctx = NewShowRoutineLoadTaskStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 388, DorisSQLParserRULE_showRoutineLoadTaskStatement) + p.EnterRule(localctx, 388, StarRocksSQLParserRULE_showRoutineLoadTaskStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3673) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58327,7 +58327,7 @@ func (p *DorisSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLo } { p.SetState(3674) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58335,7 +58335,7 @@ func (p *DorisSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLo } { p.SetState(3675) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58343,7 +58343,7 @@ func (p *DorisSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLo } { p.SetState(3676) - p.Match(DorisSQLParserTASK) + p.Match(StarRocksSQLParserTASK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58356,10 +58356,10 @@ func (p *DorisSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLo } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3677) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58376,7 +58376,7 @@ func (p *DorisSQLParser) ShowRoutineLoadTaskStatement() (localctx IShowRoutineLo } { p.SetState(3681) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58441,13 +58441,13 @@ type ShowCreateRoutineLoadStatementContext struct { func NewEmptyShowCreateRoutineLoadStatementContext() *ShowCreateRoutineLoadStatementContext { var p = new(ShowCreateRoutineLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateRoutineLoadStatement return p } func InitEmptyShowCreateRoutineLoadStatementContext(p *ShowCreateRoutineLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateRoutineLoadStatement } func (*ShowCreateRoutineLoadStatementContext) IsShowCreateRoutineLoadStatementContext() {} @@ -58458,7 +58458,7 @@ func NewShowCreateRoutineLoadStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateRoutineLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateRoutineLoadStatement return p } @@ -58474,19 +58474,19 @@ func (s *ShowCreateRoutineLoadStatementContext) SetDb(v IQualifiedNameContext) { func (s *ShowCreateRoutineLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *ShowCreateRoutineLoadStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateRoutineLoadStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateRoutineLoadStatementContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *ShowCreateRoutineLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowCreateRoutineLoadStatementContext) Identifier() IIdentifierContext { @@ -58530,20 +58530,20 @@ func (s *ShowCreateRoutineLoadStatementContext) ToStringTree(ruleNames []string, } func (s *ShowCreateRoutineLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateRoutineLoadStatement(s) } } func (s *ShowCreateRoutineLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateRoutineLoadStatement(s) } } func (s *ShowCreateRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateRoutineLoadStatement(s) default: @@ -58551,13 +58551,13 @@ func (s *ShowCreateRoutineLoadStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) ShowCreateRoutineLoadStatement() (localctx IShowCreateRoutineLoadStatementContext) { +func (p *StarRocksSQLParser) ShowCreateRoutineLoadStatement() (localctx IShowCreateRoutineLoadStatementContext) { localctx = NewShowCreateRoutineLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 390, DorisSQLParserRULE_showCreateRoutineLoadStatement) + p.EnterRule(localctx, 390, StarRocksSQLParserRULE_showCreateRoutineLoadStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(3684) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58565,7 +58565,7 @@ func (p *DorisSQLParser) ShowCreateRoutineLoadStatement() (localctx IShowCreateR } { p.SetState(3685) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58573,7 +58573,7 @@ func (p *DorisSQLParser) ShowCreateRoutineLoadStatement() (localctx IShowCreateR } { p.SetState(3686) - p.Match(DorisSQLParserROUTINE) + p.Match(StarRocksSQLParserROUTINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58581,7 +58581,7 @@ func (p *DorisSQLParser) ShowCreateRoutineLoadStatement() (localctx IShowCreateR } { p.SetState(3687) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58600,7 +58600,7 @@ func (p *DorisSQLParser) ShowCreateRoutineLoadStatement() (localctx IShowCreateR } { p.SetState(3689) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58682,13 +58682,13 @@ type ShowStreamLoadStatementContext struct { func NewEmptyShowStreamLoadStatementContext() *ShowStreamLoadStatementContext { var p = new(ShowStreamLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStreamLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showStreamLoadStatement return p } func InitEmptyShowStreamLoadStatementContext(p *ShowStreamLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStreamLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showStreamLoadStatement } func (*ShowStreamLoadStatementContext) IsShowStreamLoadStatementContext() {} @@ -58699,7 +58699,7 @@ func NewShowStreamLoadStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showStreamLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showStreamLoadStatement return p } @@ -58715,31 +58715,31 @@ func (s *ShowStreamLoadStatementContext) SetDb(v IQualifiedNameContext) { s.db = func (s *ShowStreamLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *ShowStreamLoadStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowStreamLoadStatementContext) STREAM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTREAM, 0) + return s.GetToken(StarRocksSQLParserSTREAM, 0) } func (s *ShowStreamLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowStreamLoadStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ShowStreamLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowStreamLoadStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowStreamLoadStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowStreamLoadStatementContext) Expression() IExpressionContext { @@ -58759,11 +58759,11 @@ func (s *ShowStreamLoadStatementContext) Expression() IExpressionContext { } func (s *ShowStreamLoadStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowStreamLoadStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowStreamLoadStatementContext) AllSortItem() []ISortItemContext { @@ -58889,20 +58889,20 @@ func (s *ShowStreamLoadStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowStreamLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowStreamLoadStatement(s) } } func (s *ShowStreamLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowStreamLoadStatement(s) } } func (s *ShowStreamLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowStreamLoadStatement(s) default: @@ -58910,15 +58910,15 @@ func (s *ShowStreamLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStatementContext) { +func (p *StarRocksSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStatementContext) { localctx = NewShowStreamLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 392, DorisSQLParserRULE_showStreamLoadStatement) + p.EnterRule(localctx, 392, StarRocksSQLParserRULE_showStreamLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3695) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58931,10 +58931,10 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL { + if _la == StarRocksSQLParserALL { { p.SetState(3696) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58944,7 +58944,7 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } { p.SetState(3699) - p.Match(DorisSQLParserSTREAM) + p.Match(StarRocksSQLParserSTREAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58952,7 +58952,7 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } { p.SetState(3700) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58965,10 +58965,10 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(3701) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -58987,7 +58987,7 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } { p.SetState(3703) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59013,10 +59013,10 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(3710) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59038,10 +59038,10 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3714) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59060,10 +59060,10 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(3718) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59071,7 +59071,7 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } { p.SetState(3719) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59088,10 +59088,10 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3721) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59118,7 +59118,7 @@ func (p *DorisSQLParser) ShowStreamLoadStatement() (localctx IShowStreamLoadStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(3730) p.LimitElement() @@ -59172,13 +59172,13 @@ type AnalyzeStatementContext struct { func NewEmptyAnalyzeStatementContext() *AnalyzeStatementContext { var p = new(AnalyzeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeStatement return p } func InitEmptyAnalyzeStatementContext(p *AnalyzeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeStatement } func (*AnalyzeStatementContext) IsAnalyzeStatementContext() {} @@ -59189,7 +59189,7 @@ func NewAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_analyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeStatement return p } @@ -59197,11 +59197,11 @@ func NewAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *AnalyzeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AnalyzeStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *AnalyzeStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *AnalyzeStatementContext) TableName() ITableNameContext { @@ -59253,11 +59253,11 @@ func (s *AnalyzeStatementContext) PartitionNames() IPartitionNamesContext { } func (s *AnalyzeStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *AnalyzeStatementContext) MODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODE, 0) + return s.GetToken(StarRocksSQLParserMODE, 0) } func (s *AnalyzeStatementContext) Properties() IPropertiesContext { @@ -59277,19 +59277,19 @@ func (s *AnalyzeStatementContext) Properties() IPropertiesContext { } func (s *AnalyzeStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *AnalyzeStatementContext) SAMPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSAMPLE, 0) + return s.GetToken(StarRocksSQLParserSAMPLE, 0) } func (s *AnalyzeStatementContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *AnalyzeStatementContext) ASYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASYNC, 0) + return s.GetToken(StarRocksSQLParserASYNC, 0) } func (s *AnalyzeStatementContext) GetRuleContext() antlr.RuleContext { @@ -59301,20 +59301,20 @@ func (s *AnalyzeStatementContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *AnalyzeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAnalyzeStatement(s) } } func (s *AnalyzeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAnalyzeStatement(s) } } func (s *AnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAnalyzeStatement(s) default: @@ -59322,15 +59322,15 @@ func (s *AnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) { +func (p *StarRocksSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) { localctx = NewAnalyzeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 394, DorisSQLParserRULE_analyzeStatement) + p.EnterRule(localctx, 394, StarRocksSQLParserRULE_analyzeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3733) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59343,12 +59343,12 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE { + if _la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE { { p.SetState(3734) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE) { + if !(_la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -59359,7 +59359,7 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) } { p.SetState(3737) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59388,7 +59388,7 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(3742) p.PartitionNames() @@ -59402,10 +59402,10 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(3745) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59415,7 +59415,7 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) p.SetState(3746) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserASYNC || _la == DorisSQLParserSYNC) { + if !(_la == StarRocksSQLParserASYNC || _la == StarRocksSQLParserSYNC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -59424,7 +59424,7 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) } { p.SetState(3747) - p.Match(DorisSQLParserMODE) + p.Match(StarRocksSQLParserMODE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59439,7 +59439,7 @@ func (p *DorisSQLParser) AnalyzeStatement() (localctx IAnalyzeStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3750) p.Properties() @@ -59478,13 +59478,13 @@ type AnalyzeColumnClauseContext struct { func NewEmptyAnalyzeColumnClauseContext() *AnalyzeColumnClauseContext { var p = new(AnalyzeColumnClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeColumnClause + p.RuleIndex = StarRocksSQLParserRULE_analyzeColumnClause return p } func InitEmptyAnalyzeColumnClauseContext(p *AnalyzeColumnClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeColumnClause + p.RuleIndex = StarRocksSQLParserRULE_analyzeColumnClause } func (*AnalyzeColumnClauseContext) IsAnalyzeColumnClauseContext() {} @@ -59495,7 +59495,7 @@ func NewAnalyzeColumnClauseContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_analyzeColumnClause + p.RuleIndex = StarRocksSQLParserRULE_analyzeColumnClause return p } @@ -59533,28 +59533,28 @@ func (s *PredicateColumnsContext) GetRuleContext() antlr.RuleContext { } func (s *PredicateColumnsContext) PREDICATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPREDICATE, 0) + return s.GetToken(StarRocksSQLParserPREDICATE, 0) } func (s *PredicateColumnsContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *PredicateColumnsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPredicateColumns(s) } } func (s *PredicateColumnsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPredicateColumns(s) } } func (s *PredicateColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPredicateColumns(s) default: @@ -59622,20 +59622,20 @@ func (s *RegularColumnsContext) QualifiedName(i int) IQualifiedNameContext { } func (s *RegularColumnsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRegularColumns(s) } } func (s *RegularColumnsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRegularColumns(s) } } func (s *RegularColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRegularColumns(s) default: @@ -59662,28 +59662,28 @@ func (s *AllColumnsContext) GetRuleContext() antlr.RuleContext { } func (s *AllColumnsContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *AllColumnsContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *AllColumnsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAllColumns(s) } } func (s *AllColumnsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAllColumns(s) } } func (s *AllColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAllColumns(s) default: @@ -59710,11 +59710,11 @@ func (s *MultiColumnSetContext) GetRuleContext() antlr.RuleContext { } func (s *MultiColumnSetContext) MULTIPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMULTIPLE, 0) + return s.GetToken(StarRocksSQLParserMULTIPLE, 0) } func (s *MultiColumnSetContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *MultiColumnSetContext) AllQualifiedName() []IQualifiedNameContext { @@ -59759,20 +59759,20 @@ func (s *MultiColumnSetContext) QualifiedName(i int) IQualifiedNameContext { } func (s *MultiColumnSetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMultiColumnSet(s) } } func (s *MultiColumnSetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMultiColumnSet(s) } } func (s *MultiColumnSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMultiColumnSet(s) default: @@ -59780,9 +59780,9 @@ func (s *MultiColumnSetContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseContext) { +func (p *StarRocksSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseContext) { localctx = NewAnalyzeColumnClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 396, DorisSQLParserRULE_analyzeColumnClause) + p.EnterRule(localctx, 396, StarRocksSQLParserRULE_analyzeColumnClause) var _la int p.SetState(3789) @@ -59797,7 +59797,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon p.EnterOuterAlt(localctx, 1) { p.SetState(3753) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59814,10 +59814,10 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3755) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59837,7 +59837,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } { p.SetState(3762) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59858,10 +59858,10 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3765) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59885,7 +59885,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon p.EnterOuterAlt(localctx, 3) { p.SetState(3772) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59893,7 +59893,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } { p.SetState(3773) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59905,7 +59905,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon p.EnterOuterAlt(localctx, 4) { p.SetState(3774) - p.Match(DorisSQLParserPREDICATE) + p.Match(StarRocksSQLParserPREDICATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59913,7 +59913,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } { p.SetState(3775) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59925,7 +59925,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon p.EnterOuterAlt(localctx, 5) { p.SetState(3776) - p.Match(DorisSQLParserMULTIPLE) + p.Match(StarRocksSQLParserMULTIPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59933,7 +59933,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } { p.SetState(3777) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59941,7 +59941,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } { p.SetState(3778) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59958,10 +59958,10 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3780) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -59981,7 +59981,7 @@ func (p *DorisSQLParser) AnalyzeColumnClause() (localctx IAnalyzeColumnClauseCon } { p.SetState(3787) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60031,13 +60031,13 @@ type DropStatsStatementContext struct { func NewEmptyDropStatsStatementContext() *DropStatsStatementContext { var p = new(DropStatsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_dropStatsStatement return p } func InitEmptyDropStatsStatementContext(p *DropStatsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_dropStatsStatement } func (*DropStatsStatementContext) IsDropStatsStatementContext() {} @@ -60048,7 +60048,7 @@ func NewDropStatsStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_dropStatsStatement return p } @@ -60056,11 +60056,11 @@ func NewDropStatsStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *DropStatsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropStatsStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropStatsStatementContext) STATS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATS, 0) + return s.GetToken(StarRocksSQLParserSTATS, 0) } func (s *DropStatsStatementContext) QualifiedName() IQualifiedNameContext { @@ -60080,11 +60080,11 @@ func (s *DropStatsStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropStatsStatementContext) MULTIPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMULTIPLE, 0) + return s.GetToken(StarRocksSQLParserMULTIPLE, 0) } func (s *DropStatsStatementContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *DropStatsStatementContext) GetRuleContext() antlr.RuleContext { @@ -60096,20 +60096,20 @@ func (s *DropStatsStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *DropStatsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropStatsStatement(s) } } func (s *DropStatsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropStatsStatement(s) } } func (s *DropStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropStatsStatement(s) default: @@ -60117,15 +60117,15 @@ func (s *DropStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) DropStatsStatement() (localctx IDropStatsStatementContext) { +func (p *StarRocksSQLParser) DropStatsStatement() (localctx IDropStatsStatementContext) { localctx = NewDropStatsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 398, DorisSQLParserRULE_dropStatsStatement) + p.EnterRule(localctx, 398, StarRocksSQLParserRULE_dropStatsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3791) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60138,10 +60138,10 @@ func (p *DorisSQLParser) DropStatsStatement() (localctx IDropStatsStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserMULTIPLE { + if _la == StarRocksSQLParserMULTIPLE { { p.SetState(3792) - p.Match(DorisSQLParserMULTIPLE) + p.Match(StarRocksSQLParserMULTIPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60149,7 +60149,7 @@ func (p *DorisSQLParser) DropStatsStatement() (localctx IDropStatsStatementConte } { p.SetState(3793) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60159,7 +60159,7 @@ func (p *DorisSQLParser) DropStatsStatement() (localctx IDropStatsStatementConte } { p.SetState(3796) - p.Match(DorisSQLParserSTATS) + p.Match(StarRocksSQLParserSTATS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60222,13 +60222,13 @@ type HistogramStatementContext struct { func NewEmptyHistogramStatementContext() *HistogramStatementContext { var p = new(HistogramStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_histogramStatement + p.RuleIndex = StarRocksSQLParserRULE_histogramStatement return p } func InitEmptyHistogramStatementContext(p *HistogramStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_histogramStatement + p.RuleIndex = StarRocksSQLParserRULE_histogramStatement } func (*HistogramStatementContext) IsHistogramStatementContext() {} @@ -60239,7 +60239,7 @@ func NewHistogramStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_histogramStatement + p.RuleIndex = StarRocksSQLParserRULE_histogramStatement return p } @@ -60251,11 +60251,11 @@ func (s *HistogramStatementContext) GetBucket() antlr.Token { return s.bucket } func (s *HistogramStatementContext) SetBucket(v antlr.Token) { s.bucket = v } func (s *HistogramStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *HistogramStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *HistogramStatementContext) TableName() ITableNameContext { @@ -60275,15 +60275,15 @@ func (s *HistogramStatementContext) TableName() ITableNameContext { } func (s *HistogramStatementContext) UPDATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUPDATE, 0) + return s.GetToken(StarRocksSQLParserUPDATE, 0) } func (s *HistogramStatementContext) HISTOGRAM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHISTOGRAM, 0) + return s.GetToken(StarRocksSQLParserHISTOGRAM, 0) } func (s *HistogramStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *HistogramStatementContext) AnalyzeColumnClause() IAnalyzeColumnClauseContext { @@ -60303,11 +60303,11 @@ func (s *HistogramStatementContext) AnalyzeColumnClause() IAnalyzeColumnClauseCo } func (s *HistogramStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *HistogramStatementContext) BUCKETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBUCKETS, 0) + return s.GetToken(StarRocksSQLParserBUCKETS, 0) } func (s *HistogramStatementContext) Properties() IPropertiesContext { @@ -60327,7 +60327,7 @@ func (s *HistogramStatementContext) Properties() IPropertiesContext { } func (s *HistogramStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *HistogramStatementContext) GetRuleContext() antlr.RuleContext { @@ -60339,20 +60339,20 @@ func (s *HistogramStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *HistogramStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterHistogramStatement(s) } } func (s *HistogramStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitHistogramStatement(s) } } func (s *HistogramStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitHistogramStatement(s) default: @@ -60360,15 +60360,15 @@ func (s *HistogramStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementContext) { +func (p *StarRocksSQLParser) HistogramStatement() (localctx IHistogramStatementContext) { localctx = NewHistogramStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 400, DorisSQLParserRULE_histogramStatement) + p.EnterRule(localctx, 400, StarRocksSQLParserRULE_histogramStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3799) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60376,7 +60376,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte } { p.SetState(3800) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60388,7 +60388,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte } { p.SetState(3802) - p.Match(DorisSQLParserUPDATE) + p.Match(StarRocksSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60396,7 +60396,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte } { p.SetState(3803) - p.Match(DorisSQLParserHISTOGRAM) + p.Match(StarRocksSQLParserHISTOGRAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60404,7 +60404,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte } { p.SetState(3804) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60420,7 +60420,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 353, p.GetParserRuleContext()) == 1 { { p.SetState(3806) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60429,7 +60429,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte { p.SetState(3807) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*HistogramStatementContext).bucket = _m if p.HasError() { @@ -60439,7 +60439,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte } { p.SetState(3808) - p.Match(DorisSQLParserBUCKETS) + p.Match(StarRocksSQLParserBUCKETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60456,7 +60456,7 @@ func (p *DorisSQLParser) HistogramStatement() (localctx IHistogramStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3811) p.Properties() @@ -60503,13 +60503,13 @@ type AnalyzeHistogramStatementContext struct { func NewEmptyAnalyzeHistogramStatementContext() *AnalyzeHistogramStatementContext { var p = new(AnalyzeHistogramStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeHistogramStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeHistogramStatement return p } func InitEmptyAnalyzeHistogramStatementContext(p *AnalyzeHistogramStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeHistogramStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeHistogramStatement } func (*AnalyzeHistogramStatementContext) IsAnalyzeHistogramStatementContext() {} @@ -60520,7 +60520,7 @@ func NewAnalyzeHistogramStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_analyzeHistogramStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeHistogramStatement return p } @@ -60544,19 +60544,19 @@ func (s *AnalyzeHistogramStatementContext) HistogramStatement() IHistogramStatem } func (s *AnalyzeHistogramStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *AnalyzeHistogramStatementContext) MODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODE, 0) + return s.GetToken(StarRocksSQLParserMODE, 0) } func (s *AnalyzeHistogramStatementContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *AnalyzeHistogramStatementContext) ASYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASYNC, 0) + return s.GetToken(StarRocksSQLParserASYNC, 0) } func (s *AnalyzeHistogramStatementContext) GetRuleContext() antlr.RuleContext { @@ -60568,20 +60568,20 @@ func (s *AnalyzeHistogramStatementContext) ToStringTree(ruleNames []string, reco } func (s *AnalyzeHistogramStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAnalyzeHistogramStatement(s) } } func (s *AnalyzeHistogramStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAnalyzeHistogramStatement(s) } } func (s *AnalyzeHistogramStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAnalyzeHistogramStatement(s) default: @@ -60589,9 +60589,9 @@ func (s *AnalyzeHistogramStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) AnalyzeHistogramStatement() (localctx IAnalyzeHistogramStatementContext) { +func (p *StarRocksSQLParser) AnalyzeHistogramStatement() (localctx IAnalyzeHistogramStatementContext) { localctx = NewAnalyzeHistogramStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 402, DorisSQLParserRULE_analyzeHistogramStatement) + p.EnterRule(localctx, 402, StarRocksSQLParserRULE_analyzeHistogramStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -60606,10 +60606,10 @@ func (p *DorisSQLParser) AnalyzeHistogramStatement() (localctx IAnalyzeHistogram } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(3815) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60619,7 +60619,7 @@ func (p *DorisSQLParser) AnalyzeHistogramStatement() (localctx IAnalyzeHistogram p.SetState(3816) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserASYNC || _la == DorisSQLParserSYNC) { + if !(_la == StarRocksSQLParserASYNC || _la == StarRocksSQLParserSYNC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -60628,7 +60628,7 @@ func (p *DorisSQLParser) AnalyzeHistogramStatement() (localctx IAnalyzeHistogram } { p.SetState(3817) - p.Match(DorisSQLParserMODE) + p.Match(StarRocksSQLParserMODE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60678,13 +60678,13 @@ type DropHistogramStatementContext struct { func NewEmptyDropHistogramStatementContext() *DropHistogramStatementContext { var p = new(DropHistogramStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropHistogramStatement + p.RuleIndex = StarRocksSQLParserRULE_dropHistogramStatement return p } func InitEmptyDropHistogramStatementContext(p *DropHistogramStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropHistogramStatement + p.RuleIndex = StarRocksSQLParserRULE_dropHistogramStatement } func (*DropHistogramStatementContext) IsDropHistogramStatementContext() {} @@ -60695,7 +60695,7 @@ func NewDropHistogramStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropHistogramStatement + p.RuleIndex = StarRocksSQLParserRULE_dropHistogramStatement return p } @@ -60703,11 +60703,11 @@ func NewDropHistogramStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *DropHistogramStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropHistogramStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *DropHistogramStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *DropHistogramStatementContext) AllQualifiedName() []IQualifiedNameContext { @@ -60752,15 +60752,15 @@ func (s *DropHistogramStatementContext) QualifiedName(i int) IQualifiedNameConte } func (s *DropHistogramStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropHistogramStatementContext) HISTOGRAM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHISTOGRAM, 0) + return s.GetToken(StarRocksSQLParserHISTOGRAM, 0) } func (s *DropHistogramStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *DropHistogramStatementContext) GetRuleContext() antlr.RuleContext { @@ -60772,20 +60772,20 @@ func (s *DropHistogramStatementContext) ToStringTree(ruleNames []string, recog a } func (s *DropHistogramStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropHistogramStatement(s) } } func (s *DropHistogramStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropHistogramStatement(s) } } func (s *DropHistogramStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropHistogramStatement(s) default: @@ -60793,15 +60793,15 @@ func (s *DropHistogramStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) DropHistogramStatement() (localctx IDropHistogramStatementContext) { +func (p *StarRocksSQLParser) DropHistogramStatement() (localctx IDropHistogramStatementContext) { localctx = NewDropHistogramStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 404, DorisSQLParserRULE_dropHistogramStatement) + p.EnterRule(localctx, 404, StarRocksSQLParserRULE_dropHistogramStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3820) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60809,7 +60809,7 @@ func (p *DorisSQLParser) DropHistogramStatement() (localctx IDropHistogramStatem } { p.SetState(3821) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60821,7 +60821,7 @@ func (p *DorisSQLParser) DropHistogramStatement() (localctx IDropHistogramStatem } { p.SetState(3823) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60829,7 +60829,7 @@ func (p *DorisSQLParser) DropHistogramStatement() (localctx IDropHistogramStatem } { p.SetState(3824) - p.Match(DorisSQLParserHISTOGRAM) + p.Match(StarRocksSQLParserHISTOGRAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60837,7 +60837,7 @@ func (p *DorisSQLParser) DropHistogramStatement() (localctx IDropHistogramStatem } { p.SetState(3825) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60854,10 +60854,10 @@ func (p *DorisSQLParser) DropHistogramStatement() (localctx IDropHistogramStatem } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3827) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -60929,13 +60929,13 @@ type CreateAnalyzeStatementContext struct { func NewEmptyCreateAnalyzeStatementContext() *CreateAnalyzeStatementContext { var p = new(CreateAnalyzeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_createAnalyzeStatement return p } func InitEmptyCreateAnalyzeStatementContext(p *CreateAnalyzeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_createAnalyzeStatement } func (*CreateAnalyzeStatementContext) IsCreateAnalyzeStatementContext() {} @@ -60946,7 +60946,7 @@ func NewCreateAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_createAnalyzeStatement return p } @@ -60958,15 +60958,15 @@ func (s *CreateAnalyzeStatementContext) GetDb() IIdentifierContext { return s.db func (s *CreateAnalyzeStatementContext) SetDb(v IIdentifierContext) { s.db = v } func (s *CreateAnalyzeStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateAnalyzeStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *CreateAnalyzeStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *CreateAnalyzeStatementContext) Properties() IPropertiesContext { @@ -60986,15 +60986,15 @@ func (s *CreateAnalyzeStatementContext) Properties() IPropertiesContext { } func (s *CreateAnalyzeStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *CreateAnalyzeStatementContext) SAMPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSAMPLE, 0) + return s.GetToken(StarRocksSQLParserSAMPLE, 0) } func (s *CreateAnalyzeStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *CreateAnalyzeStatementContext) Identifier() IIdentifierContext { @@ -61014,7 +61014,7 @@ func (s *CreateAnalyzeStatementContext) Identifier() IIdentifierContext { } func (s *CreateAnalyzeStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CreateAnalyzeStatementContext) AllQualifiedName() []IQualifiedNameContext { @@ -61083,20 +61083,20 @@ func (s *CreateAnalyzeStatementContext) ToStringTree(ruleNames []string, recog a } func (s *CreateAnalyzeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateAnalyzeStatement(s) } } func (s *CreateAnalyzeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateAnalyzeStatement(s) } } func (s *CreateAnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateAnalyzeStatement(s) default: @@ -61104,9 +61104,9 @@ func (s *CreateAnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatementContext) { +func (p *StarRocksSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatementContext) { localctx = NewCreateAnalyzeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 406, DorisSQLParserRULE_createAnalyzeStatement) + p.EnterRule(localctx, 406, StarRocksSQLParserRULE_createAnalyzeStatement) var _la int p.SetState(3878) @@ -61120,7 +61120,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem p.EnterOuterAlt(localctx, 1) { p.SetState(3834) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61128,7 +61128,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3835) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61141,12 +61141,12 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE { + if _la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE { { p.SetState(3836) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE) { + if !(_la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -61157,7 +61157,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3839) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61170,7 +61170,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3840) p.Properties() @@ -61182,7 +61182,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem p.EnterOuterAlt(localctx, 2) { p.SetState(3843) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61190,7 +61190,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3844) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61203,12 +61203,12 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE { + if _la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE { { p.SetState(3845) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE) { + if !(_la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -61219,7 +61219,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3848) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61239,7 +61239,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3850) p.Properties() @@ -61251,7 +61251,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem p.EnterOuterAlt(localctx, 3) { p.SetState(3853) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61259,7 +61259,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3854) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61272,12 +61272,12 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE { + if _la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE { { p.SetState(3855) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFULL || _la == DorisSQLParserSAMPLE) { + if !(_la == StarRocksSQLParserFULL || _la == StarRocksSQLParserSAMPLE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -61288,7 +61288,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3858) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61305,10 +61305,10 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(3860) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61325,10 +61325,10 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3862) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61348,7 +61348,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } { p.SetState(3869) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61363,7 +61363,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3873) p.Properties() @@ -61375,7 +61375,7 @@ func (p *DorisSQLParser) CreateAnalyzeStatement() (localctx ICreateAnalyzeStatem p.EnterOuterAlt(localctx, 4) { p.SetState(3876) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61429,13 +61429,13 @@ type DropAnalyzeJobStatementContext struct { func NewEmptyDropAnalyzeJobStatementContext() *DropAnalyzeJobStatementContext { var p = new(DropAnalyzeJobStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropAnalyzeJobStatement + p.RuleIndex = StarRocksSQLParserRULE_dropAnalyzeJobStatement return p } func InitEmptyDropAnalyzeJobStatementContext(p *DropAnalyzeJobStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropAnalyzeJobStatement + p.RuleIndex = StarRocksSQLParserRULE_dropAnalyzeJobStatement } func (*DropAnalyzeJobStatementContext) IsDropAnalyzeJobStatementContext() {} @@ -61446,7 +61446,7 @@ func NewDropAnalyzeJobStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropAnalyzeJobStatement + p.RuleIndex = StarRocksSQLParserRULE_dropAnalyzeJobStatement return p } @@ -61454,23 +61454,23 @@ func NewDropAnalyzeJobStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *DropAnalyzeJobStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropAnalyzeJobStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropAnalyzeJobStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *DropAnalyzeJobStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *DropAnalyzeJobStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *DropAnalyzeJobStatementContext) JOB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOB, 0) + return s.GetToken(StarRocksSQLParserJOB, 0) } func (s *DropAnalyzeJobStatementContext) GetRuleContext() antlr.RuleContext { @@ -61482,20 +61482,20 @@ func (s *DropAnalyzeJobStatementContext) ToStringTree(ruleNames []string, recog } func (s *DropAnalyzeJobStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropAnalyzeJobStatement(s) } } func (s *DropAnalyzeJobStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropAnalyzeJobStatement(s) } } func (s *DropAnalyzeJobStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropAnalyzeJobStatement(s) default: @@ -61503,9 +61503,9 @@ func (s *DropAnalyzeJobStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStatementContext) { +func (p *StarRocksSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStatementContext) { localctx = NewDropAnalyzeJobStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 408, DorisSQLParserRULE_dropAnalyzeJobStatement) + p.EnterRule(localctx, 408, StarRocksSQLParserRULE_dropAnalyzeJobStatement) p.SetState(3887) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -61517,7 +61517,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat p.EnterOuterAlt(localctx, 1) { p.SetState(3880) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61525,7 +61525,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat } { p.SetState(3881) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61533,7 +61533,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat } { p.SetState(3882) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61544,7 +61544,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat p.EnterOuterAlt(localctx, 2) { p.SetState(3883) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61552,7 +61552,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat } { p.SetState(3884) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61560,7 +61560,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat } { p.SetState(3885) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61568,7 +61568,7 @@ func (p *DorisSQLParser) DropAnalyzeJobStatement() (localctx IDropAnalyzeJobStat } { p.SetState(3886) - p.Match(DorisSQLParserJOB) + p.Match(StarRocksSQLParserJOB) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61624,13 +61624,13 @@ type ShowAnalyzeStatementContext struct { func NewEmptyShowAnalyzeStatementContext() *ShowAnalyzeStatementContext { var p = new(ShowAnalyzeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_showAnalyzeStatement return p } func InitEmptyShowAnalyzeStatementContext(p *ShowAnalyzeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_showAnalyzeStatement } func (*ShowAnalyzeStatementContext) IsShowAnalyzeStatementContext() {} @@ -61641,7 +61641,7 @@ func NewShowAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_showAnalyzeStatement return p } @@ -61649,15 +61649,15 @@ func NewShowAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowAnalyzeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowAnalyzeStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowAnalyzeStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *ShowAnalyzeStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowAnalyzeStatementContext) Expression() IExpressionContext { @@ -61677,11 +61677,11 @@ func (s *ShowAnalyzeStatementContext) Expression() IExpressionContext { } func (s *ShowAnalyzeStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowAnalyzeStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowAnalyzeStatementContext) AllSortItem() []ISortItemContext { @@ -61742,11 +61742,11 @@ func (s *ShowAnalyzeStatementContext) LimitElement() ILimitElementContext { } func (s *ShowAnalyzeStatementContext) JOB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOB, 0) + return s.GetToken(StarRocksSQLParserJOB, 0) } func (s *ShowAnalyzeStatementContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *ShowAnalyzeStatementContext) GetRuleContext() antlr.RuleContext { @@ -61758,20 +61758,20 @@ func (s *ShowAnalyzeStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowAnalyzeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowAnalyzeStatement(s) } } func (s *ShowAnalyzeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowAnalyzeStatement(s) } } func (s *ShowAnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowAnalyzeStatement(s) default: @@ -61779,15 +61779,15 @@ func (s *ShowAnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementContext) { +func (p *StarRocksSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementContext) { localctx = NewShowAnalyzeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 410, DorisSQLParserRULE_showAnalyzeStatement) + p.EnterRule(localctx, 410, StarRocksSQLParserRULE_showAnalyzeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3889) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61795,7 +61795,7 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } { p.SetState(3890) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61808,12 +61808,12 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserJOB || _la == DorisSQLParserSTATUS { + if _la == StarRocksSQLParserJOB || _la == StarRocksSQLParserSTATUS { { p.SetState(3891) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserJOB || _la == DorisSQLParserSTATUS) { + if !(_la == StarRocksSQLParserJOB || _la == StarRocksSQLParserSTATUS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -61829,10 +61829,10 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3894) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61851,10 +61851,10 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(3898) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61862,7 +61862,7 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } { p.SetState(3899) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61879,10 +61879,10 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3901) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -61909,7 +61909,7 @@ func (p *DorisSQLParser) ShowAnalyzeStatement() (localctx IShowAnalyzeStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(3910) p.LimitElement() @@ -61963,13 +61963,13 @@ type ShowStatsMetaStatementContext struct { func NewEmptyShowStatsMetaStatementContext() *ShowStatsMetaStatementContext { var p = new(ShowStatsMetaStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStatsMetaStatement + p.RuleIndex = StarRocksSQLParserRULE_showStatsMetaStatement return p } func InitEmptyShowStatsMetaStatementContext(p *ShowStatsMetaStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStatsMetaStatement + p.RuleIndex = StarRocksSQLParserRULE_showStatsMetaStatement } func (*ShowStatsMetaStatementContext) IsShowStatsMetaStatementContext() {} @@ -61980,7 +61980,7 @@ func NewShowStatsMetaStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showStatsMetaStatement + p.RuleIndex = StarRocksSQLParserRULE_showStatsMetaStatement return p } @@ -61988,27 +61988,27 @@ func NewShowStatsMetaStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *ShowStatsMetaStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowStatsMetaStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowStatsMetaStatementContext) STATS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATS, 0) + return s.GetToken(StarRocksSQLParserSTATS, 0) } func (s *ShowStatsMetaStatementContext) META() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMETA, 0) + return s.GetToken(StarRocksSQLParserMETA, 0) } func (s *ShowStatsMetaStatementContext) MULTIPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMULTIPLE, 0) + return s.GetToken(StarRocksSQLParserMULTIPLE, 0) } func (s *ShowStatsMetaStatementContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *ShowStatsMetaStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowStatsMetaStatementContext) Expression() IExpressionContext { @@ -62028,11 +62028,11 @@ func (s *ShowStatsMetaStatementContext) Expression() IExpressionContext { } func (s *ShowStatsMetaStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowStatsMetaStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowStatsMetaStatementContext) AllSortItem() []ISortItemContext { @@ -62101,20 +62101,20 @@ func (s *ShowStatsMetaStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowStatsMetaStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowStatsMetaStatement(s) } } func (s *ShowStatsMetaStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowStatsMetaStatement(s) } } func (s *ShowStatsMetaStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowStatsMetaStatement(s) default: @@ -62122,15 +62122,15 @@ func (s *ShowStatsMetaStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatementContext) { +func (p *StarRocksSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatementContext) { localctx = NewShowStatsMetaStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 412, DorisSQLParserRULE_showStatsMetaStatement) + p.EnterRule(localctx, 412, StarRocksSQLParserRULE_showStatsMetaStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3913) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62143,10 +62143,10 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserMULTIPLE { + if _la == StarRocksSQLParserMULTIPLE { { p.SetState(3914) - p.Match(DorisSQLParserMULTIPLE) + p.Match(StarRocksSQLParserMULTIPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62154,7 +62154,7 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } { p.SetState(3915) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62164,7 +62164,7 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } { p.SetState(3918) - p.Match(DorisSQLParserSTATS) + p.Match(StarRocksSQLParserSTATS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62172,7 +62172,7 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } { p.SetState(3919) - p.Match(DorisSQLParserMETA) + p.Match(StarRocksSQLParserMETA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62185,10 +62185,10 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3920) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62207,10 +62207,10 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(3924) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62218,7 +62218,7 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } { p.SetState(3925) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62235,10 +62235,10 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3927) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62265,7 +62265,7 @@ func (p *DorisSQLParser) ShowStatsMetaStatement() (localctx IShowStatsMetaStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(3936) p.LimitElement() @@ -62317,13 +62317,13 @@ type ShowHistogramMetaStatementContext struct { func NewEmptyShowHistogramMetaStatementContext() *ShowHistogramMetaStatementContext { var p = new(ShowHistogramMetaStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showHistogramMetaStatement + p.RuleIndex = StarRocksSQLParserRULE_showHistogramMetaStatement return p } func InitEmptyShowHistogramMetaStatementContext(p *ShowHistogramMetaStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showHistogramMetaStatement + p.RuleIndex = StarRocksSQLParserRULE_showHistogramMetaStatement } func (*ShowHistogramMetaStatementContext) IsShowHistogramMetaStatementContext() {} @@ -62334,7 +62334,7 @@ func NewShowHistogramMetaStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showHistogramMetaStatement + p.RuleIndex = StarRocksSQLParserRULE_showHistogramMetaStatement return p } @@ -62342,19 +62342,19 @@ func NewShowHistogramMetaStatementContext(parser antlr.Parser, parent antlr.Pars func (s *ShowHistogramMetaStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowHistogramMetaStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowHistogramMetaStatementContext) HISTOGRAM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHISTOGRAM, 0) + return s.GetToken(StarRocksSQLParserHISTOGRAM, 0) } func (s *ShowHistogramMetaStatementContext) META() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMETA, 0) + return s.GetToken(StarRocksSQLParserMETA, 0) } func (s *ShowHistogramMetaStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowHistogramMetaStatementContext) Expression() IExpressionContext { @@ -62374,11 +62374,11 @@ func (s *ShowHistogramMetaStatementContext) Expression() IExpressionContext { } func (s *ShowHistogramMetaStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowHistogramMetaStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowHistogramMetaStatementContext) AllSortItem() []ISortItemContext { @@ -62447,20 +62447,20 @@ func (s *ShowHistogramMetaStatementContext) ToStringTree(ruleNames []string, rec } func (s *ShowHistogramMetaStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowHistogramMetaStatement(s) } } func (s *ShowHistogramMetaStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowHistogramMetaStatement(s) } } func (s *ShowHistogramMetaStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowHistogramMetaStatement(s) default: @@ -62468,15 +62468,15 @@ func (s *ShowHistogramMetaStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMetaStatementContext) { +func (p *StarRocksSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMetaStatementContext) { localctx = NewShowHistogramMetaStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 414, DorisSQLParserRULE_showHistogramMetaStatement) + p.EnterRule(localctx, 414, StarRocksSQLParserRULE_showHistogramMetaStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3939) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62484,7 +62484,7 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } { p.SetState(3940) - p.Match(DorisSQLParserHISTOGRAM) + p.Match(StarRocksSQLParserHISTOGRAM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62492,7 +62492,7 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } { p.SetState(3941) - p.Match(DorisSQLParserMETA) + p.Match(StarRocksSQLParserMETA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62505,10 +62505,10 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(3942) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62527,10 +62527,10 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(3946) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62538,7 +62538,7 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } { p.SetState(3947) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62555,10 +62555,10 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3949) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62585,7 +62585,7 @@ func (p *DorisSQLParser) ShowHistogramMetaStatement() (localctx IShowHistogramMe } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(3958) p.LimitElement() @@ -62630,13 +62630,13 @@ type KillAnalyzeStatementContext struct { func NewEmptyKillAnalyzeStatementContext() *KillAnalyzeStatementContext { var p = new(KillAnalyzeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_killAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_killAnalyzeStatement return p } func InitEmptyKillAnalyzeStatementContext(p *KillAnalyzeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_killAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_killAnalyzeStatement } func (*KillAnalyzeStatementContext) IsKillAnalyzeStatementContext() {} @@ -62647,7 +62647,7 @@ func NewKillAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_killAnalyzeStatement + p.RuleIndex = StarRocksSQLParserRULE_killAnalyzeStatement return p } @@ -62655,15 +62655,15 @@ func NewKillAnalyzeStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *KillAnalyzeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *KillAnalyzeStatementContext) KILL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKILL, 0) + return s.GetToken(StarRocksSQLParserKILL, 0) } func (s *KillAnalyzeStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *KillAnalyzeStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *KillAnalyzeStatementContext) GetRuleContext() antlr.RuleContext { @@ -62675,20 +62675,20 @@ func (s *KillAnalyzeStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *KillAnalyzeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterKillAnalyzeStatement(s) } } func (s *KillAnalyzeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitKillAnalyzeStatement(s) } } func (s *KillAnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitKillAnalyzeStatement(s) default: @@ -62696,13 +62696,13 @@ func (s *KillAnalyzeStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) KillAnalyzeStatement() (localctx IKillAnalyzeStatementContext) { +func (p *StarRocksSQLParser) KillAnalyzeStatement() (localctx IKillAnalyzeStatementContext) { localctx = NewKillAnalyzeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 416, DorisSQLParserRULE_killAnalyzeStatement) + p.EnterRule(localctx, 416, StarRocksSQLParserRULE_killAnalyzeStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(3961) - p.Match(DorisSQLParserKILL) + p.Match(StarRocksSQLParserKILL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62710,7 +62710,7 @@ func (p *DorisSQLParser) KillAnalyzeStatement() (localctx IKillAnalyzeStatementC } { p.SetState(3962) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62718,7 +62718,7 @@ func (p *DorisSQLParser) KillAnalyzeStatement() (localctx IKillAnalyzeStatementC } { p.SetState(3963) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62765,13 +62765,13 @@ type AnalyzeProfileStatementContext struct { func NewEmptyAnalyzeProfileStatementContext() *AnalyzeProfileStatementContext { var p = new(AnalyzeProfileStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeProfileStatement return p } func InitEmptyAnalyzeProfileStatementContext(p *AnalyzeProfileStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_analyzeProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeProfileStatement } func (*AnalyzeProfileStatementContext) IsAnalyzeProfileStatementContext() {} @@ -62782,7 +62782,7 @@ func NewAnalyzeProfileStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_analyzeProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_analyzeProfileStatement return p } @@ -62790,15 +62790,15 @@ func NewAnalyzeProfileStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *AnalyzeProfileStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AnalyzeProfileStatementContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *AnalyzeProfileStatementContext) PROFILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROFILE, 0) + return s.GetToken(StarRocksSQLParserPROFILE, 0) } func (s *AnalyzeProfileStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *AnalyzeProfileStatementContext) String_() IStringContext { @@ -62818,11 +62818,11 @@ func (s *AnalyzeProfileStatementContext) String_() IStringContext { } func (s *AnalyzeProfileStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *AnalyzeProfileStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *AnalyzeProfileStatementContext) GetRuleContext() antlr.RuleContext { @@ -62834,20 +62834,20 @@ func (s *AnalyzeProfileStatementContext) ToStringTree(ruleNames []string, recog } func (s *AnalyzeProfileStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAnalyzeProfileStatement(s) } } func (s *AnalyzeProfileStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAnalyzeProfileStatement(s) } } func (s *AnalyzeProfileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAnalyzeProfileStatement(s) default: @@ -62855,9 +62855,9 @@ func (s *AnalyzeProfileStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStatementContext) { +func (p *StarRocksSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStatementContext) { localctx = NewAnalyzeProfileStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 418, DorisSQLParserRULE_analyzeProfileStatement) + p.EnterRule(localctx, 418, StarRocksSQLParserRULE_analyzeProfileStatement) var _la int p.SetState(3982) @@ -62871,7 +62871,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat p.EnterOuterAlt(localctx, 1) { p.SetState(3965) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62879,7 +62879,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3966) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62887,7 +62887,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3967) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62902,7 +62902,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat p.EnterOuterAlt(localctx, 2) { p.SetState(3969) - p.Match(DorisSQLParserANALYZE) + p.Match(StarRocksSQLParserANALYZE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62910,7 +62910,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3970) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62918,7 +62918,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3971) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62930,7 +62930,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3973) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62938,7 +62938,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3974) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62951,10 +62951,10 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(3975) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -62962,7 +62962,7 @@ func (p *DorisSQLParser) AnalyzeProfileStatement() (localctx IAnalyzeProfileStat } { p.SetState(3976) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63023,13 +63023,13 @@ type CreateBaselinePlanStatementContext struct { func NewEmptyCreateBaselinePlanStatementContext() *CreateBaselinePlanStatementContext { var p = new(CreateBaselinePlanStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_createBaselinePlanStatement return p } func InitEmptyCreateBaselinePlanStatementContext(p *CreateBaselinePlanStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_createBaselinePlanStatement } func (*CreateBaselinePlanStatementContext) IsCreateBaselinePlanStatementContext() {} @@ -63040,7 +63040,7 @@ func NewCreateBaselinePlanStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_createBaselinePlanStatement return p } @@ -63048,15 +63048,15 @@ func NewCreateBaselinePlanStatementContext(parser antlr.Parser, parent antlr.Par func (s *CreateBaselinePlanStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateBaselinePlanStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateBaselinePlanStatementContext) BASELINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBASELINE, 0) + return s.GetToken(StarRocksSQLParserBASELINE, 0) } func (s *CreateBaselinePlanStatementContext) USING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSING, 0) + return s.GetToken(StarRocksSQLParserUSING, 0) } func (s *CreateBaselinePlanStatementContext) AllQueryRelation() []IQueryRelationContext { @@ -63101,11 +63101,11 @@ func (s *CreateBaselinePlanStatementContext) QueryRelation(i int) IQueryRelation } func (s *CreateBaselinePlanStatementContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *CreateBaselinePlanStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CreateBaselinePlanStatementContext) Properties() IPropertiesContext { @@ -63133,20 +63133,20 @@ func (s *CreateBaselinePlanStatementContext) ToStringTree(ruleNames []string, re } func (s *CreateBaselinePlanStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateBaselinePlanStatement(s) } } func (s *CreateBaselinePlanStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateBaselinePlanStatement(s) } } func (s *CreateBaselinePlanStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateBaselinePlanStatement(s) default: @@ -63154,15 +63154,15 @@ func (s *CreateBaselinePlanStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaselinePlanStatementContext) { +func (p *StarRocksSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaselinePlanStatementContext) { localctx = NewCreateBaselinePlanStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 420, DorisSQLParserRULE_createBaselinePlanStatement) + p.EnterRule(localctx, 420, StarRocksSQLParserRULE_createBaselinePlanStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3984) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63175,10 +63175,10 @@ func (p *DorisSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaseline } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL { + if _la == StarRocksSQLParserGLOBAL { { p.SetState(3985) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63188,7 +63188,7 @@ func (p *DorisSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaseline } { p.SetState(3988) - p.Match(DorisSQLParserBASELINE) + p.Match(StarRocksSQLParserBASELINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63201,10 +63201,10 @@ func (p *DorisSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaseline } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserON { + if _la == StarRocksSQLParserON { { p.SetState(3989) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63218,7 +63218,7 @@ func (p *DorisSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaseline } { p.SetState(3993) - p.Match(DorisSQLParserUSING) + p.Match(StarRocksSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63235,7 +63235,7 @@ func (p *DorisSQLParser) CreateBaselinePlanStatement() (localctx ICreateBaseline } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(3995) p.Properties() @@ -63281,13 +63281,13 @@ type DropBaselinePlanStatementContext struct { func NewEmptyDropBaselinePlanStatementContext() *DropBaselinePlanStatementContext { var p = new(DropBaselinePlanStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_dropBaselinePlanStatement return p } func InitEmptyDropBaselinePlanStatementContext(p *DropBaselinePlanStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_dropBaselinePlanStatement } func (*DropBaselinePlanStatementContext) IsDropBaselinePlanStatementContext() {} @@ -63298,7 +63298,7 @@ func NewDropBaselinePlanStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_dropBaselinePlanStatement return p } @@ -63306,19 +63306,19 @@ func NewDropBaselinePlanStatementContext(parser antlr.Parser, parent antlr.Parse func (s *DropBaselinePlanStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropBaselinePlanStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropBaselinePlanStatementContext) BASELINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBASELINE, 0) + return s.GetToken(StarRocksSQLParserBASELINE, 0) } func (s *DropBaselinePlanStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *DropBaselinePlanStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *DropBaselinePlanStatementContext) GetRuleContext() antlr.RuleContext { @@ -63330,20 +63330,20 @@ func (s *DropBaselinePlanStatementContext) ToStringTree(ruleNames []string, reco } func (s *DropBaselinePlanStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropBaselinePlanStatement(s) } } func (s *DropBaselinePlanStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropBaselinePlanStatement(s) } } func (s *DropBaselinePlanStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropBaselinePlanStatement(s) default: @@ -63351,15 +63351,15 @@ func (s *DropBaselinePlanStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) DropBaselinePlanStatement() (localctx IDropBaselinePlanStatementContext) { +func (p *StarRocksSQLParser) DropBaselinePlanStatement() (localctx IDropBaselinePlanStatementContext) { localctx = NewDropBaselinePlanStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 422, DorisSQLParserRULE_dropBaselinePlanStatement) + p.EnterRule(localctx, 422, StarRocksSQLParserRULE_dropBaselinePlanStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(3998) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63367,7 +63367,7 @@ func (p *DorisSQLParser) DropBaselinePlanStatement() (localctx IDropBaselinePlan } { p.SetState(3999) - p.Match(DorisSQLParserBASELINE) + p.Match(StarRocksSQLParserBASELINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63375,7 +63375,7 @@ func (p *DorisSQLParser) DropBaselinePlanStatement() (localctx IDropBaselinePlan } { p.SetState(4000) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63388,10 +63388,10 @@ func (p *DorisSQLParser) DropBaselinePlanStatement() (localctx IDropBaselinePlan } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4001) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63399,7 +63399,7 @@ func (p *DorisSQLParser) DropBaselinePlanStatement() (localctx IDropBaselinePlan } { p.SetState(4002) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63450,13 +63450,13 @@ type ShowBaselinePlanStatementContext struct { func NewEmptyShowBaselinePlanStatementContext() *ShowBaselinePlanStatementContext { var p = new(ShowBaselinePlanStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_showBaselinePlanStatement return p } func InitEmptyShowBaselinePlanStatementContext(p *ShowBaselinePlanStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_showBaselinePlanStatement } func (*ShowBaselinePlanStatementContext) IsShowBaselinePlanStatementContext() {} @@ -63467,7 +63467,7 @@ func NewShowBaselinePlanStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showBaselinePlanStatement + p.RuleIndex = StarRocksSQLParserRULE_showBaselinePlanStatement return p } @@ -63475,11 +63475,11 @@ func NewShowBaselinePlanStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowBaselinePlanStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowBaselinePlanStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowBaselinePlanStatementContext) BASELINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBASELINE, 0) + return s.GetToken(StarRocksSQLParserBASELINE, 0) } func (s *ShowBaselinePlanStatementContext) GetRuleContext() antlr.RuleContext { @@ -63491,20 +63491,20 @@ func (s *ShowBaselinePlanStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowBaselinePlanStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowBaselinePlanStatement(s) } } func (s *ShowBaselinePlanStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowBaselinePlanStatement(s) } } func (s *ShowBaselinePlanStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowBaselinePlanStatement(s) default: @@ -63512,13 +63512,13 @@ func (s *ShowBaselinePlanStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowBaselinePlanStatement() (localctx IShowBaselinePlanStatementContext) { +func (p *StarRocksSQLParser) ShowBaselinePlanStatement() (localctx IShowBaselinePlanStatementContext) { localctx = NewShowBaselinePlanStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 424, DorisSQLParserRULE_showBaselinePlanStatement) + p.EnterRule(localctx, 424, StarRocksSQLParserRULE_showBaselinePlanStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4008) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63526,7 +63526,7 @@ func (p *DorisSQLParser) ShowBaselinePlanStatement() (localctx IShowBaselinePlan } { p.SetState(4009) - p.Match(DorisSQLParserBASELINE) + p.Match(StarRocksSQLParserBASELINE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63582,13 +63582,13 @@ type CreateResourceGroupStatementContext struct { func NewEmptyCreateResourceGroupStatementContext() *CreateResourceGroupStatementContext { var p = new(CreateResourceGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_createResourceGroupStatement return p } func InitEmptyCreateResourceGroupStatementContext(p *CreateResourceGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_createResourceGroupStatement } func (*CreateResourceGroupStatementContext) IsCreateResourceGroupStatementContext() {} @@ -63599,7 +63599,7 @@ func NewCreateResourceGroupStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_createResourceGroupStatement return p } @@ -63607,15 +63607,15 @@ func NewCreateResourceGroupStatementContext(parser antlr.Parser, parent antlr.Pa func (s *CreateResourceGroupStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateResourceGroupStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateResourceGroupStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *CreateResourceGroupStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *CreateResourceGroupStatementContext) Identifier() IIdentifierContext { @@ -63635,7 +63635,7 @@ func (s *CreateResourceGroupStatementContext) Identifier() IIdentifierContext { } func (s *CreateResourceGroupStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *CreateResourceGroupStatementContext) AllProperty() []IPropertyContext { @@ -63680,27 +63680,27 @@ func (s *CreateResourceGroupStatementContext) Property(i int) IPropertyContext { } func (s *CreateResourceGroupStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateResourceGroupStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateResourceGroupStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateResourceGroupStatementContext) OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOR, 0) + return s.GetToken(StarRocksSQLParserOR, 0) } func (s *CreateResourceGroupStatementContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *CreateResourceGroupStatementContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *CreateResourceGroupStatementContext) AllClassifier() []IClassifierContext { @@ -63753,20 +63753,20 @@ func (s *CreateResourceGroupStatementContext) ToStringTree(ruleNames []string, r } func (s *CreateResourceGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateResourceGroupStatement(s) } } func (s *CreateResourceGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateResourceGroupStatement(s) } } func (s *CreateResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateResourceGroupStatement(s) default: @@ -63774,15 +63774,15 @@ func (s *CreateResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourceGroupStatementContext) { +func (p *StarRocksSQLParser) CreateResourceGroupStatement() (localctx ICreateResourceGroupStatementContext) { localctx = NewCreateResourceGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 426, DorisSQLParserRULE_createResourceGroupStatement) + p.EnterRule(localctx, 426, StarRocksSQLParserRULE_createResourceGroupStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4011) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63790,7 +63790,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4012) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63798,7 +63798,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4013) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63811,10 +63811,10 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(4014) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63822,7 +63822,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4015) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63830,7 +63830,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4016) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63845,10 +63845,10 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserOR { + if _la == StarRocksSQLParserOR { { p.SetState(4019) - p.Match(DorisSQLParserOR) + p.Match(StarRocksSQLParserOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63856,7 +63856,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4020) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63875,10 +63875,10 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTO { + if _la == StarRocksSQLParserTO { { p.SetState(4024) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63895,10 +63895,10 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4026) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63920,7 +63920,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4035) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63928,7 +63928,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4036) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63945,10 +63945,10 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4038) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -63968,7 +63968,7 @@ func (p *DorisSQLParser) CreateResourceGroupStatement() (localctx ICreateResourc } { p.SetState(4045) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64013,13 +64013,13 @@ type DropResourceGroupStatementContext struct { func NewEmptyDropResourceGroupStatementContext() *DropResourceGroupStatementContext { var p = new(DropResourceGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_dropResourceGroupStatement return p } func InitEmptyDropResourceGroupStatementContext(p *DropResourceGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_dropResourceGroupStatement } func (*DropResourceGroupStatementContext) IsDropResourceGroupStatementContext() {} @@ -64030,7 +64030,7 @@ func NewDropResourceGroupStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_dropResourceGroupStatement return p } @@ -64038,15 +64038,15 @@ func NewDropResourceGroupStatementContext(parser antlr.Parser, parent antlr.Pars func (s *DropResourceGroupStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropResourceGroupStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropResourceGroupStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *DropResourceGroupStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *DropResourceGroupStatementContext) Identifier() IIdentifierContext { @@ -64074,20 +64074,20 @@ func (s *DropResourceGroupStatementContext) ToStringTree(ruleNames []string, rec } func (s *DropResourceGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropResourceGroupStatement(s) } } func (s *DropResourceGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropResourceGroupStatement(s) } } func (s *DropResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropResourceGroupStatement(s) default: @@ -64095,13 +64095,13 @@ func (s *DropResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) DropResourceGroupStatement() (localctx IDropResourceGroupStatementContext) { +func (p *StarRocksSQLParser) DropResourceGroupStatement() (localctx IDropResourceGroupStatementContext) { localctx = NewDropResourceGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 428, DorisSQLParserRULE_dropResourceGroupStatement) + p.EnterRule(localctx, 428, StarRocksSQLParserRULE_dropResourceGroupStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4047) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64109,7 +64109,7 @@ func (p *DorisSQLParser) DropResourceGroupStatement() (localctx IDropResourceGro } { p.SetState(4048) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64117,7 +64117,7 @@ func (p *DorisSQLParser) DropResourceGroupStatement() (localctx IDropResourceGro } { p.SetState(4049) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64176,13 +64176,13 @@ type AlterResourceGroupStatementContext struct { func NewEmptyAlterResourceGroupStatementContext() *AlterResourceGroupStatementContext { var p = new(AlterResourceGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_alterResourceGroupStatement return p } func InitEmptyAlterResourceGroupStatementContext(p *AlterResourceGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_alterResourceGroupStatement } func (*AlterResourceGroupStatementContext) IsAlterResourceGroupStatementContext() {} @@ -64193,7 +64193,7 @@ func NewAlterResourceGroupStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_alterResourceGroupStatement return p } @@ -64201,15 +64201,15 @@ func NewAlterResourceGroupStatementContext(parser antlr.Parser, parent antlr.Par func (s *AlterResourceGroupStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterResourceGroupStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterResourceGroupStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *AlterResourceGroupStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *AlterResourceGroupStatementContext) Identifier() IIdentifierContext { @@ -64229,7 +64229,7 @@ func (s *AlterResourceGroupStatementContext) Identifier() IIdentifierContext { } func (s *AlterResourceGroupStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AlterResourceGroupStatementContext) AllClassifier() []IClassifierContext { @@ -64274,23 +64274,23 @@ func (s *AlterResourceGroupStatementContext) Classifier(i int) IClassifierContex } func (s *AlterResourceGroupStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *AlterResourceGroupStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *AlterResourceGroupStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *AlterResourceGroupStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *AlterResourceGroupStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *AlterResourceGroupStatementContext) AllProperty() []IPropertyContext { @@ -64343,20 +64343,20 @@ func (s *AlterResourceGroupStatementContext) ToStringTree(ruleNames []string, re } func (s *AlterResourceGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterResourceGroupStatement(s) } } func (s *AlterResourceGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterResourceGroupStatement(s) } } func (s *AlterResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterResourceGroupStatement(s) default: @@ -64364,9 +64364,9 @@ func (s *AlterResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceGroupStatementContext) { +func (p *StarRocksSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceGroupStatementContext) { localctx = NewAlterResourceGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 430, DorisSQLParserRULE_alterResourceGroupStatement) + p.EnterRule(localctx, 430, StarRocksSQLParserRULE_alterResourceGroupStatement) var _la int p.SetState(4104) @@ -64380,7 +64380,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG p.EnterOuterAlt(localctx, 1) { p.SetState(4052) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64388,7 +64388,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4053) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64396,7 +64396,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4054) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64408,7 +64408,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4056) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64425,10 +64425,10 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4058) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64451,7 +64451,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG p.EnterOuterAlt(localctx, 2) { p.SetState(4065) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64459,7 +64459,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4066) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64467,7 +64467,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4067) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64479,7 +64479,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4069) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64487,7 +64487,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4070) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64495,7 +64495,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4071) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64508,10 +64508,10 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4072) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64519,7 +64519,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4073) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64535,7 +64535,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4079) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64546,7 +64546,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG p.EnterOuterAlt(localctx, 3) { p.SetState(4081) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64554,7 +64554,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4082) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64562,7 +64562,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4083) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64574,7 +64574,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4085) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64582,7 +64582,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4086) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64593,7 +64593,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG p.EnterOuterAlt(localctx, 4) { p.SetState(4088) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64601,7 +64601,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4089) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64609,7 +64609,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4090) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64621,7 +64621,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4092) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64629,7 +64629,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4093) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64646,10 +64646,10 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4095) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64669,7 +64669,7 @@ func (p *DorisSQLParser) AlterResourceGroupStatement() (localctx IAlterResourceG } { p.SetState(4102) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64721,13 +64721,13 @@ type ShowResourceGroupStatementContext struct { func NewEmptyShowResourceGroupStatementContext() *ShowResourceGroupStatementContext { var p = new(ShowResourceGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceGroupStatement return p } func InitEmptyShowResourceGroupStatementContext(p *ShowResourceGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceGroupStatement } func (*ShowResourceGroupStatementContext) IsShowResourceGroupStatementContext() {} @@ -64738,7 +64738,7 @@ func NewShowResourceGroupStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showResourceGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceGroupStatement return p } @@ -64746,15 +64746,15 @@ func NewShowResourceGroupStatementContext(parser antlr.Parser, parent antlr.Pars func (s *ShowResourceGroupStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowResourceGroupStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowResourceGroupStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *ShowResourceGroupStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *ShowResourceGroupStatementContext) Identifier() IIdentifierContext { @@ -64774,15 +64774,15 @@ func (s *ShowResourceGroupStatementContext) Identifier() IIdentifierContext { } func (s *ShowResourceGroupStatementContext) VERBOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERBOSE, 0) + return s.GetToken(StarRocksSQLParserVERBOSE, 0) } func (s *ShowResourceGroupStatementContext) GROUPS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPS, 0) + return s.GetToken(StarRocksSQLParserGROUPS, 0) } func (s *ShowResourceGroupStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ShowResourceGroupStatementContext) GetRuleContext() antlr.RuleContext { @@ -64794,20 +64794,20 @@ func (s *ShowResourceGroupStatementContext) ToStringTree(ruleNames []string, rec } func (s *ShowResourceGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowResourceGroupStatement(s) } } func (s *ShowResourceGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowResourceGroupStatement(s) } } func (s *ShowResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowResourceGroupStatement(s) default: @@ -64815,9 +64815,9 @@ func (s *ShowResourceGroupStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGroupStatementContext) { +func (p *StarRocksSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGroupStatementContext) { localctx = NewShowResourceGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 432, DorisSQLParserRULE_showResourceGroupStatement) + p.EnterRule(localctx, 432, StarRocksSQLParserRULE_showResourceGroupStatement) var _la int p.SetState(4122) @@ -64831,7 +64831,7 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro p.EnterOuterAlt(localctx, 1) { p.SetState(4106) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64844,10 +64844,10 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserVERBOSE { { p.SetState(4107) - p.Match(DorisSQLParserVERBOSE) + p.Match(StarRocksSQLParserVERBOSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64857,7 +64857,7 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } { p.SetState(4110) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64865,7 +64865,7 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } { p.SetState(4111) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64880,7 +64880,7 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro p.EnterOuterAlt(localctx, 2) { p.SetState(4113) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64893,10 +64893,10 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserVERBOSE { { p.SetState(4114) - p.Match(DorisSQLParserVERBOSE) + p.Match(StarRocksSQLParserVERBOSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64906,7 +64906,7 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } { p.SetState(4117) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64914,7 +64914,7 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } { p.SetState(4118) - p.Match(DorisSQLParserGROUPS) + p.Match(StarRocksSQLParserGROUPS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64927,10 +64927,10 @@ func (p *DorisSQLParser) ShowResourceGroupStatement() (localctx IShowResourceGro } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL { + if _la == StarRocksSQLParserALL { { p.SetState(4119) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -64983,13 +64983,13 @@ type ShowResourceGroupUsageStatementContext struct { func NewEmptyShowResourceGroupUsageStatementContext() *ShowResourceGroupUsageStatementContext { var p = new(ShowResourceGroupUsageStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showResourceGroupUsageStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceGroupUsageStatement return p } func InitEmptyShowResourceGroupUsageStatementContext(p *ShowResourceGroupUsageStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showResourceGroupUsageStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceGroupUsageStatement } func (*ShowResourceGroupUsageStatementContext) IsShowResourceGroupUsageStatementContext() {} @@ -65000,7 +65000,7 @@ func NewShowResourceGroupUsageStatementContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showResourceGroupUsageStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceGroupUsageStatement return p } @@ -65008,19 +65008,19 @@ func NewShowResourceGroupUsageStatementContext(parser antlr.Parser, parent antlr func (s *ShowResourceGroupUsageStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowResourceGroupUsageStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowResourceGroupUsageStatementContext) USAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSAGE, 0) + return s.GetToken(StarRocksSQLParserUSAGE, 0) } func (s *ShowResourceGroupUsageStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *ShowResourceGroupUsageStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *ShowResourceGroupUsageStatementContext) Identifier() IIdentifierContext { @@ -65040,7 +65040,7 @@ func (s *ShowResourceGroupUsageStatementContext) Identifier() IIdentifierContext } func (s *ShowResourceGroupUsageStatementContext) GROUPS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPS, 0) + return s.GetToken(StarRocksSQLParserGROUPS, 0) } func (s *ShowResourceGroupUsageStatementContext) GetRuleContext() antlr.RuleContext { @@ -65052,20 +65052,20 @@ func (s *ShowResourceGroupUsageStatementContext) ToStringTree(ruleNames []string } func (s *ShowResourceGroupUsageStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowResourceGroupUsageStatement(s) } } func (s *ShowResourceGroupUsageStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowResourceGroupUsageStatement(s) } } func (s *ShowResourceGroupUsageStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowResourceGroupUsageStatement(s) default: @@ -65073,9 +65073,9 @@ func (s *ShowResourceGroupUsageStatementContext) Accept(visitor antlr.ParseTreeV } } -func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResourceGroupUsageStatementContext) { +func (p *StarRocksSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResourceGroupUsageStatementContext) { localctx = NewShowResourceGroupUsageStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 434, DorisSQLParserRULE_showResourceGroupUsageStatement) + p.EnterRule(localctx, 434, StarRocksSQLParserRULE_showResourceGroupUsageStatement) p.SetState(4133) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -65087,7 +65087,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour p.EnterOuterAlt(localctx, 1) { p.SetState(4124) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65095,7 +65095,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour } { p.SetState(4125) - p.Match(DorisSQLParserUSAGE) + p.Match(StarRocksSQLParserUSAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65103,7 +65103,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour } { p.SetState(4126) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65111,7 +65111,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour } { p.SetState(4127) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65126,7 +65126,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour p.EnterOuterAlt(localctx, 2) { p.SetState(4129) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65134,7 +65134,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour } { p.SetState(4130) - p.Match(DorisSQLParserUSAGE) + p.Match(StarRocksSQLParserUSAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65142,7 +65142,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour } { p.SetState(4131) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65150,7 +65150,7 @@ func (p *DorisSQLParser) ShowResourceGroupUsageStatement() (localctx IShowResour } { p.SetState(4132) - p.Match(DorisSQLParserGROUPS) + p.Match(StarRocksSQLParserGROUPS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65207,13 +65207,13 @@ type CreateResourceStatementContext struct { func NewEmptyCreateResourceStatementContext() *CreateResourceStatementContext { var p = new(CreateResourceStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_createResourceStatement return p } func InitEmptyCreateResourceStatementContext(p *CreateResourceStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_createResourceStatement } func (*CreateResourceStatementContext) IsCreateResourceStatementContext() {} @@ -65224,7 +65224,7 @@ func NewCreateResourceStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_createResourceStatement return p } @@ -65240,11 +65240,11 @@ func (s *CreateResourceStatementContext) SetResourceName(v IIdentifierOrStringCo } func (s *CreateResourceStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateResourceStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *CreateResourceStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -65264,7 +65264,7 @@ func (s *CreateResourceStatementContext) IdentifierOrString() IIdentifierOrStrin } func (s *CreateResourceStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *CreateResourceStatementContext) Properties() IPropertiesContext { @@ -65292,20 +65292,20 @@ func (s *CreateResourceStatementContext) ToStringTree(ruleNames []string, recog } func (s *CreateResourceStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateResourceStatement(s) } } func (s *CreateResourceStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateResourceStatement(s) } } func (s *CreateResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateResourceStatement(s) default: @@ -65313,15 +65313,15 @@ func (s *CreateResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CreateResourceStatement() (localctx ICreateResourceStatementContext) { +func (p *StarRocksSQLParser) CreateResourceStatement() (localctx ICreateResourceStatementContext) { localctx = NewCreateResourceStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 436, DorisSQLParserRULE_createResourceStatement) + p.EnterRule(localctx, 436, StarRocksSQLParserRULE_createResourceStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4135) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65334,10 +65334,10 @@ func (p *DorisSQLParser) CreateResourceStatement() (localctx ICreateResourceStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEXTERNAL { + if _la == StarRocksSQLParserEXTERNAL { { p.SetState(4136) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65347,7 +65347,7 @@ func (p *DorisSQLParser) CreateResourceStatement() (localctx ICreateResourceStat } { p.SetState(4139) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65367,7 +65367,7 @@ func (p *DorisSQLParser) CreateResourceStatement() (localctx ICreateResourceStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(4141) p.Properties() @@ -65421,13 +65421,13 @@ type AlterResourceStatementContext struct { func NewEmptyAlterResourceStatementContext() *AlterResourceStatementContext { var p = new(AlterResourceStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_alterResourceStatement return p } func InitEmptyAlterResourceStatementContext(p *AlterResourceStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_alterResourceStatement } func (*AlterResourceStatementContext) IsAlterResourceStatementContext() {} @@ -65438,7 +65438,7 @@ func NewAlterResourceStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_alterResourceStatement return p } @@ -65454,15 +65454,15 @@ func (s *AlterResourceStatementContext) SetResourceName(v IIdentifierOrStringCon } func (s *AlterResourceStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterResourceStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *AlterResourceStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterResourceStatementContext) Properties() IPropertiesContext { @@ -65506,20 +65506,20 @@ func (s *AlterResourceStatementContext) ToStringTree(ruleNames []string, recog a } func (s *AlterResourceStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterResourceStatement(s) } } func (s *AlterResourceStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterResourceStatement(s) } } func (s *AlterResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterResourceStatement(s) default: @@ -65527,13 +65527,13 @@ func (s *AlterResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) AlterResourceStatement() (localctx IAlterResourceStatementContext) { +func (p *StarRocksSQLParser) AlterResourceStatement() (localctx IAlterResourceStatementContext) { localctx = NewAlterResourceStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 438, DorisSQLParserRULE_alterResourceStatement) + p.EnterRule(localctx, 438, StarRocksSQLParserRULE_alterResourceStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4144) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65541,7 +65541,7 @@ func (p *DorisSQLParser) AlterResourceStatement() (localctx IAlterResourceStatem } { p.SetState(4145) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65556,7 +65556,7 @@ func (p *DorisSQLParser) AlterResourceStatement() (localctx IAlterResourceStatem } { p.SetState(4147) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65611,13 +65611,13 @@ type DropResourceStatementContext struct { func NewEmptyDropResourceStatementContext() *DropResourceStatementContext { var p = new(DropResourceStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_dropResourceStatement return p } func InitEmptyDropResourceStatementContext(p *DropResourceStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_dropResourceStatement } func (*DropResourceStatementContext) IsDropResourceStatementContext() {} @@ -65628,7 +65628,7 @@ func NewDropResourceStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_dropResourceStatement return p } @@ -65644,11 +65644,11 @@ func (s *DropResourceStatementContext) SetResourceName(v IIdentifierOrStringCont } func (s *DropResourceStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropResourceStatementContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *DropResourceStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -65676,20 +65676,20 @@ func (s *DropResourceStatementContext) ToStringTree(ruleNames []string, recog an } func (s *DropResourceStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropResourceStatement(s) } } func (s *DropResourceStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropResourceStatement(s) } } func (s *DropResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropResourceStatement(s) default: @@ -65697,13 +65697,13 @@ func (s *DropResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) DropResourceStatement() (localctx IDropResourceStatementContext) { +func (p *StarRocksSQLParser) DropResourceStatement() (localctx IDropResourceStatementContext) { localctx = NewDropResourceStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 440, DorisSQLParserRULE_dropResourceStatement) + p.EnterRule(localctx, 440, StarRocksSQLParserRULE_dropResourceStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4150) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65711,7 +65711,7 @@ func (p *DorisSQLParser) DropResourceStatement() (localctx IDropResourceStatemen } { p.SetState(4151) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65761,13 +65761,13 @@ type ShowResourceStatementContext struct { func NewEmptyShowResourceStatementContext() *ShowResourceStatementContext { var p = new(ShowResourceStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceStatement return p } func InitEmptyShowResourceStatementContext(p *ShowResourceStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceStatement } func (*ShowResourceStatementContext) IsShowResourceStatementContext() {} @@ -65778,7 +65778,7 @@ func NewShowResourceStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showResourceStatement + p.RuleIndex = StarRocksSQLParserRULE_showResourceStatement return p } @@ -65786,11 +65786,11 @@ func NewShowResourceStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *ShowResourceStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowResourceStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowResourceStatementContext) RESOURCES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCES, 0) + return s.GetToken(StarRocksSQLParserRESOURCES, 0) } func (s *ShowResourceStatementContext) GetRuleContext() antlr.RuleContext { @@ -65802,20 +65802,20 @@ func (s *ShowResourceStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowResourceStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowResourceStatement(s) } } func (s *ShowResourceStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowResourceStatement(s) } } func (s *ShowResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowResourceStatement(s) default: @@ -65823,13 +65823,13 @@ func (s *ShowResourceStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowResourceStatement() (localctx IShowResourceStatementContext) { +func (p *StarRocksSQLParser) ShowResourceStatement() (localctx IShowResourceStatementContext) { localctx = NewShowResourceStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 442, DorisSQLParserRULE_showResourceStatement) + p.EnterRule(localctx, 442, StarRocksSQLParserRULE_showResourceStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4154) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65837,7 +65837,7 @@ func (p *DorisSQLParser) ShowResourceStatement() (localctx IShowResourceStatemen } { p.SetState(4155) - p.Match(DorisSQLParserRESOURCES) + p.Match(StarRocksSQLParserRESOURCES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65879,13 +65879,13 @@ type ClassifierContext struct { func NewEmptyClassifierContext() *ClassifierContext { var p = new(ClassifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_classifier + p.RuleIndex = StarRocksSQLParserRULE_classifier return p } func InitEmptyClassifierContext(p *ClassifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_classifier + p.RuleIndex = StarRocksSQLParserRULE_classifier } func (*ClassifierContext) IsClassifierContext() {} @@ -65896,7 +65896,7 @@ func NewClassifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_classifier + p.RuleIndex = StarRocksSQLParserRULE_classifier return p } @@ -65928,20 +65928,20 @@ func (s *ClassifierContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *ClassifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterClassifier(s) } } func (s *ClassifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitClassifier(s) } } func (s *ClassifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitClassifier(s) default: @@ -65949,13 +65949,13 @@ func (s *ClassifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Classifier() (localctx IClassifierContext) { +func (p *StarRocksSQLParser) Classifier() (localctx IClassifierContext) { localctx = NewClassifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 444, DorisSQLParserRULE_classifier) + p.EnterRule(localctx, 444, StarRocksSQLParserRULE_classifier) p.EnterOuterAlt(localctx, 1) { p.SetState(4157) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -65967,7 +65967,7 @@ func (p *DorisSQLParser) Classifier() (localctx IClassifierContext) { } { p.SetState(4159) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66034,13 +66034,13 @@ type ShowFunctionsStatementContext struct { func NewEmptyShowFunctionsStatementContext() *ShowFunctionsStatementContext { var p = new(ShowFunctionsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFunctionsStatement + p.RuleIndex = StarRocksSQLParserRULE_showFunctionsStatement return p } func InitEmptyShowFunctionsStatementContext(p *ShowFunctionsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFunctionsStatement + p.RuleIndex = StarRocksSQLParserRULE_showFunctionsStatement } func (*ShowFunctionsStatementContext) IsShowFunctionsStatementContext() {} @@ -66051,7 +66051,7 @@ func NewShowFunctionsStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showFunctionsStatement + p.RuleIndex = StarRocksSQLParserRULE_showFunctionsStatement return p } @@ -66067,31 +66067,31 @@ func (s *ShowFunctionsStatementContext) SetDb(v IQualifiedNameContext) { s.db = func (s *ShowFunctionsStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowFunctionsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowFunctionsStatementContext) FUNCTIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTIONS, 0) + return s.GetToken(StarRocksSQLParserFUNCTIONS, 0) } func (s *ShowFunctionsStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *ShowFunctionsStatementContext) BUILTIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBUILTIN, 0) + return s.GetToken(StarRocksSQLParserBUILTIN, 0) } func (s *ShowFunctionsStatementContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *ShowFunctionsStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowFunctionsStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowFunctionsStatementContext) QualifiedName() IQualifiedNameContext { @@ -66111,11 +66111,11 @@ func (s *ShowFunctionsStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowFunctionsStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowFunctionsStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowFunctionsStatementContext) Expression() IExpressionContext { @@ -66159,20 +66159,20 @@ func (s *ShowFunctionsStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowFunctionsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowFunctionsStatement(s) } } func (s *ShowFunctionsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowFunctionsStatement(s) } } func (s *ShowFunctionsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowFunctionsStatement(s) default: @@ -66180,15 +66180,15 @@ func (s *ShowFunctionsStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatementContext) { +func (p *StarRocksSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatementContext) { localctx = NewShowFunctionsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 446, DorisSQLParserRULE_showFunctionsStatement) + p.EnterRule(localctx, 446, StarRocksSQLParserRULE_showFunctionsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4161) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66201,10 +66201,10 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL { + if _la == StarRocksSQLParserFULL { { p.SetState(4162) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66219,12 +66219,12 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBUILTIN || _la == DorisSQLParserGLOBAL { + if _la == StarRocksSQLParserBUILTIN || _la == StarRocksSQLParserGLOBAL { { p.SetState(4165) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserBUILTIN || _la == DorisSQLParserGLOBAL) { + if !(_la == StarRocksSQLParserBUILTIN || _la == StarRocksSQLParserGLOBAL) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -66235,7 +66235,7 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem } { p.SetState(4168) - p.Match(DorisSQLParserFUNCTIONS) + p.Match(StarRocksSQLParserFUNCTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66248,12 +66248,12 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4169) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -66275,10 +66275,10 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4173) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66292,10 +66292,10 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem localctx.(*ShowFunctionsStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4175) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66306,7 +66306,7 @@ func (p *DorisSQLParser) ShowFunctionsStatement() (localctx IShowFunctionsStatem p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -66352,13 +66352,13 @@ type DropFunctionStatementContext struct { func NewEmptyDropFunctionStatementContext() *DropFunctionStatementContext { var p = new(DropFunctionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFunctionStatement + p.RuleIndex = StarRocksSQLParserRULE_dropFunctionStatement return p } func InitEmptyDropFunctionStatementContext(p *DropFunctionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFunctionStatement + p.RuleIndex = StarRocksSQLParserRULE_dropFunctionStatement } func (*DropFunctionStatementContext) IsDropFunctionStatementContext() {} @@ -66369,7 +66369,7 @@ func NewDropFunctionStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropFunctionStatement + p.RuleIndex = StarRocksSQLParserRULE_dropFunctionStatement return p } @@ -66377,11 +66377,11 @@ func NewDropFunctionStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *DropFunctionStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropFunctionStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropFunctionStatementContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *DropFunctionStatementContext) QualifiedName() IQualifiedNameContext { @@ -66417,15 +66417,15 @@ func (s *DropFunctionStatementContext) TypeList() ITypeListContext { } func (s *DropFunctionStatementContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *DropFunctionStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropFunctionStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropFunctionStatementContext) GetRuleContext() antlr.RuleContext { @@ -66437,20 +66437,20 @@ func (s *DropFunctionStatementContext) ToStringTree(ruleNames []string, recog an } func (s *DropFunctionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropFunctionStatement(s) } } func (s *DropFunctionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropFunctionStatement(s) } } func (s *DropFunctionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropFunctionStatement(s) default: @@ -66458,15 +66458,15 @@ func (s *DropFunctionStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatementContext) { +func (p *StarRocksSQLParser) DropFunctionStatement() (localctx IDropFunctionStatementContext) { localctx = NewDropFunctionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 448, DorisSQLParserRULE_dropFunctionStatement) + p.EnterRule(localctx, 448, StarRocksSQLParserRULE_dropFunctionStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4179) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66479,10 +66479,10 @@ func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL { + if _la == StarRocksSQLParserGLOBAL { { p.SetState(4180) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66492,7 +66492,7 @@ func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatemen } { p.SetState(4183) - p.Match(DorisSQLParserFUNCTION) + p.Match(StarRocksSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66505,10 +66505,10 @@ func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(4184) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66516,7 +66516,7 @@ func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatemen } { p.SetState(4185) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66530,7 +66530,7 @@ func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatemen } { p.SetState(4189) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66542,7 +66542,7 @@ func (p *DorisSQLParser) DropFunctionStatement() (localctx IDropFunctionStatemen } { p.SetState(4191) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66611,13 +66611,13 @@ type CreateFunctionStatementContext struct { func NewEmptyCreateFunctionStatementContext() *CreateFunctionStatementContext { var p = new(CreateFunctionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createFunctionStatement + p.RuleIndex = StarRocksSQLParserRULE_createFunctionStatement return p } func InitEmptyCreateFunctionStatementContext(p *CreateFunctionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createFunctionStatement + p.RuleIndex = StarRocksSQLParserRULE_createFunctionStatement } func (*CreateFunctionStatementContext) IsCreateFunctionStatementContext() {} @@ -66628,7 +66628,7 @@ func NewCreateFunctionStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createFunctionStatement + p.RuleIndex = StarRocksSQLParserRULE_createFunctionStatement return p } @@ -66644,7 +66644,7 @@ func (s *CreateFunctionStatementContext) GetReturnType() ITypeContext { return s func (s *CreateFunctionStatementContext) SetReturnType(v ITypeContext) { s.returnType = v } func (s *CreateFunctionStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateFunctionStatementContext) OrReplace() IOrReplaceContext { @@ -66664,7 +66664,7 @@ func (s *CreateFunctionStatementContext) OrReplace() IOrReplaceContext { } func (s *CreateFunctionStatementContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *CreateFunctionStatementContext) IfNotExists() IIfNotExistsContext { @@ -66716,7 +66716,7 @@ func (s *CreateFunctionStatementContext) TypeList() ITypeListContext { } func (s *CreateFunctionStatementContext) RETURNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETURNS, 0) + return s.GetToken(StarRocksSQLParserRETURNS, 0) } func (s *CreateFunctionStatementContext) Type_() ITypeContext { @@ -66736,7 +66736,7 @@ func (s *CreateFunctionStatementContext) Type_() ITypeContext { } func (s *CreateFunctionStatementContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *CreateFunctionStatementContext) Properties() IPropertiesContext { @@ -66788,11 +66788,11 @@ func (s *CreateFunctionStatementContext) InlineFunction() IInlineFunctionContext } func (s *CreateFunctionStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *CreateFunctionStatementContext) AGGREGATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAGGREGATE, 0) + return s.GetToken(StarRocksSQLParserAGGREGATE, 0) } func (s *CreateFunctionStatementContext) GetRuleContext() antlr.RuleContext { @@ -66804,20 +66804,20 @@ func (s *CreateFunctionStatementContext) ToStringTree(ruleNames []string, recog } func (s *CreateFunctionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateFunctionStatement(s) } } func (s *CreateFunctionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateFunctionStatement(s) } } func (s *CreateFunctionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateFunctionStatement(s) default: @@ -66825,15 +66825,15 @@ func (s *CreateFunctionStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStatementContext) { +func (p *StarRocksSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStatementContext) { localctx = NewCreateFunctionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 450, DorisSQLParserRULE_createFunctionStatement) + p.EnterRule(localctx, 450, StarRocksSQLParserRULE_createFunctionStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4193) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66850,10 +66850,10 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL { + if _la == StarRocksSQLParserGLOBAL { { p.SetState(4195) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66868,7 +66868,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAGGREGATE || _la == DorisSQLParserTABLE { + if _la == StarRocksSQLParserAGGREGATE || _la == StarRocksSQLParserTABLE { { p.SetState(4198) @@ -66878,7 +66878,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserAGGREGATE || _la == DorisSQLParserTABLE) { + if !(_la == StarRocksSQLParserAGGREGATE || _la == StarRocksSQLParserTABLE) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*CreateFunctionStatementContext).functionType = _ri @@ -66891,7 +66891,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } { p.SetState(4201) - p.Match(DorisSQLParserFUNCTION) + p.Match(StarRocksSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66907,7 +66907,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } { p.SetState(4204) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66919,7 +66919,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } { p.SetState(4206) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66927,7 +66927,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } { p.SetState(4207) - p.Match(DorisSQLParserRETURNS) + p.Match(StarRocksSQLParserRETURNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -66967,7 +66967,7 @@ func (p *DorisSQLParser) CreateFunctionStatement() (localctx ICreateFunctionStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(4213) p.InlineFunction() @@ -67011,13 +67011,13 @@ type InlineFunctionContext struct { func NewEmptyInlineFunctionContext() *InlineFunctionContext { var p = new(InlineFunctionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_inlineFunction + p.RuleIndex = StarRocksSQLParserRULE_inlineFunction return p } func InitEmptyInlineFunctionContext(p *InlineFunctionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_inlineFunction + p.RuleIndex = StarRocksSQLParserRULE_inlineFunction } func (*InlineFunctionContext) IsInlineFunctionContext() {} @@ -67028,7 +67028,7 @@ func NewInlineFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_inlineFunction + p.RuleIndex = StarRocksSQLParserRULE_inlineFunction return p } @@ -67036,11 +67036,11 @@ func NewInlineFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *InlineFunctionContext) GetParser() antlr.Parser { return s.parser } func (s *InlineFunctionContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *InlineFunctionContext) ATTACHMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserATTACHMENT, 0) + return s.GetToken(StarRocksSQLParserATTACHMENT, 0) } func (s *InlineFunctionContext) GetRuleContext() antlr.RuleContext { @@ -67052,20 +67052,20 @@ func (s *InlineFunctionContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *InlineFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInlineFunction(s) } } func (s *InlineFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInlineFunction(s) } } func (s *InlineFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInlineFunction(s) default: @@ -67073,13 +67073,13 @@ func (s *InlineFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) InlineFunction() (localctx IInlineFunctionContext) { +func (p *StarRocksSQLParser) InlineFunction() (localctx IInlineFunctionContext) { localctx = NewInlineFunctionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 452, DorisSQLParserRULE_inlineFunction) + p.EnterRule(localctx, 452, StarRocksSQLParserRULE_inlineFunction) p.EnterOuterAlt(localctx, 1) { p.SetState(4216) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67087,7 +67087,7 @@ func (p *DorisSQLParser) InlineFunction() (localctx IInlineFunctionContext) { } { p.SetState(4217) - p.Match(DorisSQLParserATTACHMENT) + p.Match(StarRocksSQLParserATTACHMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67131,13 +67131,13 @@ type TypeListContext struct { func NewEmptyTypeListContext() *TypeListContext { var p = new(TypeListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeList + p.RuleIndex = StarRocksSQLParserRULE_typeList return p } func InitEmptyTypeListContext(p *TypeListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeList + p.RuleIndex = StarRocksSQLParserRULE_typeList } func (*TypeListContext) IsTypeListContext() {} @@ -67148,7 +67148,7 @@ func NewTypeListContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_typeList + p.RuleIndex = StarRocksSQLParserRULE_typeList return p } @@ -67197,7 +67197,7 @@ func (s *TypeListContext) Type_(i int) ITypeContext { } func (s *TypeListContext) DOTDOTDOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOTDOTDOT, 0) + return s.GetToken(StarRocksSQLParserDOTDOTDOT, 0) } func (s *TypeListContext) GetRuleContext() antlr.RuleContext { @@ -67209,20 +67209,20 @@ func (s *TypeListContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *TypeListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTypeList(s) } } func (s *TypeListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTypeList(s) } } func (s *TypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTypeList(s) default: @@ -67230,9 +67230,9 @@ func (s *TypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TypeList() (localctx ITypeListContext) { +func (p *StarRocksSQLParser) TypeList() (localctx ITypeListContext) { localctx = NewTypeListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 454, DorisSQLParserRULE_typeList) + p.EnterRule(localctx, 454, StarRocksSQLParserRULE_typeList) var _la int var _alt int @@ -67245,7 +67245,7 @@ func (p *DorisSQLParser) TypeList() (localctx ITypeListContext) { } _la = p.GetTokenStream().LA(1) - if ((int64((_la-24)) & ^0x3f) == 0 && ((int64(1)<<(_la-24))&1099547017217) != 0) || ((int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&576460752336978915) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&4611690485199667201) != 0) || ((int64((_la-286)) & ^0x3f) == 0 && ((int64(1)<<(_la-286))&67108867) != 0) || ((int64((_la-401)) & ^0x3f) == 0 && ((int64(1)<<(_la-401))&36029080491024393) != 0) || _la == DorisSQLParserVARBINARY || _la == DorisSQLParserVARCHAR { + if ((int64((_la-24)) & ^0x3f) == 0 && ((int64(1)<<(_la-24))&1099547017217) != 0) || ((int64((_la-106)) & ^0x3f) == 0 && ((int64(1)<<(_la-106))&576460752336978915) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&4611690485199667201) != 0) || ((int64((_la-286)) & ^0x3f) == 0 && ((int64(1)<<(_la-286))&67108867) != 0) || ((int64((_la-401)) & ^0x3f) == 0 && ((int64(1)<<(_la-401))&36029080491024393) != 0) || _la == StarRocksSQLParserVARBINARY || _la == StarRocksSQLParserVARCHAR { { p.SetState(4219) p.Type_() @@ -67265,7 +67265,7 @@ func (p *DorisSQLParser) TypeList() (localctx ITypeListContext) { if _alt == 1 { { p.SetState(4222) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67294,10 +67294,10 @@ func (p *DorisSQLParser) TypeList() (localctx ITypeListContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__2 { + if _la == StarRocksSQLParserT__2 { { p.SetState(4229) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67305,7 +67305,7 @@ func (p *DorisSQLParser) TypeList() (localctx ITypeListContext) { } { p.SetState(4230) - p.Match(DorisSQLParserDOTDOTDOT) + p.Match(StarRocksSQLParserDOTDOTDOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67400,13 +67400,13 @@ type LoadStatementContext struct { func NewEmptyLoadStatementContext() *LoadStatementContext { var p = new(LoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_loadStatement + p.RuleIndex = StarRocksSQLParserRULE_loadStatement return p } func InitEmptyLoadStatementContext(p *LoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_loadStatement + p.RuleIndex = StarRocksSQLParserRULE_loadStatement } func (*LoadStatementContext) IsLoadStatementContext() {} @@ -67417,7 +67417,7 @@ func NewLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_loadStatement + p.RuleIndex = StarRocksSQLParserRULE_loadStatement return p } @@ -67449,11 +67449,11 @@ func (s *LoadStatementContext) SetProps(v IPropertyListContext) { s.props = v } func (s *LoadStatementContext) SetResource(v IResourceDescContext) { s.resource = v } func (s *LoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *LoadStatementContext) LABEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLABEL, 0) + return s.GetToken(StarRocksSQLParserLABEL, 0) } func (s *LoadStatementContext) LabelName() ILabelNameContext { @@ -67473,11 +67473,11 @@ func (s *LoadStatementContext) LabelName() ILabelNameContext { } func (s *LoadStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *LoadStatementContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *LoadStatementContext) DataDescList() IDataDescListContext { @@ -67569,20 +67569,20 @@ func (s *LoadStatementContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *LoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLoadStatement(s) } } func (s *LoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLoadStatement(s) } } func (s *LoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLoadStatement(s) default: @@ -67590,9 +67590,9 @@ func (s *LoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { +func (p *StarRocksSQLParser) LoadStatement() (localctx ILoadStatementContext) { localctx = NewLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 456, DorisSQLParserRULE_loadStatement) + p.EnterRule(localctx, 456, StarRocksSQLParserRULE_loadStatement) var _la int p.SetState(4261) @@ -67606,7 +67606,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(4233) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67614,7 +67614,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } { p.SetState(4234) - p.Match(DorisSQLParserLABEL) + p.Match(StarRocksSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67634,7 +67634,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4236) @@ -67651,7 +67651,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(4239) @@ -67668,10 +67668,10 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBY { + if _la == StarRocksSQLParserBY { { p.SetState(4242) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67693,10 +67693,10 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(4246) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67716,7 +67716,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(4250) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67724,7 +67724,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } { p.SetState(4251) - p.Match(DorisSQLParserLABEL) + p.Match(StarRocksSQLParserLABEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67744,7 +67744,7 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4253) @@ -67768,10 +67768,10 @@ func (p *DorisSQLParser) LoadStatement() (localctx ILoadStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(4257) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -67841,13 +67841,13 @@ type LabelNameContext struct { func NewEmptyLabelNameContext() *LabelNameContext { var p = new(LabelNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_labelName + p.RuleIndex = StarRocksSQLParserRULE_labelName return p } func InitEmptyLabelNameContext(p *LabelNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_labelName + p.RuleIndex = StarRocksSQLParserRULE_labelName } func (*LabelNameContext) IsLabelNameContext() {} @@ -67858,7 +67858,7 @@ func NewLabelNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_labelName + p.RuleIndex = StarRocksSQLParserRULE_labelName return p } @@ -67923,20 +67923,20 @@ func (s *LabelNameContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *LabelNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLabelName(s) } } func (s *LabelNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLabelName(s) } } func (s *LabelNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLabelName(s) default: @@ -67944,9 +67944,9 @@ func (s *LabelNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) LabelName() (localctx ILabelNameContext) { +func (p *StarRocksSQLParser) LabelName() (localctx ILabelNameContext) { localctx = NewLabelNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 458, DorisSQLParserRULE_labelName) + p.EnterRule(localctx, 458, StarRocksSQLParserRULE_labelName) p.EnterOuterAlt(localctx, 1) p.SetState(4266) p.GetErrorHandler().Sync(p) @@ -67961,7 +67961,7 @@ func (p *DorisSQLParser) LabelName() (localctx ILabelNameContext) { } { p.SetState(4264) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68015,13 +68015,13 @@ type DataDescListContext struct { func NewEmptyDataDescListContext() *DataDescListContext { var p = new(DataDescListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataDescList + p.RuleIndex = StarRocksSQLParserRULE_dataDescList return p } func InitEmptyDataDescListContext(p *DataDescListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataDescList + p.RuleIndex = StarRocksSQLParserRULE_dataDescList } func (*DataDescListContext) IsDataDescListContext() {} @@ -68032,7 +68032,7 @@ func NewDataDescListContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dataDescList + p.RuleIndex = StarRocksSQLParserRULE_dataDescList return p } @@ -68089,20 +68089,20 @@ func (s *DataDescListContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *DataDescListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDataDescList(s) } } func (s *DataDescListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDataDescList(s) } } func (s *DataDescListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDataDescList(s) default: @@ -68110,15 +68110,15 @@ func (s *DataDescListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) DataDescList() (localctx IDataDescListContext) { +func (p *StarRocksSQLParser) DataDescList() (localctx IDataDescListContext) { localctx = NewDataDescListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 460, DorisSQLParserRULE_dataDescList) + p.EnterRule(localctx, 460, StarRocksSQLParserRULE_dataDescList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4270) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68135,10 +68135,10 @@ func (p *DorisSQLParser) DataDescList() (localctx IDataDescListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4272) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68158,7 +68158,7 @@ func (p *DorisSQLParser) DataDescList() (localctx IDataDescListContext) { } { p.SetState(4279) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68313,13 +68313,13 @@ type DataDescContext struct { func NewEmptyDataDescContext() *DataDescContext { var p = new(DataDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataDesc + p.RuleIndex = StarRocksSQLParserRULE_dataDesc return p } func InitEmptyDataDescContext(p *DataDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataDesc + p.RuleIndex = StarRocksSQLParserRULE_dataDesc } func (*DataDescContext) IsDataDescContext() {} @@ -68330,7 +68330,7 @@ func NewDataDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dataDesc + p.RuleIndex = StarRocksSQLParserRULE_dataDesc return p } @@ -68386,23 +68386,23 @@ func (s *DataDescContext) SetWhere(v IExpressionContext) { s.where = v } func (s *DataDescContext) SetSrcTableName(v IIdentifierContext) { s.srcTableName = v } func (s *DataDescContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *DataDescContext) INFILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINFILE, 0) + return s.GetToken(StarRocksSQLParserINFILE, 0) } func (s *DataDescContext) INTO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTO, 0) + return s.GetToken(StarRocksSQLParserINTO, 0) } func (s *DataDescContext) AllTABLE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserTABLE) + return s.GetTokens(StarRocksSQLParserTABLE) } func (s *DataDescContext) TABLE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, i) + return s.GetToken(StarRocksSQLParserTABLE, i) } func (s *DataDescContext) StringList() IStringListContext { @@ -68463,55 +68463,55 @@ func (s *DataDescContext) Identifier(i int) IIdentifierContext { } func (s *DataDescContext) NEGATIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNEGATIVE, 0) + return s.GetToken(StarRocksSQLParserNEGATIVE, 0) } func (s *DataDescContext) AllCOLUMNS() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserCOLUMNS) + return s.GetTokens(StarRocksSQLParserCOLUMNS) } func (s *DataDescContext) COLUMNS(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, i) + return s.GetToken(StarRocksSQLParserCOLUMNS, i) } func (s *DataDescContext) AllTERMINATED() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserTERMINATED) + return s.GetTokens(StarRocksSQLParserTERMINATED) } func (s *DataDescContext) TERMINATED(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserTERMINATED, i) + return s.GetToken(StarRocksSQLParserTERMINATED, i) } func (s *DataDescContext) AllBY() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserBY) + return s.GetTokens(StarRocksSQLParserBY) } func (s *DataDescContext) BY(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, i) + return s.GetToken(StarRocksSQLParserBY, i) } func (s *DataDescContext) ROWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROWS, 0) + return s.GetToken(StarRocksSQLParserROWS, 0) } func (s *DataDescContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DataDescContext) PATH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPATH, 0) + return s.GetToken(StarRocksSQLParserPATH, 0) } func (s *DataDescContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *DataDescContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *DataDescContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *DataDescContext) PartitionNames() IPartitionNamesContext { @@ -68676,20 +68676,20 @@ func (s *DataDescContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *DataDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDataDesc(s) } } func (s *DataDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDataDesc(s) } } func (s *DataDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDataDesc(s) default: @@ -68697,9 +68697,9 @@ func (s *DataDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { +func (p *StarRocksSQLParser) DataDesc() (localctx IDataDescContext) { localctx = NewDataDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 462, DorisSQLParserRULE_dataDesc) + p.EnterRule(localctx, 462, StarRocksSQLParserRULE_dataDesc) var _la int p.SetState(4350) @@ -68713,7 +68713,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(4281) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68721,7 +68721,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4282) - p.Match(DorisSQLParserINFILE) + p.Match(StarRocksSQLParserINFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68741,10 +68741,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNEGATIVE { + if _la == StarRocksSQLParserNEGATIVE { { p.SetState(4284) - p.Match(DorisSQLParserNEGATIVE) + p.Match(StarRocksSQLParserNEGATIVE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68754,7 +68754,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4287) - p.Match(DorisSQLParserINTO) + p.Match(StarRocksSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68762,7 +68762,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4288) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68782,7 +68782,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(4290) @@ -68798,7 +68798,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 427, p.GetParserRuleContext()) == 1 { { p.SetState(4293) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68806,7 +68806,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4294) - p.Match(DorisSQLParserTERMINATED) + p.Match(StarRocksSQLParserTERMINATED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68814,7 +68814,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4295) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68838,10 +68838,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserROWS { + if _la == StarRocksSQLParserROWS { { p.SetState(4299) - p.Match(DorisSQLParserROWS) + p.Match(StarRocksSQLParserROWS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68849,7 +68849,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4300) - p.Match(DorisSQLParserTERMINATED) + p.Match(StarRocksSQLParserTERMINATED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68857,7 +68857,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4301) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68879,7 +68879,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORMAT { + if _la == StarRocksSQLParserFORMAT { { p.SetState(4305) @@ -68911,7 +68911,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4311) @@ -68928,10 +68928,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOLUMNS { + if _la == StarRocksSQLParserCOLUMNS { { p.SetState(4314) - p.Match(DorisSQLParserCOLUMNS) + p.Match(StarRocksSQLParserCOLUMNS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68939,7 +68939,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4315) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68947,7 +68947,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4316) - p.Match(DorisSQLParserPATH) + p.Match(StarRocksSQLParserPATH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68955,7 +68955,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4317) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -68977,10 +68977,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSET { + if _la == StarRocksSQLParserSET { { p.SetState(4321) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69002,10 +69002,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4325) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69025,7 +69025,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(4329) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69033,7 +69033,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4330) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69041,7 +69041,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4331) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69061,10 +69061,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNEGATIVE { + if _la == StarRocksSQLParserNEGATIVE { { p.SetState(4333) - p.Match(DorisSQLParserNEGATIVE) + p.Match(StarRocksSQLParserNEGATIVE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69074,7 +69074,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4336) - p.Match(DorisSQLParserINTO) + p.Match(StarRocksSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69082,7 +69082,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } { p.SetState(4337) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69102,7 +69102,7 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(4339) @@ -69119,10 +69119,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSET { + if _la == StarRocksSQLParserSET { { p.SetState(4342) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69144,10 +69144,10 @@ func (p *DorisSQLParser) DataDesc() (localctx IDataDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4346) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69225,13 +69225,13 @@ type FormatPropsContext struct { func NewEmptyFormatPropsContext() *FormatPropsContext { var p = new(FormatPropsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_formatProps + p.RuleIndex = StarRocksSQLParserRULE_formatProps return p } func InitEmptyFormatPropsContext(p *FormatPropsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_formatProps + p.RuleIndex = StarRocksSQLParserRULE_formatProps } func (*FormatPropsContext) IsFormatPropsContext() {} @@ -69242,7 +69242,7 @@ func NewFormatPropsContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_formatProps + p.RuleIndex = StarRocksSQLParserRULE_formatProps return p } @@ -69258,23 +69258,23 @@ func (s *FormatPropsContext) SetEncloseCharacter(v IStringContext) { s.encloseCh func (s *FormatPropsContext) SetEscapeCharacter(v IStringContext) { s.escapeCharacter = v } func (s *FormatPropsContext) SKIP_HEADER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSKIP_HEADER, 0) + return s.GetToken(StarRocksSQLParserSKIP_HEADER, 0) } func (s *FormatPropsContext) AllEQ() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserEQ) + return s.GetTokens(StarRocksSQLParserEQ) } func (s *FormatPropsContext) EQ(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, i) + return s.GetToken(StarRocksSQLParserEQ, i) } func (s *FormatPropsContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *FormatPropsContext) TRIM_SPACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRIM_SPACE, 0) + return s.GetToken(StarRocksSQLParserTRIM_SPACE, 0) } func (s *FormatPropsContext) BooleanValue() IBooleanValueContext { @@ -69294,11 +69294,11 @@ func (s *FormatPropsContext) BooleanValue() IBooleanValueContext { } func (s *FormatPropsContext) ENCLOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENCLOSE, 0) + return s.GetToken(StarRocksSQLParserENCLOSE, 0) } func (s *FormatPropsContext) ESCAPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserESCAPE, 0) + return s.GetToken(StarRocksSQLParserESCAPE, 0) } func (s *FormatPropsContext) AllString_() []IStringContext { @@ -69351,20 +69351,20 @@ func (s *FormatPropsContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *FormatPropsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterFormatProps(s) } } func (s *FormatPropsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitFormatProps(s) } } func (s *FormatPropsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitFormatProps(s) default: @@ -69372,15 +69372,15 @@ func (s *FormatPropsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { +func (p *StarRocksSQLParser) FormatProps() (localctx IFormatPropsContext) { localctx = NewFormatPropsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 464, DorisSQLParserRULE_formatProps) + p.EnterRule(localctx, 464, StarRocksSQLParserRULE_formatProps) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4352) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69393,10 +69393,10 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSKIP_HEADER { + if _la == StarRocksSQLParserSKIP_HEADER { { p.SetState(4353) - p.Match(DorisSQLParserSKIP_HEADER) + p.Match(StarRocksSQLParserSKIP_HEADER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69404,7 +69404,7 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } { p.SetState(4354) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69412,7 +69412,7 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } { p.SetState(4355) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69427,10 +69427,10 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTRIM_SPACE { + if _la == StarRocksSQLParserTRIM_SPACE { { p.SetState(4358) - p.Match(DorisSQLParserTRIM_SPACE) + p.Match(StarRocksSQLParserTRIM_SPACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69438,7 +69438,7 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } { p.SetState(4359) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69457,10 +69457,10 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserENCLOSE { + if _la == StarRocksSQLParserENCLOSE { { p.SetState(4363) - p.Match(DorisSQLParserENCLOSE) + p.Match(StarRocksSQLParserENCLOSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69468,7 +69468,7 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } { p.SetState(4364) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69490,10 +69490,10 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserESCAPE { + if _la == StarRocksSQLParserESCAPE { { p.SetState(4368) - p.Match(DorisSQLParserESCAPE) + p.Match(StarRocksSQLParserESCAPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69501,7 +69501,7 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } { p.SetState(4369) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69518,7 +69518,7 @@ func (p *DorisSQLParser) FormatProps() (localctx IFormatPropsContext) { } { p.SetState(4373) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69577,13 +69577,13 @@ type BrokerDescContext struct { func NewEmptyBrokerDescContext() *BrokerDescContext { var p = new(BrokerDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_brokerDesc + p.RuleIndex = StarRocksSQLParserRULE_brokerDesc return p } func InitEmptyBrokerDescContext(p *BrokerDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_brokerDesc + p.RuleIndex = StarRocksSQLParserRULE_brokerDesc } func (*BrokerDescContext) IsBrokerDescContext() {} @@ -69594,7 +69594,7 @@ func NewBrokerDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_brokerDesc + p.RuleIndex = StarRocksSQLParserRULE_brokerDesc return p } @@ -69610,11 +69610,11 @@ func (s *BrokerDescContext) SetProps(v IPropertyListContext) { s.props = v } func (s *BrokerDescContext) SetName(v IIdentifierOrStringContext) { s.name = v } func (s *BrokerDescContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *BrokerDescContext) BROKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBROKER, 0) + return s.GetToken(StarRocksSQLParserBROKER, 0) } func (s *BrokerDescContext) PropertyList() IPropertyListContext { @@ -69658,20 +69658,20 @@ func (s *BrokerDescContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *BrokerDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBrokerDesc(s) } } func (s *BrokerDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBrokerDesc(s) } } func (s *BrokerDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBrokerDesc(s) default: @@ -69679,9 +69679,9 @@ func (s *BrokerDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { +func (p *StarRocksSQLParser) BrokerDesc() (localctx IBrokerDescContext) { localctx = NewBrokerDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 466, DorisSQLParserRULE_brokerDesc) + p.EnterRule(localctx, 466, StarRocksSQLParserRULE_brokerDesc) var _la int p.SetState(4386) @@ -69695,7 +69695,7 @@ func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(4375) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69703,7 +69703,7 @@ func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { } { p.SetState(4376) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69716,7 +69716,7 @@ func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4377) @@ -69731,7 +69731,7 @@ func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(4380) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69739,7 +69739,7 @@ func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { } { p.SetState(4381) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69759,7 +69759,7 @@ func (p *DorisSQLParser) BrokerDesc() (localctx IBrokerDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4383) @@ -69826,13 +69826,13 @@ type ResourceDescContext struct { func NewEmptyResourceDescContext() *ResourceDescContext { var p = new(ResourceDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_resourceDesc + p.RuleIndex = StarRocksSQLParserRULE_resourceDesc return p } func InitEmptyResourceDescContext(p *ResourceDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_resourceDesc + p.RuleIndex = StarRocksSQLParserRULE_resourceDesc } func (*ResourceDescContext) IsResourceDescContext() {} @@ -69843,7 +69843,7 @@ func NewResourceDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_resourceDesc + p.RuleIndex = StarRocksSQLParserRULE_resourceDesc return p } @@ -69859,11 +69859,11 @@ func (s *ResourceDescContext) SetName(v IIdentifierOrStringContext) { s.name = v func (s *ResourceDescContext) SetProps(v IPropertyListContext) { s.props = v } func (s *ResourceDescContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *ResourceDescContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *ResourceDescContext) IdentifierOrString() IIdentifierOrStringContext { @@ -69907,20 +69907,20 @@ func (s *ResourceDescContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *ResourceDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterResourceDesc(s) } } func (s *ResourceDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitResourceDesc(s) } } func (s *ResourceDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitResourceDesc(s) default: @@ -69928,15 +69928,15 @@ func (s *ResourceDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) ResourceDesc() (localctx IResourceDescContext) { +func (p *StarRocksSQLParser) ResourceDesc() (localctx IResourceDescContext) { localctx = NewResourceDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 468, DorisSQLParserRULE_resourceDesc) + p.EnterRule(localctx, 468, StarRocksSQLParserRULE_resourceDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4388) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69944,7 +69944,7 @@ func (p *DorisSQLParser) ResourceDesc() (localctx IResourceDescContext) { } { p.SetState(4389) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -69964,7 +69964,7 @@ func (p *DorisSQLParser) ResourceDesc() (localctx IResourceDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4391) @@ -70021,13 +70021,13 @@ type ShowLoadStatementContext struct { func NewEmptyShowLoadStatementContext() *ShowLoadStatementContext { var p = new(ShowLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadStatement return p } func InitEmptyShowLoadStatementContext(p *ShowLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadStatement } func (*ShowLoadStatementContext) IsShowLoadStatementContext() {} @@ -70038,7 +70038,7 @@ func NewShowLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadStatement return p } @@ -70046,19 +70046,19 @@ func NewShowLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *ShowLoadStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowLoadStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowLoadStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ShowLoadStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowLoadStatementContext) Identifier() IIdentifierContext { @@ -70078,7 +70078,7 @@ func (s *ShowLoadStatementContext) Identifier() IIdentifierContext { } func (s *ShowLoadStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowLoadStatementContext) Expression() IExpressionContext { @@ -70098,11 +70098,11 @@ func (s *ShowLoadStatementContext) Expression() IExpressionContext { } func (s *ShowLoadStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowLoadStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowLoadStatementContext) AllSortItem() []ISortItemContext { @@ -70171,20 +70171,20 @@ func (s *ShowLoadStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *ShowLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowLoadStatement(s) } } func (s *ShowLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowLoadStatement(s) } } func (s *ShowLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowLoadStatement(s) default: @@ -70192,15 +70192,15 @@ func (s *ShowLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext) { +func (p *StarRocksSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext) { localctx = NewShowLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 470, DorisSQLParserRULE_showLoadStatement) + p.EnterRule(localctx, 470, StarRocksSQLParserRULE_showLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4394) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70208,7 +70208,7 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } { p.SetState(4395) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70221,10 +70221,10 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL { + if _la == StarRocksSQLParserALL { { p.SetState(4396) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70239,10 +70239,10 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(4399) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70261,10 +70261,10 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4403) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70283,10 +70283,10 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(4407) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70294,7 +70294,7 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } { p.SetState(4408) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70311,10 +70311,10 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4410) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70341,7 +70341,7 @@ func (p *DorisSQLParser) ShowLoadStatement() (localctx IShowLoadStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(4419) p.LimitElement() @@ -70393,13 +70393,13 @@ type ShowLoadWarningsStatementContext struct { func NewEmptyShowLoadWarningsStatementContext() *ShowLoadWarningsStatementContext { var p = new(ShowLoadWarningsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLoadWarningsStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadWarningsStatement return p } func InitEmptyShowLoadWarningsStatementContext(p *ShowLoadWarningsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLoadWarningsStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadWarningsStatement } func (*ShowLoadWarningsStatementContext) IsShowLoadWarningsStatementContext() {} @@ -70410,7 +70410,7 @@ func NewShowLoadWarningsStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showLoadWarningsStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadWarningsStatement return p } @@ -70418,19 +70418,19 @@ func NewShowLoadWarningsStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowLoadWarningsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowLoadWarningsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowLoadWarningsStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowLoadWarningsStatementContext) WARNINGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWARNINGS, 0) + return s.GetToken(StarRocksSQLParserWARNINGS, 0) } func (s *ShowLoadWarningsStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowLoadWarningsStatementContext) Identifier() IIdentifierContext { @@ -70450,7 +70450,7 @@ func (s *ShowLoadWarningsStatementContext) Identifier() IIdentifierContext { } func (s *ShowLoadWarningsStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowLoadWarningsStatementContext) Expression() IExpressionContext { @@ -70486,7 +70486,7 @@ func (s *ShowLoadWarningsStatementContext) LimitElement() ILimitElementContext { } func (s *ShowLoadWarningsStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *ShowLoadWarningsStatementContext) String_() IStringContext { @@ -70514,20 +70514,20 @@ func (s *ShowLoadWarningsStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowLoadWarningsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowLoadWarningsStatement(s) } } func (s *ShowLoadWarningsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowLoadWarningsStatement(s) } } func (s *ShowLoadWarningsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowLoadWarningsStatement(s) default: @@ -70535,9 +70535,9 @@ func (s *ShowLoadWarningsStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarningsStatementContext) { +func (p *StarRocksSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarningsStatementContext) { localctx = NewShowLoadWarningsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 472, DorisSQLParserRULE_showLoadWarningsStatement) + p.EnterRule(localctx, 472, StarRocksSQLParserRULE_showLoadWarningsStatement) var _la int p.SetState(4441) @@ -70551,7 +70551,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings p.EnterOuterAlt(localctx, 1) { p.SetState(4422) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70559,7 +70559,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } { p.SetState(4423) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70567,7 +70567,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } { p.SetState(4424) - p.Match(DorisSQLParserWARNINGS) + p.Match(StarRocksSQLParserWARNINGS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70580,10 +70580,10 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(4425) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70602,10 +70602,10 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4429) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70624,7 +70624,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(4433) p.LimitElement() @@ -70636,7 +70636,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings p.EnterOuterAlt(localctx, 2) { p.SetState(4436) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70644,7 +70644,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } { p.SetState(4437) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70652,7 +70652,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } { p.SetState(4438) - p.Match(DorisSQLParserWARNINGS) + p.Match(StarRocksSQLParserWARNINGS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70660,7 +70660,7 @@ func (p *DorisSQLParser) ShowLoadWarningsStatement() (localctx IShowLoadWarnings } { p.SetState(4439) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70715,13 +70715,13 @@ type CancelLoadStatementContext struct { func NewEmptyCancelLoadStatementContext() *CancelLoadStatementContext { var p = new(CancelLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelLoadStatement return p } func InitEmptyCancelLoadStatementContext(p *CancelLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelLoadStatement } func (*CancelLoadStatementContext) IsCancelLoadStatementContext() {} @@ -70732,7 +70732,7 @@ func NewCancelLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelLoadStatement return p } @@ -70740,15 +70740,15 @@ func NewCancelLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *CancelLoadStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelLoadStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *CancelLoadStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CancelLoadStatementContext) Identifier() IIdentifierContext { @@ -70768,7 +70768,7 @@ func (s *CancelLoadStatementContext) Identifier() IIdentifierContext { } func (s *CancelLoadStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *CancelLoadStatementContext) Expression() IExpressionContext { @@ -70796,20 +70796,20 @@ func (s *CancelLoadStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *CancelLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelLoadStatement(s) } } func (s *CancelLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelLoadStatement(s) } } func (s *CancelLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelLoadStatement(s) default: @@ -70817,15 +70817,15 @@ func (s *CancelLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) CancelLoadStatement() (localctx ICancelLoadStatementContext) { +func (p *StarRocksSQLParser) CancelLoadStatement() (localctx ICancelLoadStatementContext) { localctx = NewCancelLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 474, DorisSQLParserRULE_cancelLoadStatement) + p.EnterRule(localctx, 474, StarRocksSQLParserRULE_cancelLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4443) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70833,7 +70833,7 @@ func (p *DorisSQLParser) CancelLoadStatement() (localctx ICancelLoadStatementCon } { p.SetState(4444) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70846,10 +70846,10 @@ func (p *DorisSQLParser) CancelLoadStatement() (localctx ICancelLoadStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(4445) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70868,10 +70868,10 @@ func (p *DorisSQLParser) CancelLoadStatement() (localctx ICancelLoadStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4449) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -70938,13 +70938,13 @@ type AlterLoadStatementContext struct { func NewEmptyAlterLoadStatementContext() *AlterLoadStatementContext { var p = new(AlterLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_alterLoadStatement return p } func InitEmptyAlterLoadStatementContext(p *AlterLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_alterLoadStatement } func (*AlterLoadStatementContext) IsAlterLoadStatementContext() {} @@ -70955,7 +70955,7 @@ func NewAlterLoadStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_alterLoadStatement return p } @@ -70971,15 +70971,15 @@ func (s *AlterLoadStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *AlterLoadStatementContext) SetName(v IIdentifierContext) { s.name = v } func (s *AlterLoadStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *AlterLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *AlterLoadStatementContext) Identifier() IIdentifierContext { @@ -71039,20 +71039,20 @@ func (s *AlterLoadStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *AlterLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterLoadStatement(s) } } func (s *AlterLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterLoadStatement(s) } } func (s *AlterLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterLoadStatement(s) default: @@ -71060,15 +71060,15 @@ func (s *AlterLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) AlterLoadStatement() (localctx IAlterLoadStatementContext) { +func (p *StarRocksSQLParser) AlterLoadStatement() (localctx IAlterLoadStatementContext) { localctx = NewAlterLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 476, DorisSQLParserRULE_alterLoadStatement) + p.EnterRule(localctx, 476, StarRocksSQLParserRULE_alterLoadStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4453) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71076,7 +71076,7 @@ func (p *DorisSQLParser) AlterLoadStatement() (localctx IAlterLoadStatementConte } { p.SetState(4454) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71084,7 +71084,7 @@ func (p *DorisSQLParser) AlterLoadStatement() (localctx IAlterLoadStatementConte } { p.SetState(4455) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71103,7 +71103,7 @@ func (p *DorisSQLParser) AlterLoadStatement() (localctx IAlterLoadStatementConte } { p.SetState(4457) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71127,7 +71127,7 @@ func (p *DorisSQLParser) AlterLoadStatement() (localctx IAlterLoadStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(4462) p.JobProperties() @@ -71173,13 +71173,13 @@ type CancelCompactionStatementContext struct { func NewEmptyCancelCompactionStatementContext() *CancelCompactionStatementContext { var p = new(CancelCompactionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelCompactionStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelCompactionStatement return p } func InitEmptyCancelCompactionStatementContext(p *CancelCompactionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelCompactionStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelCompactionStatement } func (*CancelCompactionStatementContext) IsCancelCompactionStatementContext() {} @@ -71190,7 +71190,7 @@ func NewCancelCompactionStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelCompactionStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelCompactionStatement return p } @@ -71198,15 +71198,15 @@ func NewCancelCompactionStatementContext(parser antlr.Parser, parent antlr.Parse func (s *CancelCompactionStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelCompactionStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelCompactionStatementContext) COMPACTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPACTION, 0) + return s.GetToken(StarRocksSQLParserCOMPACTION, 0) } func (s *CancelCompactionStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *CancelCompactionStatementContext) Expression() IExpressionContext { @@ -71234,20 +71234,20 @@ func (s *CancelCompactionStatementContext) ToStringTree(ruleNames []string, reco } func (s *CancelCompactionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelCompactionStatement(s) } } func (s *CancelCompactionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelCompactionStatement(s) } } func (s *CancelCompactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelCompactionStatement(s) default: @@ -71255,13 +71255,13 @@ func (s *CancelCompactionStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) CancelCompactionStatement() (localctx ICancelCompactionStatementContext) { +func (p *StarRocksSQLParser) CancelCompactionStatement() (localctx ICancelCompactionStatementContext) { localctx = NewCancelCompactionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 478, DorisSQLParserRULE_cancelCompactionStatement) + p.EnterRule(localctx, 478, StarRocksSQLParserRULE_cancelCompactionStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4465) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71269,7 +71269,7 @@ func (p *DorisSQLParser) CancelCompactionStatement() (localctx ICancelCompaction } { p.SetState(4466) - p.Match(DorisSQLParserCOMPACTION) + p.Match(StarRocksSQLParserCOMPACTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71277,7 +71277,7 @@ func (p *DorisSQLParser) CancelCompactionStatement() (localctx ICancelCompaction } { p.SetState(4467) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71324,13 +71324,13 @@ type ShowAuthorStatementContext struct { func NewEmptyShowAuthorStatementContext() *ShowAuthorStatementContext { var p = new(ShowAuthorStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAuthorStatement + p.RuleIndex = StarRocksSQLParserRULE_showAuthorStatement return p } func InitEmptyShowAuthorStatementContext(p *ShowAuthorStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAuthorStatement + p.RuleIndex = StarRocksSQLParserRULE_showAuthorStatement } func (*ShowAuthorStatementContext) IsShowAuthorStatementContext() {} @@ -71341,7 +71341,7 @@ func NewShowAuthorStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showAuthorStatement + p.RuleIndex = StarRocksSQLParserRULE_showAuthorStatement return p } @@ -71349,11 +71349,11 @@ func NewShowAuthorStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ShowAuthorStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowAuthorStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowAuthorStatementContext) AUTHORS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTHORS, 0) + return s.GetToken(StarRocksSQLParserAUTHORS, 0) } func (s *ShowAuthorStatementContext) GetRuleContext() antlr.RuleContext { @@ -71365,20 +71365,20 @@ func (s *ShowAuthorStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowAuthorStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowAuthorStatement(s) } } func (s *ShowAuthorStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowAuthorStatement(s) } } func (s *ShowAuthorStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowAuthorStatement(s) default: @@ -71386,13 +71386,13 @@ func (s *ShowAuthorStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowAuthorStatement() (localctx IShowAuthorStatementContext) { +func (p *StarRocksSQLParser) ShowAuthorStatement() (localctx IShowAuthorStatementContext) { localctx = NewShowAuthorStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 480, DorisSQLParserRULE_showAuthorStatement) + p.EnterRule(localctx, 480, StarRocksSQLParserRULE_showAuthorStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4470) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71400,7 +71400,7 @@ func (p *DorisSQLParser) ShowAuthorStatement() (localctx IShowAuthorStatementCon } { p.SetState(4471) - p.Match(DorisSQLParserAUTHORS) + p.Match(StarRocksSQLParserAUTHORS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71443,13 +71443,13 @@ type ShowBackendsStatementContext struct { func NewEmptyShowBackendsStatementContext() *ShowBackendsStatementContext { var p = new(ShowBackendsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBackendsStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackendsStatement return p } func InitEmptyShowBackendsStatementContext(p *ShowBackendsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBackendsStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackendsStatement } func (*ShowBackendsStatementContext) IsShowBackendsStatementContext() {} @@ -71460,7 +71460,7 @@ func NewShowBackendsStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showBackendsStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackendsStatement return p } @@ -71468,11 +71468,11 @@ func NewShowBackendsStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *ShowBackendsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowBackendsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowBackendsStatementContext) BACKENDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKENDS, 0) + return s.GetToken(StarRocksSQLParserBACKENDS, 0) } func (s *ShowBackendsStatementContext) GetRuleContext() antlr.RuleContext { @@ -71484,20 +71484,20 @@ func (s *ShowBackendsStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowBackendsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowBackendsStatement(s) } } func (s *ShowBackendsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowBackendsStatement(s) } } func (s *ShowBackendsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowBackendsStatement(s) default: @@ -71505,13 +71505,13 @@ func (s *ShowBackendsStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowBackendsStatement() (localctx IShowBackendsStatementContext) { +func (p *StarRocksSQLParser) ShowBackendsStatement() (localctx IShowBackendsStatementContext) { localctx = NewShowBackendsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 482, DorisSQLParserRULE_showBackendsStatement) + p.EnterRule(localctx, 482, StarRocksSQLParserRULE_showBackendsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4473) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71519,7 +71519,7 @@ func (p *DorisSQLParser) ShowBackendsStatement() (localctx IShowBackendsStatemen } { p.SetState(4474) - p.Match(DorisSQLParserBACKENDS) + p.Match(StarRocksSQLParserBACKENDS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71562,13 +71562,13 @@ type ShowBrokerStatementContext struct { func NewEmptyShowBrokerStatementContext() *ShowBrokerStatementContext { var p = new(ShowBrokerStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBrokerStatement + p.RuleIndex = StarRocksSQLParserRULE_showBrokerStatement return p } func InitEmptyShowBrokerStatementContext(p *ShowBrokerStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBrokerStatement + p.RuleIndex = StarRocksSQLParserRULE_showBrokerStatement } func (*ShowBrokerStatementContext) IsShowBrokerStatementContext() {} @@ -71579,7 +71579,7 @@ func NewShowBrokerStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showBrokerStatement + p.RuleIndex = StarRocksSQLParserRULE_showBrokerStatement return p } @@ -71587,11 +71587,11 @@ func NewShowBrokerStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ShowBrokerStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowBrokerStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowBrokerStatementContext) BROKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBROKER, 0) + return s.GetToken(StarRocksSQLParserBROKER, 0) } func (s *ShowBrokerStatementContext) GetRuleContext() antlr.RuleContext { @@ -71603,20 +71603,20 @@ func (s *ShowBrokerStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowBrokerStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowBrokerStatement(s) } } func (s *ShowBrokerStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowBrokerStatement(s) } } func (s *ShowBrokerStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowBrokerStatement(s) default: @@ -71624,13 +71624,13 @@ func (s *ShowBrokerStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowBrokerStatement() (localctx IShowBrokerStatementContext) { +func (p *StarRocksSQLParser) ShowBrokerStatement() (localctx IShowBrokerStatementContext) { localctx = NewShowBrokerStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 484, DorisSQLParserRULE_showBrokerStatement) + p.EnterRule(localctx, 484, StarRocksSQLParserRULE_showBrokerStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4476) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71638,7 +71638,7 @@ func (p *DorisSQLParser) ShowBrokerStatement() (localctx IShowBrokerStatementCon } { p.SetState(4477) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71695,13 +71695,13 @@ type ShowCharsetStatementContext struct { func NewEmptyShowCharsetStatementContext() *ShowCharsetStatementContext { var p = new(ShowCharsetStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCharsetStatement + p.RuleIndex = StarRocksSQLParserRULE_showCharsetStatement return p } func InitEmptyShowCharsetStatementContext(p *ShowCharsetStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCharsetStatement + p.RuleIndex = StarRocksSQLParserRULE_showCharsetStatement } func (*ShowCharsetStatementContext) IsShowCharsetStatementContext() {} @@ -71712,7 +71712,7 @@ func NewShowCharsetStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCharsetStatement + p.RuleIndex = StarRocksSQLParserRULE_showCharsetStatement return p } @@ -71724,31 +71724,31 @@ func (s *ShowCharsetStatementContext) GetPattern() IStringContext { return s.pat func (s *ShowCharsetStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowCharsetStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCharsetStatementContext) CHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAR, 0) + return s.GetToken(StarRocksSQLParserCHAR, 0) } func (s *ShowCharsetStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *ShowCharsetStatementContext) CHARSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARSET, 0) + return s.GetToken(StarRocksSQLParserCHARSET, 0) } func (s *ShowCharsetStatementContext) CHARACTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARACTER, 0) + return s.GetToken(StarRocksSQLParserCHARACTER, 0) } func (s *ShowCharsetStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowCharsetStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowCharsetStatementContext) Expression() IExpressionContext { @@ -71792,20 +71792,20 @@ func (s *ShowCharsetStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowCharsetStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCharsetStatement(s) } } func (s *ShowCharsetStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCharsetStatement(s) } } func (s *ShowCharsetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCharsetStatement(s) default: @@ -71813,13 +71813,13 @@ func (s *ShowCharsetStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementContext) { +func (p *StarRocksSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementContext) { localctx = NewShowCharsetStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 486, DorisSQLParserRULE_showCharsetStatement) + p.EnterRule(localctx, 486, StarRocksSQLParserRULE_showCharsetStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4479) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71832,10 +71832,10 @@ func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCHAR: + case StarRocksSQLParserCHAR: { p.SetState(4480) - p.Match(DorisSQLParserCHAR) + p.Match(StarRocksSQLParserCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71843,27 +71843,27 @@ func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementC } { p.SetState(4481) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCHARSET: + case StarRocksSQLParserCHARSET: { p.SetState(4482) - p.Match(DorisSQLParserCHARSET) + p.Match(StarRocksSQLParserCHARSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCHARACTER: + case StarRocksSQLParserCHARACTER: { p.SetState(4483) - p.Match(DorisSQLParserCHARACTER) + p.Match(StarRocksSQLParserCHARACTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71871,7 +71871,7 @@ func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementC } { p.SetState(4484) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71888,10 +71888,10 @@ func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementC goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4487) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71905,10 +71905,10 @@ func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementC localctx.(*ShowCharsetStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4489) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -71919,7 +71919,7 @@ func (p *DorisSQLParser) ShowCharsetStatement() (localctx IShowCharsetStatementC p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -71971,13 +71971,13 @@ type ShowCollationStatementContext struct { func NewEmptyShowCollationStatementContext() *ShowCollationStatementContext { var p = new(ShowCollationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCollationStatement + p.RuleIndex = StarRocksSQLParserRULE_showCollationStatement return p } func InitEmptyShowCollationStatementContext(p *ShowCollationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCollationStatement + p.RuleIndex = StarRocksSQLParserRULE_showCollationStatement } func (*ShowCollationStatementContext) IsShowCollationStatementContext() {} @@ -71988,7 +71988,7 @@ func NewShowCollationStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCollationStatement + p.RuleIndex = StarRocksSQLParserRULE_showCollationStatement return p } @@ -72000,19 +72000,19 @@ func (s *ShowCollationStatementContext) GetPattern() IStringContext { return s.p func (s *ShowCollationStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowCollationStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCollationStatementContext) COLLATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLLATION, 0) + return s.GetToken(StarRocksSQLParserCOLLATION, 0) } func (s *ShowCollationStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowCollationStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowCollationStatementContext) Expression() IExpressionContext { @@ -72056,20 +72056,20 @@ func (s *ShowCollationStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowCollationStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCollationStatement(s) } } func (s *ShowCollationStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCollationStatement(s) } } func (s *ShowCollationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCollationStatement(s) default: @@ -72077,13 +72077,13 @@ func (s *ShowCollationStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowCollationStatement() (localctx IShowCollationStatementContext) { +func (p *StarRocksSQLParser) ShowCollationStatement() (localctx IShowCollationStatementContext) { localctx = NewShowCollationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 488, DorisSQLParserRULE_showCollationStatement) + p.EnterRule(localctx, 488, StarRocksSQLParserRULE_showCollationStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4493) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72091,7 +72091,7 @@ func (p *DorisSQLParser) ShowCollationStatement() (localctx IShowCollationStatem } { p.SetState(4494) - p.Match(DorisSQLParserCOLLATION) + p.Match(StarRocksSQLParserCOLLATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72103,10 +72103,10 @@ func (p *DorisSQLParser) ShowCollationStatement() (localctx IShowCollationStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4495) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72120,10 +72120,10 @@ func (p *DorisSQLParser) ShowCollationStatement() (localctx IShowCollationStatem localctx.(*ShowCollationStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4497) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72134,7 +72134,7 @@ func (p *DorisSQLParser) ShowCollationStatement() (localctx IShowCollationStatem p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -72185,13 +72185,13 @@ type ShowDeleteStatementContext struct { func NewEmptyShowDeleteStatementContext() *ShowDeleteStatementContext { var p = new(ShowDeleteStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDeleteStatement + p.RuleIndex = StarRocksSQLParserRULE_showDeleteStatement return p } func InitEmptyShowDeleteStatementContext(p *ShowDeleteStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDeleteStatement + p.RuleIndex = StarRocksSQLParserRULE_showDeleteStatement } func (*ShowDeleteStatementContext) IsShowDeleteStatementContext() {} @@ -72202,7 +72202,7 @@ func NewShowDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDeleteStatement + p.RuleIndex = StarRocksSQLParserRULE_showDeleteStatement return p } @@ -72214,19 +72214,19 @@ func (s *ShowDeleteStatementContext) GetDb() IQualifiedNameContext { return s.db func (s *ShowDeleteStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowDeleteStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDeleteStatementContext) DELETE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDELETE, 0) + return s.GetToken(StarRocksSQLParserDELETE, 0) } func (s *ShowDeleteStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowDeleteStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowDeleteStatementContext) QualifiedName() IQualifiedNameContext { @@ -72254,20 +72254,20 @@ func (s *ShowDeleteStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowDeleteStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDeleteStatement(s) } } func (s *ShowDeleteStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDeleteStatement(s) } } func (s *ShowDeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDeleteStatement(s) default: @@ -72275,15 +72275,15 @@ func (s *ShowDeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowDeleteStatement() (localctx IShowDeleteStatementContext) { +func (p *StarRocksSQLParser) ShowDeleteStatement() (localctx IShowDeleteStatementContext) { localctx = NewShowDeleteStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 490, DorisSQLParserRULE_showDeleteStatement) + p.EnterRule(localctx, 490, StarRocksSQLParserRULE_showDeleteStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4501) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72291,7 +72291,7 @@ func (p *DorisSQLParser) ShowDeleteStatement() (localctx IShowDeleteStatementCon } { p.SetState(4502) - p.Match(DorisSQLParserDELETE) + p.Match(StarRocksSQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72304,12 +72304,12 @@ func (p *DorisSQLParser) ShowDeleteStatement() (localctx IShowDeleteStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4503) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -72374,13 +72374,13 @@ type ShowDynamicPartitionStatementContext struct { func NewEmptyShowDynamicPartitionStatementContext() *ShowDynamicPartitionStatementContext { var p = new(ShowDynamicPartitionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDynamicPartitionStatement + p.RuleIndex = StarRocksSQLParserRULE_showDynamicPartitionStatement return p } func InitEmptyShowDynamicPartitionStatementContext(p *ShowDynamicPartitionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDynamicPartitionStatement + p.RuleIndex = StarRocksSQLParserRULE_showDynamicPartitionStatement } func (*ShowDynamicPartitionStatementContext) IsShowDynamicPartitionStatementContext() {} @@ -72391,7 +72391,7 @@ func NewShowDynamicPartitionStatementContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDynamicPartitionStatement + p.RuleIndex = StarRocksSQLParserRULE_showDynamicPartitionStatement return p } @@ -72403,27 +72403,27 @@ func (s *ShowDynamicPartitionStatementContext) GetDb() IQualifiedNameContext { r func (s *ShowDynamicPartitionStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowDynamicPartitionStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDynamicPartitionStatementContext) DYNAMIC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDYNAMIC, 0) + return s.GetToken(StarRocksSQLParserDYNAMIC, 0) } func (s *ShowDynamicPartitionStatementContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *ShowDynamicPartitionStatementContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *ShowDynamicPartitionStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowDynamicPartitionStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowDynamicPartitionStatementContext) QualifiedName() IQualifiedNameContext { @@ -72451,20 +72451,20 @@ func (s *ShowDynamicPartitionStatementContext) ToStringTree(ruleNames []string, } func (s *ShowDynamicPartitionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDynamicPartitionStatement(s) } } func (s *ShowDynamicPartitionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDynamicPartitionStatement(s) } } func (s *ShowDynamicPartitionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDynamicPartitionStatement(s) default: @@ -72472,15 +72472,15 @@ func (s *ShowDynamicPartitionStatementContext) Accept(visitor antlr.ParseTreeVis } } -func (p *DorisSQLParser) ShowDynamicPartitionStatement() (localctx IShowDynamicPartitionStatementContext) { +func (p *StarRocksSQLParser) ShowDynamicPartitionStatement() (localctx IShowDynamicPartitionStatementContext) { localctx = NewShowDynamicPartitionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 492, DorisSQLParserRULE_showDynamicPartitionStatement) + p.EnterRule(localctx, 492, StarRocksSQLParserRULE_showDynamicPartitionStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4507) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72488,7 +72488,7 @@ func (p *DorisSQLParser) ShowDynamicPartitionStatement() (localctx IShowDynamicP } { p.SetState(4508) - p.Match(DorisSQLParserDYNAMIC) + p.Match(StarRocksSQLParserDYNAMIC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72496,7 +72496,7 @@ func (p *DorisSQLParser) ShowDynamicPartitionStatement() (localctx IShowDynamicP } { p.SetState(4509) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72504,7 +72504,7 @@ func (p *DorisSQLParser) ShowDynamicPartitionStatement() (localctx IShowDynamicP } { p.SetState(4510) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72517,12 +72517,12 @@ func (p *DorisSQLParser) ShowDynamicPartitionStatement() (localctx IShowDynamicP } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4511) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -72596,13 +72596,13 @@ type ShowEventsStatementContext struct { func NewEmptyShowEventsStatementContext() *ShowEventsStatementContext { var p = new(ShowEventsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showEventsStatement + p.RuleIndex = StarRocksSQLParserRULE_showEventsStatement return p } func InitEmptyShowEventsStatementContext(p *ShowEventsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showEventsStatement + p.RuleIndex = StarRocksSQLParserRULE_showEventsStatement } func (*ShowEventsStatementContext) IsShowEventsStatementContext() {} @@ -72613,7 +72613,7 @@ func NewShowEventsStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showEventsStatement + p.RuleIndex = StarRocksSQLParserRULE_showEventsStatement return p } @@ -72629,19 +72629,19 @@ func (s *ShowEventsStatementContext) SetCatalog(v IQualifiedNameContext) { s.cat func (s *ShowEventsStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowEventsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowEventsStatementContext) EVENTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEVENTS, 0) + return s.GetToken(StarRocksSQLParserEVENTS, 0) } func (s *ShowEventsStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowEventsStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowEventsStatementContext) QualifiedName() IQualifiedNameContext { @@ -72661,11 +72661,11 @@ func (s *ShowEventsStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowEventsStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowEventsStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowEventsStatementContext) Expression() IExpressionContext { @@ -72709,20 +72709,20 @@ func (s *ShowEventsStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowEventsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowEventsStatement(s) } } func (s *ShowEventsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowEventsStatement(s) } } func (s *ShowEventsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowEventsStatement(s) default: @@ -72730,15 +72730,15 @@ func (s *ShowEventsStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowEventsStatement() (localctx IShowEventsStatementContext) { +func (p *StarRocksSQLParser) ShowEventsStatement() (localctx IShowEventsStatementContext) { localctx = NewShowEventsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 494, DorisSQLParserRULE_showEventsStatement) + p.EnterRule(localctx, 494, StarRocksSQLParserRULE_showEventsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4515) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72746,7 +72746,7 @@ func (p *DorisSQLParser) ShowEventsStatement() (localctx IShowEventsStatementCon } { p.SetState(4516) - p.Match(DorisSQLParserEVENTS) + p.Match(StarRocksSQLParserEVENTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72759,12 +72759,12 @@ func (p *DorisSQLParser) ShowEventsStatement() (localctx IShowEventsStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4517) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -72786,10 +72786,10 @@ func (p *DorisSQLParser) ShowEventsStatement() (localctx IShowEventsStatementCon goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4521) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72803,10 +72803,10 @@ func (p *DorisSQLParser) ShowEventsStatement() (localctx IShowEventsStatementCon localctx.(*ShowEventsStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4523) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72817,7 +72817,7 @@ func (p *DorisSQLParser) ShowEventsStatement() (localctx IShowEventsStatementCon p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -72858,13 +72858,13 @@ type ShowEnginesStatementContext struct { func NewEmptyShowEnginesStatementContext() *ShowEnginesStatementContext { var p = new(ShowEnginesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showEnginesStatement + p.RuleIndex = StarRocksSQLParserRULE_showEnginesStatement return p } func InitEmptyShowEnginesStatementContext(p *ShowEnginesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showEnginesStatement + p.RuleIndex = StarRocksSQLParserRULE_showEnginesStatement } func (*ShowEnginesStatementContext) IsShowEnginesStatementContext() {} @@ -72875,7 +72875,7 @@ func NewShowEnginesStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showEnginesStatement + p.RuleIndex = StarRocksSQLParserRULE_showEnginesStatement return p } @@ -72883,11 +72883,11 @@ func NewShowEnginesStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowEnginesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowEnginesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowEnginesStatementContext) ENGINES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENGINES, 0) + return s.GetToken(StarRocksSQLParserENGINES, 0) } func (s *ShowEnginesStatementContext) GetRuleContext() antlr.RuleContext { @@ -72899,20 +72899,20 @@ func (s *ShowEnginesStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowEnginesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowEnginesStatement(s) } } func (s *ShowEnginesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowEnginesStatement(s) } } func (s *ShowEnginesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowEnginesStatement(s) default: @@ -72920,13 +72920,13 @@ func (s *ShowEnginesStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowEnginesStatement() (localctx IShowEnginesStatementContext) { +func (p *StarRocksSQLParser) ShowEnginesStatement() (localctx IShowEnginesStatementContext) { localctx = NewShowEnginesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 496, DorisSQLParserRULE_showEnginesStatement) + p.EnterRule(localctx, 496, StarRocksSQLParserRULE_showEnginesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4527) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72934,7 +72934,7 @@ func (p *DorisSQLParser) ShowEnginesStatement() (localctx IShowEnginesStatementC } { p.SetState(4528) - p.Match(DorisSQLParserENGINES) + p.Match(StarRocksSQLParserENGINES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -72977,13 +72977,13 @@ type ShowFrontendsStatementContext struct { func NewEmptyShowFrontendsStatementContext() *ShowFrontendsStatementContext { var p = new(ShowFrontendsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFrontendsStatement + p.RuleIndex = StarRocksSQLParserRULE_showFrontendsStatement return p } func InitEmptyShowFrontendsStatementContext(p *ShowFrontendsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFrontendsStatement + p.RuleIndex = StarRocksSQLParserRULE_showFrontendsStatement } func (*ShowFrontendsStatementContext) IsShowFrontendsStatementContext() {} @@ -72994,7 +72994,7 @@ func NewShowFrontendsStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showFrontendsStatement + p.RuleIndex = StarRocksSQLParserRULE_showFrontendsStatement return p } @@ -73002,11 +73002,11 @@ func NewShowFrontendsStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *ShowFrontendsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowFrontendsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowFrontendsStatementContext) FRONTENDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTENDS, 0) + return s.GetToken(StarRocksSQLParserFRONTENDS, 0) } func (s *ShowFrontendsStatementContext) GetRuleContext() antlr.RuleContext { @@ -73018,20 +73018,20 @@ func (s *ShowFrontendsStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowFrontendsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowFrontendsStatement(s) } } func (s *ShowFrontendsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowFrontendsStatement(s) } } func (s *ShowFrontendsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowFrontendsStatement(s) default: @@ -73039,13 +73039,13 @@ func (s *ShowFrontendsStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowFrontendsStatement() (localctx IShowFrontendsStatementContext) { +func (p *StarRocksSQLParser) ShowFrontendsStatement() (localctx IShowFrontendsStatementContext) { localctx = NewShowFrontendsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 498, DorisSQLParserRULE_showFrontendsStatement) + p.EnterRule(localctx, 498, StarRocksSQLParserRULE_showFrontendsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4530) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73053,7 +73053,7 @@ func (p *DorisSQLParser) ShowFrontendsStatement() (localctx IShowFrontendsStatem } { p.SetState(4531) - p.Match(DorisSQLParserFRONTENDS) + p.Match(StarRocksSQLParserFRONTENDS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73097,13 +73097,13 @@ type ShowFrontendsDisksStatementContext struct { func NewEmptyShowFrontendsDisksStatementContext() *ShowFrontendsDisksStatementContext { var p = new(ShowFrontendsDisksStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFrontendsDisksStatement + p.RuleIndex = StarRocksSQLParserRULE_showFrontendsDisksStatement return p } func InitEmptyShowFrontendsDisksStatementContext(p *ShowFrontendsDisksStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showFrontendsDisksStatement + p.RuleIndex = StarRocksSQLParserRULE_showFrontendsDisksStatement } func (*ShowFrontendsDisksStatementContext) IsShowFrontendsDisksStatementContext() {} @@ -73114,7 +73114,7 @@ func NewShowFrontendsDisksStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showFrontendsDisksStatement + p.RuleIndex = StarRocksSQLParserRULE_showFrontendsDisksStatement return p } @@ -73122,15 +73122,15 @@ func NewShowFrontendsDisksStatementContext(parser antlr.Parser, parent antlr.Par func (s *ShowFrontendsDisksStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowFrontendsDisksStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowFrontendsDisksStatementContext) FRONTENDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTENDS, 0) + return s.GetToken(StarRocksSQLParserFRONTENDS, 0) } func (s *ShowFrontendsDisksStatementContext) DISKS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISKS, 0) + return s.GetToken(StarRocksSQLParserDISKS, 0) } func (s *ShowFrontendsDisksStatementContext) GetRuleContext() antlr.RuleContext { @@ -73142,20 +73142,20 @@ func (s *ShowFrontendsDisksStatementContext) ToStringTree(ruleNames []string, re } func (s *ShowFrontendsDisksStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowFrontendsDisksStatement(s) } } func (s *ShowFrontendsDisksStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowFrontendsDisksStatement(s) } } func (s *ShowFrontendsDisksStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowFrontendsDisksStatement(s) default: @@ -73163,13 +73163,13 @@ func (s *ShowFrontendsDisksStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) ShowFrontendsDisksStatement() (localctx IShowFrontendsDisksStatementContext) { +func (p *StarRocksSQLParser) ShowFrontendsDisksStatement() (localctx IShowFrontendsDisksStatementContext) { localctx = NewShowFrontendsDisksStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 500, DorisSQLParserRULE_showFrontendsDisksStatement) + p.EnterRule(localctx, 500, StarRocksSQLParserRULE_showFrontendsDisksStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4533) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73177,7 +73177,7 @@ func (p *DorisSQLParser) ShowFrontendsDisksStatement() (localctx IShowFrontendsD } { p.SetState(4534) - p.Match(DorisSQLParserFRONTENDS) + p.Match(StarRocksSQLParserFRONTENDS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73185,7 +73185,7 @@ func (p *DorisSQLParser) ShowFrontendsDisksStatement() (localctx IShowFrontendsD } { p.SetState(4535) - p.Match(DorisSQLParserDISKS) + p.Match(StarRocksSQLParserDISKS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73228,13 +73228,13 @@ type ShowPluginsStatementContext struct { func NewEmptyShowPluginsStatementContext() *ShowPluginsStatementContext { var p = new(ShowPluginsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPluginsStatement + p.RuleIndex = StarRocksSQLParserRULE_showPluginsStatement return p } func InitEmptyShowPluginsStatementContext(p *ShowPluginsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPluginsStatement + p.RuleIndex = StarRocksSQLParserRULE_showPluginsStatement } func (*ShowPluginsStatementContext) IsShowPluginsStatementContext() {} @@ -73245,7 +73245,7 @@ func NewShowPluginsStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPluginsStatement + p.RuleIndex = StarRocksSQLParserRULE_showPluginsStatement return p } @@ -73253,11 +73253,11 @@ func NewShowPluginsStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowPluginsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowPluginsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPluginsStatementContext) PLUGINS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUGINS, 0) + return s.GetToken(StarRocksSQLParserPLUGINS, 0) } func (s *ShowPluginsStatementContext) GetRuleContext() antlr.RuleContext { @@ -73269,20 +73269,20 @@ func (s *ShowPluginsStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowPluginsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPluginsStatement(s) } } func (s *ShowPluginsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPluginsStatement(s) } } func (s *ShowPluginsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPluginsStatement(s) default: @@ -73290,13 +73290,13 @@ func (s *ShowPluginsStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowPluginsStatement() (localctx IShowPluginsStatementContext) { +func (p *StarRocksSQLParser) ShowPluginsStatement() (localctx IShowPluginsStatementContext) { localctx = NewShowPluginsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 502, DorisSQLParserRULE_showPluginsStatement) + p.EnterRule(localctx, 502, StarRocksSQLParserRULE_showPluginsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4537) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73304,7 +73304,7 @@ func (p *DorisSQLParser) ShowPluginsStatement() (localctx IShowPluginsStatementC } { p.SetState(4538) - p.Match(DorisSQLParserPLUGINS) + p.Match(StarRocksSQLParserPLUGINS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73347,13 +73347,13 @@ type ShowRepositoriesStatementContext struct { func NewEmptyShowRepositoriesStatementContext() *ShowRepositoriesStatementContext { var p = new(ShowRepositoriesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRepositoriesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRepositoriesStatement return p } func InitEmptyShowRepositoriesStatementContext(p *ShowRepositoriesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRepositoriesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRepositoriesStatement } func (*ShowRepositoriesStatementContext) IsShowRepositoriesStatementContext() {} @@ -73364,7 +73364,7 @@ func NewShowRepositoriesStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showRepositoriesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRepositoriesStatement return p } @@ -73372,11 +73372,11 @@ func NewShowRepositoriesStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowRepositoriesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowRepositoriesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowRepositoriesStatementContext) REPOSITORIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORIES, 0) + return s.GetToken(StarRocksSQLParserREPOSITORIES, 0) } func (s *ShowRepositoriesStatementContext) GetRuleContext() antlr.RuleContext { @@ -73388,20 +73388,20 @@ func (s *ShowRepositoriesStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowRepositoriesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowRepositoriesStatement(s) } } func (s *ShowRepositoriesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowRepositoriesStatement(s) } } func (s *ShowRepositoriesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowRepositoriesStatement(s) default: @@ -73409,13 +73409,13 @@ func (s *ShowRepositoriesStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowRepositoriesStatement() (localctx IShowRepositoriesStatementContext) { +func (p *StarRocksSQLParser) ShowRepositoriesStatement() (localctx IShowRepositoriesStatementContext) { localctx = NewShowRepositoriesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 504, DorisSQLParserRULE_showRepositoriesStatement) + p.EnterRule(localctx, 504, StarRocksSQLParserRULE_showRepositoriesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4540) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73423,7 +73423,7 @@ func (p *DorisSQLParser) ShowRepositoriesStatement() (localctx IShowRepositories } { p.SetState(4541) - p.Match(DorisSQLParserREPOSITORIES) + p.Match(StarRocksSQLParserREPOSITORIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73467,13 +73467,13 @@ type ShowOpenTableStatementContext struct { func NewEmptyShowOpenTableStatementContext() *ShowOpenTableStatementContext { var p = new(ShowOpenTableStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showOpenTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showOpenTableStatement return p } func InitEmptyShowOpenTableStatementContext(p *ShowOpenTableStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showOpenTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showOpenTableStatement } func (*ShowOpenTableStatementContext) IsShowOpenTableStatementContext() {} @@ -73484,7 +73484,7 @@ func NewShowOpenTableStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showOpenTableStatement + p.RuleIndex = StarRocksSQLParserRULE_showOpenTableStatement return p } @@ -73492,15 +73492,15 @@ func NewShowOpenTableStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *ShowOpenTableStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowOpenTableStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowOpenTableStatementContext) OPEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPEN, 0) + return s.GetToken(StarRocksSQLParserOPEN, 0) } func (s *ShowOpenTableStatementContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *ShowOpenTableStatementContext) GetRuleContext() antlr.RuleContext { @@ -73512,20 +73512,20 @@ func (s *ShowOpenTableStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowOpenTableStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowOpenTableStatement(s) } } func (s *ShowOpenTableStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowOpenTableStatement(s) } } func (s *ShowOpenTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowOpenTableStatement(s) default: @@ -73533,13 +73533,13 @@ func (s *ShowOpenTableStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowOpenTableStatement() (localctx IShowOpenTableStatementContext) { +func (p *StarRocksSQLParser) ShowOpenTableStatement() (localctx IShowOpenTableStatementContext) { localctx = NewShowOpenTableStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 506, DorisSQLParserRULE_showOpenTableStatement) + p.EnterRule(localctx, 506, StarRocksSQLParserRULE_showOpenTableStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4543) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73547,7 +73547,7 @@ func (p *DorisSQLParser) ShowOpenTableStatement() (localctx IShowOpenTableStatem } { p.SetState(4544) - p.Match(DorisSQLParserOPEN) + p.Match(StarRocksSQLParserOPEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73555,7 +73555,7 @@ func (p *DorisSQLParser) ShowOpenTableStatement() (localctx IShowOpenTableStatem } { p.SetState(4545) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73598,13 +73598,13 @@ type ShowPrivilegesStatementContext struct { func NewEmptyShowPrivilegesStatementContext() *ShowPrivilegesStatementContext { var p = new(ShowPrivilegesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPrivilegesStatement + p.RuleIndex = StarRocksSQLParserRULE_showPrivilegesStatement return p } func InitEmptyShowPrivilegesStatementContext(p *ShowPrivilegesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPrivilegesStatement + p.RuleIndex = StarRocksSQLParserRULE_showPrivilegesStatement } func (*ShowPrivilegesStatementContext) IsShowPrivilegesStatementContext() {} @@ -73615,7 +73615,7 @@ func NewShowPrivilegesStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPrivilegesStatement + p.RuleIndex = StarRocksSQLParserRULE_showPrivilegesStatement return p } @@ -73623,11 +73623,11 @@ func NewShowPrivilegesStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowPrivilegesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowPrivilegesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPrivilegesStatementContext) PRIVILEGES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIVILEGES, 0) + return s.GetToken(StarRocksSQLParserPRIVILEGES, 0) } func (s *ShowPrivilegesStatementContext) GetRuleContext() antlr.RuleContext { @@ -73639,20 +73639,20 @@ func (s *ShowPrivilegesStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowPrivilegesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPrivilegesStatement(s) } } func (s *ShowPrivilegesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPrivilegesStatement(s) } } func (s *ShowPrivilegesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPrivilegesStatement(s) default: @@ -73660,13 +73660,13 @@ func (s *ShowPrivilegesStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowPrivilegesStatement() (localctx IShowPrivilegesStatementContext) { +func (p *StarRocksSQLParser) ShowPrivilegesStatement() (localctx IShowPrivilegesStatementContext) { localctx = NewShowPrivilegesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 508, DorisSQLParserRULE_showPrivilegesStatement) + p.EnterRule(localctx, 508, StarRocksSQLParserRULE_showPrivilegesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4547) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73674,7 +73674,7 @@ func (p *DorisSQLParser) ShowPrivilegesStatement() (localctx IShowPrivilegesStat } { p.SetState(4548) - p.Match(DorisSQLParserPRIVILEGES) + p.Match(StarRocksSQLParserPRIVILEGES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73737,13 +73737,13 @@ type ShowProcedureStatementContext struct { func NewEmptyShowProcedureStatementContext() *ShowProcedureStatementContext { var p = new(ShowProcedureStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProcedureStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcedureStatement return p } func InitEmptyShowProcedureStatementContext(p *ShowProcedureStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProcedureStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcedureStatement } func (*ShowProcedureStatementContext) IsShowProcedureStatementContext() {} @@ -73754,7 +73754,7 @@ func NewShowProcedureStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showProcedureStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcedureStatement return p } @@ -73770,27 +73770,27 @@ func (s *ShowProcedureStatementContext) SetPattern(v IStringContext) { s.pattern func (s *ShowProcedureStatementContext) SetWhere(v IExpressionContext) { s.where = v } func (s *ShowProcedureStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowProcedureStatementContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *ShowProcedureStatementContext) PROCEDURE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROCEDURE, 0) + return s.GetToken(StarRocksSQLParserPROCEDURE, 0) } func (s *ShowProcedureStatementContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *ShowProcedureStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowProcedureStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowProcedureStatementContext) String_() IStringContext { @@ -73834,20 +73834,20 @@ func (s *ShowProcedureStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowProcedureStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowProcedureStatement(s) } } func (s *ShowProcedureStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowProcedureStatement(s) } } func (s *ShowProcedureStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowProcedureStatement(s) default: @@ -73855,15 +73855,15 @@ func (s *ShowProcedureStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatementContext) { +func (p *StarRocksSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatementContext) { localctx = NewShowProcedureStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 510, DorisSQLParserRULE_showProcedureStatement) + p.EnterRule(localctx, 510, StarRocksSQLParserRULE_showProcedureStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4550) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73873,7 +73873,7 @@ func (p *DorisSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatem p.SetState(4551) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFUNCTION || _la == DorisSQLParserPROCEDURE) { + if !(_la == StarRocksSQLParserFUNCTION || _la == StarRocksSQLParserPROCEDURE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -73882,7 +73882,7 @@ func (p *DorisSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatem } { p.SetState(4552) - p.Match(DorisSQLParserSTATUS) + p.Match(StarRocksSQLParserSTATUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73894,10 +73894,10 @@ func (p *DorisSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4553) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73911,10 +73911,10 @@ func (p *DorisSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatem localctx.(*ShowProcedureStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4555) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -73928,7 +73928,7 @@ func (p *DorisSQLParser) ShowProcedureStatement() (localctx IShowProcedureStatem localctx.(*ShowProcedureStatementContext).where = _x } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -73977,13 +73977,13 @@ type ShowProcStatementContext struct { func NewEmptyShowProcStatementContext() *ShowProcStatementContext { var p = new(ShowProcStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProcStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcStatement return p } func InitEmptyShowProcStatementContext(p *ShowProcStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProcStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcStatement } func (*ShowProcStatementContext) IsShowProcStatementContext() {} @@ -73994,7 +73994,7 @@ func NewShowProcStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showProcStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcStatement return p } @@ -74006,11 +74006,11 @@ func (s *ShowProcStatementContext) GetPath() IStringContext { return s.path } func (s *ShowProcStatementContext) SetPath(v IStringContext) { s.path = v } func (s *ShowProcStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowProcStatementContext) PROC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROC, 0) + return s.GetToken(StarRocksSQLParserPROC, 0) } func (s *ShowProcStatementContext) String_() IStringContext { @@ -74038,20 +74038,20 @@ func (s *ShowProcStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *ShowProcStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowProcStatement(s) } } func (s *ShowProcStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowProcStatement(s) } } func (s *ShowProcStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowProcStatement(s) default: @@ -74059,13 +74059,13 @@ func (s *ShowProcStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) ShowProcStatement() (localctx IShowProcStatementContext) { +func (p *StarRocksSQLParser) ShowProcStatement() (localctx IShowProcStatementContext) { localctx = NewShowProcStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 512, DorisSQLParserRULE_showProcStatement) + p.EnterRule(localctx, 512, StarRocksSQLParserRULE_showProcStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4559) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74073,7 +74073,7 @@ func (p *DorisSQLParser) ShowProcStatement() (localctx IShowProcStatementContext } { p.SetState(4560) - p.Match(DorisSQLParserPROC) + p.Match(StarRocksSQLParserPROC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74126,13 +74126,13 @@ type ShowProcesslistStatementContext struct { func NewEmptyShowProcesslistStatementContext() *ShowProcesslistStatementContext { var p = new(ShowProcesslistStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProcesslistStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcesslistStatement return p } func InitEmptyShowProcesslistStatementContext(p *ShowProcesslistStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProcesslistStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcesslistStatement } func (*ShowProcesslistStatementContext) IsShowProcesslistStatementContext() {} @@ -74143,7 +74143,7 @@ func NewShowProcesslistStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showProcesslistStatement + p.RuleIndex = StarRocksSQLParserRULE_showProcesslistStatement return p } @@ -74151,19 +74151,19 @@ func NewShowProcesslistStatementContext(parser antlr.Parser, parent antlr.Parser func (s *ShowProcesslistStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowProcesslistStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowProcesslistStatementContext) PROCESSLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROCESSLIST, 0) + return s.GetToken(StarRocksSQLParserPROCESSLIST, 0) } func (s *ShowProcesslistStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *ShowProcesslistStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowProcesslistStatementContext) String_() IStringContext { @@ -74191,20 +74191,20 @@ func (s *ShowProcesslistStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowProcesslistStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowProcesslistStatement(s) } } func (s *ShowProcesslistStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowProcesslistStatement(s) } } func (s *ShowProcesslistStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowProcesslistStatement(s) default: @@ -74212,15 +74212,15 @@ func (s *ShowProcesslistStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowProcesslistStatement() (localctx IShowProcesslistStatementContext) { +func (p *StarRocksSQLParser) ShowProcesslistStatement() (localctx IShowProcesslistStatementContext) { localctx = NewShowProcesslistStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 514, DorisSQLParserRULE_showProcesslistStatement) + p.EnterRule(localctx, 514, StarRocksSQLParserRULE_showProcesslistStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4563) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74233,10 +74233,10 @@ func (p *DorisSQLParser) ShowProcesslistStatement() (localctx IShowProcesslistSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL { + if _la == StarRocksSQLParserFULL { { p.SetState(4564) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74246,7 +74246,7 @@ func (p *DorisSQLParser) ShowProcesslistStatement() (localctx IShowProcesslistSt } { p.SetState(4567) - p.Match(DorisSQLParserPROCESSLIST) + p.Match(StarRocksSQLParserPROCESSLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74259,10 +74259,10 @@ func (p *DorisSQLParser) ShowProcesslistStatement() (localctx IShowProcesslistSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(4568) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74320,13 +74320,13 @@ type ShowProfilelistStatementContext struct { func NewEmptyShowProfilelistStatementContext() *ShowProfilelistStatementContext { var p = new(ShowProfilelistStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProfilelistStatement + p.RuleIndex = StarRocksSQLParserRULE_showProfilelistStatement return p } func InitEmptyShowProfilelistStatementContext(p *ShowProfilelistStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showProfilelistStatement + p.RuleIndex = StarRocksSQLParserRULE_showProfilelistStatement } func (*ShowProfilelistStatementContext) IsShowProfilelistStatementContext() {} @@ -74337,7 +74337,7 @@ func NewShowProfilelistStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showProfilelistStatement + p.RuleIndex = StarRocksSQLParserRULE_showProfilelistStatement return p } @@ -74349,19 +74349,19 @@ func (s *ShowProfilelistStatementContext) GetLimit() antlr.Token { return s.limi func (s *ShowProfilelistStatementContext) SetLimit(v antlr.Token) { s.limit = v } func (s *ShowProfilelistStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowProfilelistStatementContext) PROFILELIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROFILELIST, 0) + return s.GetToken(StarRocksSQLParserPROFILELIST, 0) } func (s *ShowProfilelistStatementContext) LIMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIMIT, 0) + return s.GetToken(StarRocksSQLParserLIMIT, 0) } func (s *ShowProfilelistStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ShowProfilelistStatementContext) GetRuleContext() antlr.RuleContext { @@ -74373,20 +74373,20 @@ func (s *ShowProfilelistStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowProfilelistStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowProfilelistStatement(s) } } func (s *ShowProfilelistStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowProfilelistStatement(s) } } func (s *ShowProfilelistStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowProfilelistStatement(s) default: @@ -74394,15 +74394,15 @@ func (s *ShowProfilelistStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowProfilelistStatement() (localctx IShowProfilelistStatementContext) { +func (p *StarRocksSQLParser) ShowProfilelistStatement() (localctx IShowProfilelistStatementContext) { localctx = NewShowProfilelistStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 516, DorisSQLParserRULE_showProfilelistStatement) + p.EnterRule(localctx, 516, StarRocksSQLParserRULE_showProfilelistStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4572) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74410,7 +74410,7 @@ func (p *DorisSQLParser) ShowProfilelistStatement() (localctx IShowProfilelistSt } { p.SetState(4573) - p.Match(DorisSQLParserPROFILELIST) + p.Match(StarRocksSQLParserPROFILELIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74423,10 +74423,10 @@ func (p *DorisSQLParser) ShowProfilelistStatement() (localctx IShowProfilelistSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(4574) - p.Match(DorisSQLParserLIMIT) + p.Match(StarRocksSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74435,7 +74435,7 @@ func (p *DorisSQLParser) ShowProfilelistStatement() (localctx IShowProfilelistSt { p.SetState(4575) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*ShowProfilelistStatementContext).limit = _m if p.HasError() { @@ -74492,13 +74492,13 @@ type ShowRunningQueriesStatementContext struct { func NewEmptyShowRunningQueriesStatementContext() *ShowRunningQueriesStatementContext { var p = new(ShowRunningQueriesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRunningQueriesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRunningQueriesStatement return p } func InitEmptyShowRunningQueriesStatementContext(p *ShowRunningQueriesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRunningQueriesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRunningQueriesStatement } func (*ShowRunningQueriesStatementContext) IsShowRunningQueriesStatementContext() {} @@ -74509,7 +74509,7 @@ func NewShowRunningQueriesStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showRunningQueriesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRunningQueriesStatement return p } @@ -74521,23 +74521,23 @@ func (s *ShowRunningQueriesStatementContext) GetLimit() antlr.Token { return s.l func (s *ShowRunningQueriesStatementContext) SetLimit(v antlr.Token) { s.limit = v } func (s *ShowRunningQueriesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowRunningQueriesStatementContext) RUNNING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRUNNING, 0) + return s.GetToken(StarRocksSQLParserRUNNING, 0) } func (s *ShowRunningQueriesStatementContext) QUERIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUERIES, 0) + return s.GetToken(StarRocksSQLParserQUERIES, 0) } func (s *ShowRunningQueriesStatementContext) LIMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIMIT, 0) + return s.GetToken(StarRocksSQLParserLIMIT, 0) } func (s *ShowRunningQueriesStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ShowRunningQueriesStatementContext) GetRuleContext() antlr.RuleContext { @@ -74549,20 +74549,20 @@ func (s *ShowRunningQueriesStatementContext) ToStringTree(ruleNames []string, re } func (s *ShowRunningQueriesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowRunningQueriesStatement(s) } } func (s *ShowRunningQueriesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowRunningQueriesStatement(s) } } func (s *ShowRunningQueriesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowRunningQueriesStatement(s) default: @@ -74570,15 +74570,15 @@ func (s *ShowRunningQueriesStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) ShowRunningQueriesStatement() (localctx IShowRunningQueriesStatementContext) { +func (p *StarRocksSQLParser) ShowRunningQueriesStatement() (localctx IShowRunningQueriesStatementContext) { localctx = NewShowRunningQueriesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 518, DorisSQLParserRULE_showRunningQueriesStatement) + p.EnterRule(localctx, 518, StarRocksSQLParserRULE_showRunningQueriesStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4578) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74586,7 +74586,7 @@ func (p *DorisSQLParser) ShowRunningQueriesStatement() (localctx IShowRunningQue } { p.SetState(4579) - p.Match(DorisSQLParserRUNNING) + p.Match(StarRocksSQLParserRUNNING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74594,7 +74594,7 @@ func (p *DorisSQLParser) ShowRunningQueriesStatement() (localctx IShowRunningQue } { p.SetState(4580) - p.Match(DorisSQLParserQUERIES) + p.Match(StarRocksSQLParserQUERIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74607,10 +74607,10 @@ func (p *DorisSQLParser) ShowRunningQueriesStatement() (localctx IShowRunningQue } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(4581) - p.Match(DorisSQLParserLIMIT) + p.Match(StarRocksSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74619,7 +74619,7 @@ func (p *DorisSQLParser) ShowRunningQueriesStatement() (localctx IShowRunningQue { p.SetState(4582) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*ShowRunningQueriesStatementContext).limit = _m if p.HasError() { @@ -74678,13 +74678,13 @@ type ShowStatusStatementContext struct { func NewEmptyShowStatusStatementContext() *ShowStatusStatementContext { var p = new(ShowStatusStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_showStatusStatement return p } func InitEmptyShowStatusStatementContext(p *ShowStatusStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_showStatusStatement } func (*ShowStatusStatementContext) IsShowStatusStatementContext() {} @@ -74695,7 +74695,7 @@ func NewShowStatusStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showStatusStatement + p.RuleIndex = StarRocksSQLParserRULE_showStatusStatement return p } @@ -74707,11 +74707,11 @@ func (s *ShowStatusStatementContext) GetPattern() IStringContext { return s.patt func (s *ShowStatusStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowStatusStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowStatusStatementContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *ShowStatusStatementContext) VarType() IVarTypeContext { @@ -74731,11 +74731,11 @@ func (s *ShowStatusStatementContext) VarType() IVarTypeContext { } func (s *ShowStatusStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowStatusStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowStatusStatementContext) Expression() IExpressionContext { @@ -74779,20 +74779,20 @@ func (s *ShowStatusStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowStatusStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowStatusStatement(s) } } func (s *ShowStatusStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowStatusStatement(s) } } func (s *ShowStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowStatusStatement(s) default: @@ -74800,15 +74800,15 @@ func (s *ShowStatusStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowStatusStatement() (localctx IShowStatusStatementContext) { +func (p *StarRocksSQLParser) ShowStatusStatement() (localctx IShowStatusStatementContext) { localctx = NewShowStatusStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 520, DorisSQLParserRULE_showStatusStatement) + p.EnterRule(localctx, 520, StarRocksSQLParserRULE_showStatusStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4585) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74821,7 +74821,7 @@ func (p *DorisSQLParser) ShowStatusStatement() (localctx IShowStatusStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL || _la == DorisSQLParserLOCAL || _la == DorisSQLParserSESSION || _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserGLOBAL || _la == StarRocksSQLParserLOCAL || _la == StarRocksSQLParserSESSION || _la == StarRocksSQLParserVERBOSE { { p.SetState(4586) p.VarType() @@ -74830,7 +74830,7 @@ func (p *DorisSQLParser) ShowStatusStatement() (localctx IShowStatusStatementCon } { p.SetState(4589) - p.Match(DorisSQLParserSTATUS) + p.Match(StarRocksSQLParserSTATUS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74842,10 +74842,10 @@ func (p *DorisSQLParser) ShowStatusStatement() (localctx IShowStatusStatementCon goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4590) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74859,10 +74859,10 @@ func (p *DorisSQLParser) ShowStatusStatement() (localctx IShowStatusStatementCon localctx.(*ShowStatusStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4592) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -74873,7 +74873,7 @@ func (p *DorisSQLParser) ShowStatusStatement() (localctx IShowStatusStatementCon p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -74926,13 +74926,13 @@ type ShowTabletStatementContext struct { func NewEmptyShowTabletStatementContext() *ShowTabletStatementContext { var p = new(ShowTabletStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTabletStatement + p.RuleIndex = StarRocksSQLParserRULE_showTabletStatement return p } func InitEmptyShowTabletStatementContext(p *ShowTabletStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTabletStatement + p.RuleIndex = StarRocksSQLParserRULE_showTabletStatement } func (*ShowTabletStatementContext) IsShowTabletStatementContext() {} @@ -74943,7 +74943,7 @@ func NewShowTabletStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTabletStatement + p.RuleIndex = StarRocksSQLParserRULE_showTabletStatement return p } @@ -74951,19 +74951,19 @@ func NewShowTabletStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ShowTabletStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowTabletStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTabletStatementContext) TABLET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLET, 0) + return s.GetToken(StarRocksSQLParserTABLET, 0) } func (s *ShowTabletStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ShowTabletStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowTabletStatementContext) QualifiedName() IQualifiedNameContext { @@ -74983,7 +74983,7 @@ func (s *ShowTabletStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowTabletStatementContext) TABLETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLETS, 0) + return s.GetToken(StarRocksSQLParserTABLETS, 0) } func (s *ShowTabletStatementContext) PartitionNames() IPartitionNamesContext { @@ -75003,7 +75003,7 @@ func (s *ShowTabletStatementContext) PartitionNames() IPartitionNamesContext { } func (s *ShowTabletStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowTabletStatementContext) Expression() IExpressionContext { @@ -75023,11 +75023,11 @@ func (s *ShowTabletStatementContext) Expression() IExpressionContext { } func (s *ShowTabletStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowTabletStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowTabletStatementContext) AllSortItem() []ISortItemContext { @@ -75096,20 +75096,20 @@ func (s *ShowTabletStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowTabletStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTabletStatement(s) } } func (s *ShowTabletStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTabletStatement(s) } } func (s *ShowTabletStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTabletStatement(s) default: @@ -75117,9 +75117,9 @@ func (s *ShowTabletStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementContext) { +func (p *StarRocksSQLParser) ShowTabletStatement() (localctx IShowTabletStatementContext) { localctx = NewShowTabletStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 522, DorisSQLParserRULE_showTabletStatement) + p.EnterRule(localctx, 522, StarRocksSQLParserRULE_showTabletStatement) var _la int p.SetState(4625) @@ -75133,7 +75133,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon p.EnterOuterAlt(localctx, 1) { p.SetState(4596) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75141,7 +75141,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } { p.SetState(4597) - p.Match(DorisSQLParserTABLET) + p.Match(StarRocksSQLParserTABLET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75149,7 +75149,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } { p.SetState(4598) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75160,7 +75160,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon p.EnterOuterAlt(localctx, 2) { p.SetState(4599) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75170,7 +75170,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon p.SetState(4600) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserTABLET || _la == DorisSQLParserTABLETS) { + if !(_la == StarRocksSQLParserTABLET || _la == StarRocksSQLParserTABLETS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -75179,7 +75179,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } { p.SetState(4601) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75196,7 +75196,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(4603) p.PartitionNames() @@ -75210,10 +75210,10 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4606) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75232,10 +75232,10 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(4610) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75243,7 +75243,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } { p.SetState(4611) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75260,10 +75260,10 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4613) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75290,7 +75290,7 @@ func (p *DorisSQLParser) ShowTabletStatement() (localctx IShowTabletStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(4622) p.LimitElement() @@ -75350,13 +75350,13 @@ type ShowTransactionStatementContext struct { func NewEmptyShowTransactionStatementContext() *ShowTransactionStatementContext { var p = new(ShowTransactionStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTransactionStatement + p.RuleIndex = StarRocksSQLParserRULE_showTransactionStatement return p } func InitEmptyShowTransactionStatementContext(p *ShowTransactionStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTransactionStatement + p.RuleIndex = StarRocksSQLParserRULE_showTransactionStatement } func (*ShowTransactionStatementContext) IsShowTransactionStatementContext() {} @@ -75367,7 +75367,7 @@ func NewShowTransactionStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTransactionStatement + p.RuleIndex = StarRocksSQLParserRULE_showTransactionStatement return p } @@ -75379,15 +75379,15 @@ func (s *ShowTransactionStatementContext) GetDb() IQualifiedNameContext { return func (s *ShowTransactionStatementContext) SetDb(v IQualifiedNameContext) { s.db = v } func (s *ShowTransactionStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTransactionStatementContext) TRANSACTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSACTION, 0) + return s.GetToken(StarRocksSQLParserTRANSACTION, 0) } func (s *ShowTransactionStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowTransactionStatementContext) Expression() IExpressionContext { @@ -75407,11 +75407,11 @@ func (s *ShowTransactionStatementContext) Expression() IExpressionContext { } func (s *ShowTransactionStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowTransactionStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowTransactionStatementContext) QualifiedName() IQualifiedNameContext { @@ -75439,20 +75439,20 @@ func (s *ShowTransactionStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowTransactionStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTransactionStatement(s) } } func (s *ShowTransactionStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTransactionStatement(s) } } func (s *ShowTransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTransactionStatement(s) default: @@ -75460,15 +75460,15 @@ func (s *ShowTransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowTransactionStatement() (localctx IShowTransactionStatementContext) { +func (p *StarRocksSQLParser) ShowTransactionStatement() (localctx IShowTransactionStatementContext) { localctx = NewShowTransactionStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 524, DorisSQLParserRULE_showTransactionStatement) + p.EnterRule(localctx, 524, StarRocksSQLParserRULE_showTransactionStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4627) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75476,7 +75476,7 @@ func (p *DorisSQLParser) ShowTransactionStatement() (localctx IShowTransactionSt } { p.SetState(4628) - p.Match(DorisSQLParserTRANSACTION) + p.Match(StarRocksSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75489,12 +75489,12 @@ func (p *DorisSQLParser) ShowTransactionStatement() (localctx IShowTransactionSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4629) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -75517,10 +75517,10 @@ func (p *DorisSQLParser) ShowTransactionStatement() (localctx IShowTransactionSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4633) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75591,13 +75591,13 @@ type ShowTriggersStatementContext struct { func NewEmptyShowTriggersStatementContext() *ShowTriggersStatementContext { var p = new(ShowTriggersStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTriggersStatement + p.RuleIndex = StarRocksSQLParserRULE_showTriggersStatement return p } func InitEmptyShowTriggersStatementContext(p *ShowTriggersStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTriggersStatement + p.RuleIndex = StarRocksSQLParserRULE_showTriggersStatement } func (*ShowTriggersStatementContext) IsShowTriggersStatementContext() {} @@ -75608,7 +75608,7 @@ func NewShowTriggersStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTriggersStatement + p.RuleIndex = StarRocksSQLParserRULE_showTriggersStatement return p } @@ -75624,23 +75624,23 @@ func (s *ShowTriggersStatementContext) SetCatalog(v IQualifiedNameContext) { s.c func (s *ShowTriggersStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowTriggersStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTriggersStatementContext) TRIGGERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRIGGERS, 0) + return s.GetToken(StarRocksSQLParserTRIGGERS, 0) } func (s *ShowTriggersStatementContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *ShowTriggersStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowTriggersStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowTriggersStatementContext) QualifiedName() IQualifiedNameContext { @@ -75660,11 +75660,11 @@ func (s *ShowTriggersStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowTriggersStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowTriggersStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowTriggersStatementContext) Expression() IExpressionContext { @@ -75708,20 +75708,20 @@ func (s *ShowTriggersStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowTriggersStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTriggersStatement(s) } } func (s *ShowTriggersStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTriggersStatement(s) } } func (s *ShowTriggersStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTriggersStatement(s) default: @@ -75729,15 +75729,15 @@ func (s *ShowTriggersStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatementContext) { +func (p *StarRocksSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatementContext) { localctx = NewShowTriggersStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 526, DorisSQLParserRULE_showTriggersStatement) + p.EnterRule(localctx, 526, StarRocksSQLParserRULE_showTriggersStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4637) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75750,10 +75750,10 @@ func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFULL { + if _la == StarRocksSQLParserFULL { { p.SetState(4638) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75763,7 +75763,7 @@ func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatemen } { p.SetState(4641) - p.Match(DorisSQLParserTRIGGERS) + p.Match(StarRocksSQLParserTRIGGERS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75776,12 +75776,12 @@ func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4642) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -75803,10 +75803,10 @@ func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatemen goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4646) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75820,10 +75820,10 @@ func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatemen localctx.(*ShowTriggersStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4648) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -75834,7 +75834,7 @@ func (p *DorisSQLParser) ShowTriggersStatement() (localctx IShowTriggersStatemen p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -75880,13 +75880,13 @@ type ShowUserPropertyStatementContext struct { func NewEmptyShowUserPropertyStatementContext() *ShowUserPropertyStatementContext { var p = new(ShowUserPropertyStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showUserPropertyStatement + p.RuleIndex = StarRocksSQLParserRULE_showUserPropertyStatement return p } func InitEmptyShowUserPropertyStatementContext(p *ShowUserPropertyStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showUserPropertyStatement + p.RuleIndex = StarRocksSQLParserRULE_showUserPropertyStatement } func (*ShowUserPropertyStatementContext) IsShowUserPropertyStatementContext() {} @@ -75897,7 +75897,7 @@ func NewShowUserPropertyStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showUserPropertyStatement + p.RuleIndex = StarRocksSQLParserRULE_showUserPropertyStatement return p } @@ -75905,15 +75905,15 @@ func NewShowUserPropertyStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowUserPropertyStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowUserPropertyStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowUserPropertyStatementContext) PROPERTY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTY, 0) + return s.GetToken(StarRocksSQLParserPROPERTY, 0) } func (s *ShowUserPropertyStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowUserPropertyStatementContext) AllString_() []IStringContext { @@ -75958,11 +75958,11 @@ func (s *ShowUserPropertyStatementContext) String_(i int) IStringContext { } func (s *ShowUserPropertyStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowUserPropertyStatementContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *ShowUserPropertyStatementContext) GetRuleContext() antlr.RuleContext { @@ -75974,20 +75974,20 @@ func (s *ShowUserPropertyStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowUserPropertyStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowUserPropertyStatement(s) } } func (s *ShowUserPropertyStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowUserPropertyStatement(s) } } func (s *ShowUserPropertyStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowUserPropertyStatement(s) default: @@ -75995,9 +75995,9 @@ func (s *ShowUserPropertyStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserPropertyStatementContext) { +func (p *StarRocksSQLParser) ShowUserPropertyStatement() (localctx IShowUserPropertyStatementContext) { localctx = NewShowUserPropertyStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 528, DorisSQLParserRULE_showUserPropertyStatement) + p.EnterRule(localctx, 528, StarRocksSQLParserRULE_showUserPropertyStatement) var _la int p.SetState(4672) @@ -76011,7 +76011,7 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty p.EnterOuterAlt(localctx, 1) { p.SetState(4652) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76019,7 +76019,7 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty } { p.SetState(4653) - p.Match(DorisSQLParserPROPERTY) + p.Match(StarRocksSQLParserPROPERTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76032,10 +76032,10 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(4654) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76054,10 +76054,10 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(4658) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76074,7 +76074,7 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty p.EnterOuterAlt(localctx, 2) { p.SetState(4662) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76082,7 +76082,7 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty } { p.SetState(4663) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76095,10 +76095,10 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(4664) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76117,10 +76117,10 @@ func (p *DorisSQLParser) ShowUserPropertyStatement() (localctx IShowUserProperty } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(4668) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76185,13 +76185,13 @@ type ShowVariablesStatementContext struct { func NewEmptyShowVariablesStatementContext() *ShowVariablesStatementContext { var p = new(ShowVariablesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showVariablesStatement + p.RuleIndex = StarRocksSQLParserRULE_showVariablesStatement return p } func InitEmptyShowVariablesStatementContext(p *ShowVariablesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showVariablesStatement + p.RuleIndex = StarRocksSQLParserRULE_showVariablesStatement } func (*ShowVariablesStatementContext) IsShowVariablesStatementContext() {} @@ -76202,7 +76202,7 @@ func NewShowVariablesStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showVariablesStatement + p.RuleIndex = StarRocksSQLParserRULE_showVariablesStatement return p } @@ -76214,11 +76214,11 @@ func (s *ShowVariablesStatementContext) GetPattern() IStringContext { return s.p func (s *ShowVariablesStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowVariablesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowVariablesStatementContext) VARIABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVARIABLES, 0) + return s.GetToken(StarRocksSQLParserVARIABLES, 0) } func (s *ShowVariablesStatementContext) VarType() IVarTypeContext { @@ -76238,11 +76238,11 @@ func (s *ShowVariablesStatementContext) VarType() IVarTypeContext { } func (s *ShowVariablesStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowVariablesStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowVariablesStatementContext) Expression() IExpressionContext { @@ -76286,20 +76286,20 @@ func (s *ShowVariablesStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowVariablesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowVariablesStatement(s) } } func (s *ShowVariablesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowVariablesStatement(s) } } func (s *ShowVariablesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowVariablesStatement(s) default: @@ -76307,15 +76307,15 @@ func (s *ShowVariablesStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatementContext) { +func (p *StarRocksSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatementContext) { localctx = NewShowVariablesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 530, DorisSQLParserRULE_showVariablesStatement) + p.EnterRule(localctx, 530, StarRocksSQLParserRULE_showVariablesStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4674) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76328,7 +76328,7 @@ func (p *DorisSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL || _la == DorisSQLParserLOCAL || _la == DorisSQLParserSESSION || _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserGLOBAL || _la == StarRocksSQLParserLOCAL || _la == StarRocksSQLParserSESSION || _la == StarRocksSQLParserVERBOSE { { p.SetState(4675) p.VarType() @@ -76337,7 +76337,7 @@ func (p *DorisSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatem } { p.SetState(4678) - p.Match(DorisSQLParserVARIABLES) + p.Match(StarRocksSQLParserVARIABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76349,10 +76349,10 @@ func (p *DorisSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4679) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76366,10 +76366,10 @@ func (p *DorisSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatem localctx.(*ShowVariablesStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(4681) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76380,7 +76380,7 @@ func (p *DorisSQLParser) ShowVariablesStatement() (localctx IShowVariablesStatem p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -76423,13 +76423,13 @@ type ShowWarningStatementContext struct { func NewEmptyShowWarningStatementContext() *ShowWarningStatementContext { var p = new(ShowWarningStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWarningStatement + p.RuleIndex = StarRocksSQLParserRULE_showWarningStatement return p } func InitEmptyShowWarningStatementContext(p *ShowWarningStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWarningStatement + p.RuleIndex = StarRocksSQLParserRULE_showWarningStatement } func (*ShowWarningStatementContext) IsShowWarningStatementContext() {} @@ -76440,7 +76440,7 @@ func NewShowWarningStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showWarningStatement + p.RuleIndex = StarRocksSQLParserRULE_showWarningStatement return p } @@ -76448,15 +76448,15 @@ func NewShowWarningStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowWarningStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowWarningStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowWarningStatementContext) WARNINGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWARNINGS, 0) + return s.GetToken(StarRocksSQLParserWARNINGS, 0) } func (s *ShowWarningStatementContext) ERRORS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserERRORS, 0) + return s.GetToken(StarRocksSQLParserERRORS, 0) } func (s *ShowWarningStatementContext) LimitElement() ILimitElementContext { @@ -76484,20 +76484,20 @@ func (s *ShowWarningStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowWarningStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowWarningStatement(s) } } func (s *ShowWarningStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowWarningStatement(s) } } func (s *ShowWarningStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowWarningStatement(s) default: @@ -76505,15 +76505,15 @@ func (s *ShowWarningStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowWarningStatement() (localctx IShowWarningStatementContext) { +func (p *StarRocksSQLParser) ShowWarningStatement() (localctx IShowWarningStatementContext) { localctx = NewShowWarningStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 532, DorisSQLParserRULE_showWarningStatement) + p.EnterRule(localctx, 532, StarRocksSQLParserRULE_showWarningStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4685) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76523,7 +76523,7 @@ func (p *DorisSQLParser) ShowWarningStatement() (localctx IShowWarningStatementC p.SetState(4686) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserERRORS || _la == DorisSQLParserWARNINGS) { + if !(_la == StarRocksSQLParserERRORS || _la == StarRocksSQLParserWARNINGS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -76537,7 +76537,7 @@ func (p *DorisSQLParser) ShowWarningStatement() (localctx IShowWarningStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(4687) p.LimitElement() @@ -76581,13 +76581,13 @@ type HelpStatementContext struct { func NewEmptyHelpStatementContext() *HelpStatementContext { var p = new(HelpStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_helpStatement + p.RuleIndex = StarRocksSQLParserRULE_helpStatement return p } func InitEmptyHelpStatementContext(p *HelpStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_helpStatement + p.RuleIndex = StarRocksSQLParserRULE_helpStatement } func (*HelpStatementContext) IsHelpStatementContext() {} @@ -76598,7 +76598,7 @@ func NewHelpStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_helpStatement + p.RuleIndex = StarRocksSQLParserRULE_helpStatement return p } @@ -76606,7 +76606,7 @@ func NewHelpStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *HelpStatementContext) GetParser() antlr.Parser { return s.parser } func (s *HelpStatementContext) HELP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHELP, 0) + return s.GetToken(StarRocksSQLParserHELP, 0) } func (s *HelpStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -76634,20 +76634,20 @@ func (s *HelpStatementContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *HelpStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterHelpStatement(s) } } func (s *HelpStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitHelpStatement(s) } } func (s *HelpStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitHelpStatement(s) default: @@ -76655,13 +76655,13 @@ func (s *HelpStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) HelpStatement() (localctx IHelpStatementContext) { +func (p *StarRocksSQLParser) HelpStatement() (localctx IHelpStatementContext) { localctx = NewHelpStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 534, DorisSQLParserRULE_helpStatement) + p.EnterRule(localctx, 534, StarRocksSQLParserRULE_helpStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4690) - p.Match(DorisSQLParserHELP) + p.Match(StarRocksSQLParserHELP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76714,13 +76714,13 @@ type ShowQueryProfileStatementContext struct { func NewEmptyShowQueryProfileStatementContext() *ShowQueryProfileStatementContext { var p = new(ShowQueryProfileStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showQueryProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_showQueryProfileStatement return p } func InitEmptyShowQueryProfileStatementContext(p *ShowQueryProfileStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showQueryProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_showQueryProfileStatement } func (*ShowQueryProfileStatementContext) IsShowQueryProfileStatementContext() {} @@ -76731,7 +76731,7 @@ func NewShowQueryProfileStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showQueryProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_showQueryProfileStatement return p } @@ -76739,15 +76739,15 @@ func NewShowQueryProfileStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowQueryProfileStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowQueryProfileStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowQueryProfileStatementContext) QUERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUERY, 0) + return s.GetToken(StarRocksSQLParserQUERY, 0) } func (s *ShowQueryProfileStatementContext) PROFILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROFILE, 0) + return s.GetToken(StarRocksSQLParserPROFILE, 0) } func (s *ShowQueryProfileStatementContext) String_() IStringContext { @@ -76767,19 +76767,19 @@ func (s *ShowQueryProfileStatementContext) String_() IStringContext { } func (s *ShowQueryProfileStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *ShowQueryProfileStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *ShowQueryProfileStatementContext) AllSLASH_SYMBOL() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserSLASH_SYMBOL) + return s.GetTokens(StarRocksSQLParserSLASH_SYMBOL) } func (s *ShowQueryProfileStatementContext) SLASH_SYMBOL(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserSLASH_SYMBOL, i) + return s.GetToken(StarRocksSQLParserSLASH_SYMBOL, i) } func (s *ShowQueryProfileStatementContext) GetRuleContext() antlr.RuleContext { @@ -76791,20 +76791,20 @@ func (s *ShowQueryProfileStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowQueryProfileStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowQueryProfileStatement(s) } } func (s *ShowQueryProfileStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowQueryProfileStatement(s) } } func (s *ShowQueryProfileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowQueryProfileStatement(s) default: @@ -76812,9 +76812,9 @@ func (s *ShowQueryProfileStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfileStatementContext) { +func (p *StarRocksSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfileStatementContext) { localctx = NewShowQueryProfileStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 536, DorisSQLParserRULE_showQueryProfileStatement) + p.EnterRule(localctx, 536, StarRocksSQLParserRULE_showQueryProfileStatement) var _la int p.SetState(4730) @@ -76828,7 +76828,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile p.EnterOuterAlt(localctx, 1) { p.SetState(4693) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76836,7 +76836,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4694) - p.Match(DorisSQLParserQUERY) + p.Match(StarRocksSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76844,7 +76844,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4695) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76861,10 +76861,10 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__2 { + if _la == StarRocksSQLParserT__2 { { p.SetState(4697) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76872,7 +76872,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4698) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76885,10 +76885,10 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4699) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76896,7 +76896,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4700) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76917,7 +76917,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile p.EnterOuterAlt(localctx, 2) { p.SetState(4708) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76925,7 +76925,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4709) - p.Match(DorisSQLParserQUERY) + p.Match(StarRocksSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76933,7 +76933,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4710) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76945,7 +76945,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4712) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76956,7 +76956,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile p.EnterOuterAlt(localctx, 3) { p.SetState(4714) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76964,7 +76964,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4715) - p.Match(DorisSQLParserQUERY) + p.Match(StarRocksSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76972,7 +76972,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4716) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76984,7 +76984,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4718) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -76992,7 +76992,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4719) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77003,7 +77003,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile p.EnterOuterAlt(localctx, 4) { p.SetState(4721) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77011,7 +77011,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4722) - p.Match(DorisSQLParserQUERY) + p.Match(StarRocksSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77019,7 +77019,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4723) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77031,7 +77031,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4725) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77039,7 +77039,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4726) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77047,7 +77047,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4727) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77055,7 +77055,7 @@ func (p *DorisSQLParser) ShowQueryProfileStatement() (localctx IShowQueryProfile } { p.SetState(4728) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77109,13 +77109,13 @@ type ShowQueryStatsStatementContext struct { func NewEmptyShowQueryStatsStatementContext() *ShowQueryStatsStatementContext { var p = new(ShowQueryStatsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showQueryStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showQueryStatsStatement return p } func InitEmptyShowQueryStatsStatementContext(p *ShowQueryStatsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showQueryStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showQueryStatsStatement } func (*ShowQueryStatsStatementContext) IsShowQueryStatsStatementContext() {} @@ -77126,7 +77126,7 @@ func NewShowQueryStatsStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showQueryStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showQueryStatsStatement return p } @@ -77134,27 +77134,27 @@ func NewShowQueryStatsStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowQueryStatsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowQueryStatsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowQueryStatsStatementContext) QUERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUERY, 0) + return s.GetToken(StarRocksSQLParserQUERY, 0) } func (s *ShowQueryStatsStatementContext) STATS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATS, 0) + return s.GetToken(StarRocksSQLParserSTATS, 0) } func (s *ShowQueryStatsStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ShowQueryStatsStatementContext) VERBOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERBOSE, 0) + return s.GetToken(StarRocksSQLParserVERBOSE, 0) } func (s *ShowQueryStatsStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowQueryStatsStatementContext) Identifier() IIdentifierContext { @@ -77174,7 +77174,7 @@ func (s *ShowQueryStatsStatementContext) Identifier() IIdentifierContext { } func (s *ShowQueryStatsStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowQueryStatsStatementContext) QualifiedName() IQualifiedNameContext { @@ -77202,20 +77202,20 @@ func (s *ShowQueryStatsStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowQueryStatsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowQueryStatsStatement(s) } } func (s *ShowQueryStatsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowQueryStatsStatement(s) } } func (s *ShowQueryStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowQueryStatsStatement(s) default: @@ -77223,15 +77223,15 @@ func (s *ShowQueryStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStatementContext) { +func (p *StarRocksSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStatementContext) { localctx = NewShowQueryStatsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 538, DorisSQLParserRULE_showQueryStatsStatement) + p.EnterRule(localctx, 538, StarRocksSQLParserRULE_showQueryStatsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4732) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77239,7 +77239,7 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat } { p.SetState(4733) - p.Match(DorisSQLParserQUERY) + p.Match(StarRocksSQLParserQUERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77247,7 +77247,7 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat } { p.SetState(4734) - p.Match(DorisSQLParserSTATS) + p.Match(StarRocksSQLParserSTATS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77259,10 +77259,10 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserFOR: + case StarRocksSQLParserFOR: { p.SetState(4735) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77273,10 +77273,10 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat p.Identifier() } - case DorisSQLParserFROM: + case StarRocksSQLParserFROM: { p.SetState(4737) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77287,7 +77287,7 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat p.QualifiedName() } - case DorisSQLParserEOF, DorisSQLParserALL, DorisSQLParserVERBOSE, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserALL, StarRocksSQLParserVERBOSE, StarRocksSQLParserSEMICOLON: default: } @@ -77298,10 +77298,10 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL { + if _la == StarRocksSQLParserALL { { p.SetState(4741) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77316,10 +77316,10 @@ func (p *DorisSQLParser) ShowQueryStatsStatement() (localctx IShowQueryStatsStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserVERBOSE { { p.SetState(4744) - p.Match(DorisSQLParserVERBOSE) + p.Match(StarRocksSQLParserVERBOSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77370,13 +77370,13 @@ type ShowLoadProfileStatementContext struct { func NewEmptyShowLoadProfileStatementContext() *ShowLoadProfileStatementContext { var p = new(ShowLoadProfileStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLoadProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadProfileStatement return p } func InitEmptyShowLoadProfileStatementContext(p *ShowLoadProfileStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLoadProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadProfileStatement } func (*ShowLoadProfileStatementContext) IsShowLoadProfileStatementContext() {} @@ -77387,7 +77387,7 @@ func NewShowLoadProfileStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showLoadProfileStatement + p.RuleIndex = StarRocksSQLParserRULE_showLoadProfileStatement return p } @@ -77395,15 +77395,15 @@ func NewShowLoadProfileStatementContext(parser antlr.Parser, parent antlr.Parser func (s *ShowLoadProfileStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowLoadProfileStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowLoadProfileStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowLoadProfileStatementContext) PROFILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROFILE, 0) + return s.GetToken(StarRocksSQLParserPROFILE, 0) } func (s *ShowLoadProfileStatementContext) String_() IStringContext { @@ -77423,19 +77423,19 @@ func (s *ShowLoadProfileStatementContext) String_() IStringContext { } func (s *ShowLoadProfileStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *ShowLoadProfileStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *ShowLoadProfileStatementContext) AllSLASH_SYMBOL() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserSLASH_SYMBOL) + return s.GetTokens(StarRocksSQLParserSLASH_SYMBOL) } func (s *ShowLoadProfileStatementContext) SLASH_SYMBOL(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserSLASH_SYMBOL, i) + return s.GetToken(StarRocksSQLParserSLASH_SYMBOL, i) } func (s *ShowLoadProfileStatementContext) GetRuleContext() antlr.RuleContext { @@ -77447,20 +77447,20 @@ func (s *ShowLoadProfileStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowLoadProfileStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowLoadProfileStatement(s) } } func (s *ShowLoadProfileStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowLoadProfileStatement(s) } } func (s *ShowLoadProfileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowLoadProfileStatement(s) default: @@ -77468,9 +77468,9 @@ func (s *ShowLoadProfileStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileStatementContext) { +func (p *StarRocksSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileStatementContext) { localctx = NewShowLoadProfileStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 540, DorisSQLParserRULE_showLoadProfileStatement) + p.EnterRule(localctx, 540, StarRocksSQLParserRULE_showLoadProfileStatement) var _la int p.SetState(4795) @@ -77484,7 +77484,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt p.EnterOuterAlt(localctx, 1) { p.SetState(4747) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77492,7 +77492,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4748) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77500,7 +77500,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4749) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77517,10 +77517,10 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__2 { + if _la == StarRocksSQLParserT__2 { { p.SetState(4751) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77528,7 +77528,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4752) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77541,10 +77541,10 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4753) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77552,7 +77552,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4754) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77573,7 +77573,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt p.EnterOuterAlt(localctx, 2) { p.SetState(4762) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77581,7 +77581,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4763) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77589,7 +77589,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4764) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77601,7 +77601,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4766) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77612,7 +77612,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt p.EnterOuterAlt(localctx, 3) { p.SetState(4768) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77620,7 +77620,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4769) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77628,7 +77628,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4770) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77640,7 +77640,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4772) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77648,7 +77648,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4773) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77659,7 +77659,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt p.EnterOuterAlt(localctx, 4) { p.SetState(4775) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77667,7 +77667,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4776) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77675,7 +77675,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4777) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77687,7 +77687,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4779) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77695,7 +77695,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4780) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77703,7 +77703,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4781) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77711,7 +77711,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4782) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77722,7 +77722,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt p.EnterOuterAlt(localctx, 5) { p.SetState(4784) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77730,7 +77730,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4785) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77738,7 +77738,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4786) - p.Match(DorisSQLParserPROFILE) + p.Match(StarRocksSQLParserPROFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77750,7 +77750,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4788) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77758,7 +77758,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4789) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77766,7 +77766,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4790) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77774,7 +77774,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4791) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77782,7 +77782,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4792) - p.Match(DorisSQLParserSLASH_SYMBOL) + p.Match(StarRocksSQLParserSLASH_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77790,7 +77790,7 @@ func (p *DorisSQLParser) ShowLoadProfileStatement() (localctx IShowLoadProfileSt } { p.SetState(4793) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77841,13 +77841,13 @@ type ShowDataSkewStatementContext struct { func NewEmptyShowDataSkewStatementContext() *ShowDataSkewStatementContext { var p = new(ShowDataSkewStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataSkewStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataSkewStatement return p } func InitEmptyShowDataSkewStatementContext(p *ShowDataSkewStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataSkewStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataSkewStatement } func (*ShowDataSkewStatementContext) IsShowDataSkewStatementContext() {} @@ -77858,7 +77858,7 @@ func NewShowDataSkewStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDataSkewStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataSkewStatement return p } @@ -77866,19 +77866,19 @@ func NewShowDataSkewStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *ShowDataSkewStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDataSkewStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDataSkewStatementContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *ShowDataSkewStatementContext) SKEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSKEW, 0) + return s.GetToken(StarRocksSQLParserSKEW, 0) } func (s *ShowDataSkewStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowDataSkewStatementContext) QualifiedName() IQualifiedNameContext { @@ -77922,20 +77922,20 @@ func (s *ShowDataSkewStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowDataSkewStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDataSkewStatement(s) } } func (s *ShowDataSkewStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDataSkewStatement(s) } } func (s *ShowDataSkewStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDataSkewStatement(s) default: @@ -77943,15 +77943,15 @@ func (s *ShowDataSkewStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowDataSkewStatement() (localctx IShowDataSkewStatementContext) { +func (p *StarRocksSQLParser) ShowDataSkewStatement() (localctx IShowDataSkewStatementContext) { localctx = NewShowDataSkewStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 542, DorisSQLParserRULE_showDataSkewStatement) + p.EnterRule(localctx, 542, StarRocksSQLParserRULE_showDataSkewStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4797) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77959,7 +77959,7 @@ func (p *DorisSQLParser) ShowDataSkewStatement() (localctx IShowDataSkewStatemen } { p.SetState(4798) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77967,7 +77967,7 @@ func (p *DorisSQLParser) ShowDataSkewStatement() (localctx IShowDataSkewStatemen } { p.SetState(4799) - p.Match(DorisSQLParserSKEW) + p.Match(StarRocksSQLParserSKEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77975,7 +77975,7 @@ func (p *DorisSQLParser) ShowDataSkewStatement() (localctx IShowDataSkewStatemen } { p.SetState(4800) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -77992,7 +77992,7 @@ func (p *DorisSQLParser) ShowDataSkewStatement() (localctx IShowDataSkewStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(4802) p.PartitionNames() @@ -78037,13 +78037,13 @@ type ShowDataTypesStatementContext struct { func NewEmptyShowDataTypesStatementContext() *ShowDataTypesStatementContext { var p = new(ShowDataTypesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataTypesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataTypesStatement return p } func InitEmptyShowDataTypesStatementContext(p *ShowDataTypesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataTypesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataTypesStatement } func (*ShowDataTypesStatementContext) IsShowDataTypesStatementContext() {} @@ -78054,7 +78054,7 @@ func NewShowDataTypesStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDataTypesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataTypesStatement return p } @@ -78062,15 +78062,15 @@ func NewShowDataTypesStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *ShowDataTypesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDataTypesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDataTypesStatementContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *ShowDataTypesStatementContext) TYPES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTYPES, 0) + return s.GetToken(StarRocksSQLParserTYPES, 0) } func (s *ShowDataTypesStatementContext) GetRuleContext() antlr.RuleContext { @@ -78082,20 +78082,20 @@ func (s *ShowDataTypesStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowDataTypesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDataTypesStatement(s) } } func (s *ShowDataTypesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDataTypesStatement(s) } } func (s *ShowDataTypesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDataTypesStatement(s) default: @@ -78103,13 +78103,13 @@ func (s *ShowDataTypesStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowDataTypesStatement() (localctx IShowDataTypesStatementContext) { +func (p *StarRocksSQLParser) ShowDataTypesStatement() (localctx IShowDataTypesStatementContext) { localctx = NewShowDataTypesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 544, DorisSQLParserRULE_showDataTypesStatement) + p.EnterRule(localctx, 544, StarRocksSQLParserRULE_showDataTypesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4805) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78117,7 +78117,7 @@ func (p *DorisSQLParser) ShowDataTypesStatement() (localctx IShowDataTypesStatem } { p.SetState(4806) - p.Match(DorisSQLParserDATA) + p.Match(StarRocksSQLParserDATA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78125,7 +78125,7 @@ func (p *DorisSQLParser) ShowDataTypesStatement() (localctx IShowDataTypesStatem } { p.SetState(4807) - p.Match(DorisSQLParserTYPES) + p.Match(StarRocksSQLParserTYPES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78171,13 +78171,13 @@ type ShowSyncJobStatementContext struct { func NewEmptyShowSyncJobStatementContext() *ShowSyncJobStatementContext { var p = new(ShowSyncJobStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSyncJobStatement + p.RuleIndex = StarRocksSQLParserRULE_showSyncJobStatement return p } func InitEmptyShowSyncJobStatementContext(p *ShowSyncJobStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSyncJobStatement + p.RuleIndex = StarRocksSQLParserRULE_showSyncJobStatement } func (*ShowSyncJobStatementContext) IsShowSyncJobStatementContext() {} @@ -78188,7 +78188,7 @@ func NewShowSyncJobStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showSyncJobStatement + p.RuleIndex = StarRocksSQLParserRULE_showSyncJobStatement return p } @@ -78196,19 +78196,19 @@ func NewShowSyncJobStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowSyncJobStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowSyncJobStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowSyncJobStatementContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *ShowSyncJobStatementContext) JOB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOB, 0) + return s.GetToken(StarRocksSQLParserJOB, 0) } func (s *ShowSyncJobStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowSyncJobStatementContext) QualifiedName() IQualifiedNameContext { @@ -78236,20 +78236,20 @@ func (s *ShowSyncJobStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowSyncJobStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowSyncJobStatement(s) } } func (s *ShowSyncJobStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowSyncJobStatement(s) } } func (s *ShowSyncJobStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowSyncJobStatement(s) default: @@ -78257,15 +78257,15 @@ func (s *ShowSyncJobStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowSyncJobStatement() (localctx IShowSyncJobStatementContext) { +func (p *StarRocksSQLParser) ShowSyncJobStatement() (localctx IShowSyncJobStatementContext) { localctx = NewShowSyncJobStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 546, DorisSQLParserRULE_showSyncJobStatement) + p.EnterRule(localctx, 546, StarRocksSQLParserRULE_showSyncJobStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4809) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78273,7 +78273,7 @@ func (p *DorisSQLParser) ShowSyncJobStatement() (localctx IShowSyncJobStatementC } { p.SetState(4810) - p.Match(DorisSQLParserSYNC) + p.Match(StarRocksSQLParserSYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78281,7 +78281,7 @@ func (p *DorisSQLParser) ShowSyncJobStatement() (localctx IShowSyncJobStatementC } { p.SetState(4811) - p.Match(DorisSQLParserJOB) + p.Match(StarRocksSQLParserJOB) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78294,10 +78294,10 @@ func (p *DorisSQLParser) ShowSyncJobStatement() (localctx IShowSyncJobStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM { + if _la == StarRocksSQLParserFROM { { p.SetState(4812) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78353,13 +78353,13 @@ type ShowPolicyStatementContext struct { func NewEmptyShowPolicyStatementContext() *ShowPolicyStatementContext { var p = new(ShowPolicyStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPolicyStatement + p.RuleIndex = StarRocksSQLParserRULE_showPolicyStatement return p } func InitEmptyShowPolicyStatementContext(p *ShowPolicyStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPolicyStatement + p.RuleIndex = StarRocksSQLParserRULE_showPolicyStatement } func (*ShowPolicyStatementContext) IsShowPolicyStatementContext() {} @@ -78370,7 +78370,7 @@ func NewShowPolicyStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPolicyStatement + p.RuleIndex = StarRocksSQLParserRULE_showPolicyStatement return p } @@ -78378,23 +78378,23 @@ func NewShowPolicyStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ShowPolicyStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowPolicyStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPolicyStatementContext) ROW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROW, 0) + return s.GetToken(StarRocksSQLParserROW, 0) } func (s *ShowPolicyStatementContext) POLICY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPOLICY, 0) + return s.GetToken(StarRocksSQLParserPOLICY, 0) } func (s *ShowPolicyStatementContext) AllFOR() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserFOR) + return s.GetTokens(StarRocksSQLParserFOR) } func (s *ShowPolicyStatementContext) FOR(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, i) + return s.GetToken(StarRocksSQLParserFOR, i) } func (s *ShowPolicyStatementContext) User() IUserContext { @@ -78414,7 +78414,7 @@ func (s *ShowPolicyStatementContext) User() IUserContext { } func (s *ShowPolicyStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *ShowPolicyStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -78434,7 +78434,7 @@ func (s *ShowPolicyStatementContext) IdentifierOrString() IIdentifierOrStringCon } func (s *ShowPolicyStatementContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *ShowPolicyStatementContext) GetRuleContext() antlr.RuleContext { @@ -78446,20 +78446,20 @@ func (s *ShowPolicyStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowPolicyStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPolicyStatement(s) } } func (s *ShowPolicyStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPolicyStatement(s) } } func (s *ShowPolicyStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPolicyStatement(s) default: @@ -78467,9 +78467,9 @@ func (s *ShowPolicyStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementContext) { +func (p *StarRocksSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementContext) { localctx = NewShowPolicyStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 548, DorisSQLParserRULE_showPolicyStatement) + p.EnterRule(localctx, 548, StarRocksSQLParserRULE_showPolicyStatement) var _la int p.SetState(4831) @@ -78483,7 +78483,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon p.EnterOuterAlt(localctx, 1) { p.SetState(4816) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78491,7 +78491,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon } { p.SetState(4817) - p.Match(DorisSQLParserROW) + p.Match(StarRocksSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78499,7 +78499,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon } { p.SetState(4818) - p.Match(DorisSQLParserPOLICY) + p.Match(StarRocksSQLParserPOLICY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78511,7 +78511,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 506, p.GetParserRuleContext()) == 1 { { p.SetState(4819) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78532,10 +78532,10 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(4823) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78543,7 +78543,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon } { p.SetState(4824) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78560,7 +78560,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon p.EnterOuterAlt(localctx, 2) { p.SetState(4828) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78568,7 +78568,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon } { p.SetState(4829) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78576,7 +78576,7 @@ func (p *DorisSQLParser) ShowPolicyStatement() (localctx IShowPolicyStatementCon } { p.SetState(4830) - p.Match(DorisSQLParserPOLICY) + p.Match(StarRocksSQLParserPOLICY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78627,13 +78627,13 @@ type ShowSqlBlockRuleStatementContext struct { func NewEmptyShowSqlBlockRuleStatementContext() *ShowSqlBlockRuleStatementContext { var p = new(ShowSqlBlockRuleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSqlBlockRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_showSqlBlockRuleStatement return p } func InitEmptyShowSqlBlockRuleStatementContext(p *ShowSqlBlockRuleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSqlBlockRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_showSqlBlockRuleStatement } func (*ShowSqlBlockRuleStatementContext) IsShowSqlBlockRuleStatementContext() {} @@ -78644,7 +78644,7 @@ func NewShowSqlBlockRuleStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showSqlBlockRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_showSqlBlockRuleStatement return p } @@ -78652,23 +78652,23 @@ func NewShowSqlBlockRuleStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowSqlBlockRuleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowSqlBlockRuleStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowSqlBlockRuleStatementContext) SQL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSQL, 0) + return s.GetToken(StarRocksSQLParserSQL, 0) } func (s *ShowSqlBlockRuleStatementContext) BLOCK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLOCK, 0) + return s.GetToken(StarRocksSQLParserBLOCK, 0) } func (s *ShowSqlBlockRuleStatementContext) RULE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULE, 0) + return s.GetToken(StarRocksSQLParserRULE, 0) } func (s *ShowSqlBlockRuleStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowSqlBlockRuleStatementContext) Identifier() IIdentifierContext { @@ -78696,20 +78696,20 @@ func (s *ShowSqlBlockRuleStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowSqlBlockRuleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowSqlBlockRuleStatement(s) } } func (s *ShowSqlBlockRuleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowSqlBlockRuleStatement(s) } } func (s *ShowSqlBlockRuleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowSqlBlockRuleStatement(s) default: @@ -78717,15 +78717,15 @@ func (s *ShowSqlBlockRuleStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowSqlBlockRuleStatement() (localctx IShowSqlBlockRuleStatementContext) { +func (p *StarRocksSQLParser) ShowSqlBlockRuleStatement() (localctx IShowSqlBlockRuleStatementContext) { localctx = NewShowSqlBlockRuleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 550, DorisSQLParserRULE_showSqlBlockRuleStatement) + p.EnterRule(localctx, 550, StarRocksSQLParserRULE_showSqlBlockRuleStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4833) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78733,7 +78733,7 @@ func (p *DorisSQLParser) ShowSqlBlockRuleStatement() (localctx IShowSqlBlockRule } { p.SetState(4834) - p.Match(DorisSQLParserSQL) + p.Match(StarRocksSQLParserSQL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78741,7 +78741,7 @@ func (p *DorisSQLParser) ShowSqlBlockRuleStatement() (localctx IShowSqlBlockRule } { p.SetState(4835) - p.Match(DorisSQLParserBLOCK) + p.Match(StarRocksSQLParserBLOCK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78749,7 +78749,7 @@ func (p *DorisSQLParser) ShowSqlBlockRuleStatement() (localctx IShowSqlBlockRule } { p.SetState(4836) - p.Match(DorisSQLParserRULE) + p.Match(StarRocksSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78762,10 +78762,10 @@ func (p *DorisSQLParser) ShowSqlBlockRuleStatement() (localctx IShowSqlBlockRule } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(4837) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78827,13 +78827,13 @@ type ShowEncryptKeysStatementContext struct { func NewEmptyShowEncryptKeysStatementContext() *ShowEncryptKeysStatementContext { var p = new(ShowEncryptKeysStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showEncryptKeysStatement + p.RuleIndex = StarRocksSQLParserRULE_showEncryptKeysStatement return p } func InitEmptyShowEncryptKeysStatementContext(p *ShowEncryptKeysStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showEncryptKeysStatement + p.RuleIndex = StarRocksSQLParserRULE_showEncryptKeysStatement } func (*ShowEncryptKeysStatementContext) IsShowEncryptKeysStatementContext() {} @@ -78844,7 +78844,7 @@ func NewShowEncryptKeysStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showEncryptKeysStatement + p.RuleIndex = StarRocksSQLParserRULE_showEncryptKeysStatement return p } @@ -78856,15 +78856,15 @@ func (s *ShowEncryptKeysStatementContext) GetPattern() IStringContext { return s func (s *ShowEncryptKeysStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowEncryptKeysStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowEncryptKeysStatementContext) ENCRYPT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENCRYPT, 0) + return s.GetToken(StarRocksSQLParserENCRYPT, 0) } func (s *ShowEncryptKeysStatementContext) KEYS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserKEYS, 0) + return s.GetToken(StarRocksSQLParserKEYS, 0) } func (s *ShowEncryptKeysStatementContext) QualifiedName() IQualifiedNameContext { @@ -78884,15 +78884,15 @@ func (s *ShowEncryptKeysStatementContext) QualifiedName() IQualifiedNameContext } func (s *ShowEncryptKeysStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowEncryptKeysStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowEncryptKeysStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowEncryptKeysStatementContext) String_() IStringContext { @@ -78920,20 +78920,20 @@ func (s *ShowEncryptKeysStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowEncryptKeysStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowEncryptKeysStatement(s) } } func (s *ShowEncryptKeysStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowEncryptKeysStatement(s) } } func (s *ShowEncryptKeysStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowEncryptKeysStatement(s) default: @@ -78941,15 +78941,15 @@ func (s *ShowEncryptKeysStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowEncryptKeysStatement() (localctx IShowEncryptKeysStatementContext) { +func (p *StarRocksSQLParser) ShowEncryptKeysStatement() (localctx IShowEncryptKeysStatementContext) { localctx = NewShowEncryptKeysStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 552, DorisSQLParserRULE_showEncryptKeysStatement) + p.EnterRule(localctx, 552, StarRocksSQLParserRULE_showEncryptKeysStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4841) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78957,7 +78957,7 @@ func (p *DorisSQLParser) ShowEncryptKeysStatement() (localctx IShowEncryptKeysSt } { p.SetState(4842) - p.Match(DorisSQLParserENCRYPT) + p.Match(StarRocksSQLParserENCRYPT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78965,7 +78965,7 @@ func (p *DorisSQLParser) ShowEncryptKeysStatement() (localctx IShowEncryptKeysSt } { p.SetState(4843) - p.Match(DorisSQLParserKEYS) + p.Match(StarRocksSQLParserKEYS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -78978,12 +78978,12 @@ func (p *DorisSQLParser) ShowEncryptKeysStatement() (localctx IShowEncryptKeysSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(4844) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -79003,10 +79003,10 @@ func (p *DorisSQLParser) ShowEncryptKeysStatement() (localctx IShowEncryptKeysSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(4848) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79061,13 +79061,13 @@ type ShowCreateLoadStatementContext struct { func NewEmptyShowCreateLoadStatementContext() *ShowCreateLoadStatementContext { var p = new(ShowCreateLoadStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateLoadStatement return p } func InitEmptyShowCreateLoadStatementContext(p *ShowCreateLoadStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateLoadStatement } func (*ShowCreateLoadStatementContext) IsShowCreateLoadStatementContext() {} @@ -79078,7 +79078,7 @@ func NewShowCreateLoadStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateLoadStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateLoadStatement return p } @@ -79086,19 +79086,19 @@ func NewShowCreateLoadStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowCreateLoadStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowCreateLoadStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateLoadStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateLoadStatementContext) LOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOAD, 0) + return s.GetToken(StarRocksSQLParserLOAD, 0) } func (s *ShowCreateLoadStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowCreateLoadStatementContext) Identifier() IIdentifierContext { @@ -79126,20 +79126,20 @@ func (s *ShowCreateLoadStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowCreateLoadStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateLoadStatement(s) } } func (s *ShowCreateLoadStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateLoadStatement(s) } } func (s *ShowCreateLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateLoadStatement(s) default: @@ -79147,13 +79147,13 @@ func (s *ShowCreateLoadStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowCreateLoadStatement() (localctx IShowCreateLoadStatementContext) { +func (p *StarRocksSQLParser) ShowCreateLoadStatement() (localctx IShowCreateLoadStatementContext) { localctx = NewShowCreateLoadStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 554, DorisSQLParserRULE_showCreateLoadStatement) + p.EnterRule(localctx, 554, StarRocksSQLParserRULE_showCreateLoadStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4852) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79161,7 +79161,7 @@ func (p *DorisSQLParser) ShowCreateLoadStatement() (localctx IShowCreateLoadStat } { p.SetState(4853) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79169,7 +79169,7 @@ func (p *DorisSQLParser) ShowCreateLoadStatement() (localctx IShowCreateLoadStat } { p.SetState(4854) - p.Match(DorisSQLParserLOAD) + p.Match(StarRocksSQLParserLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79177,7 +79177,7 @@ func (p *DorisSQLParser) ShowCreateLoadStatement() (localctx IShowCreateLoadStat } { p.SetState(4855) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79226,13 +79226,13 @@ type ShowCreateRepositoryStatementContext struct { func NewEmptyShowCreateRepositoryStatementContext() *ShowCreateRepositoryStatementContext { var p = new(ShowCreateRepositoryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateRepositoryStatement return p } func InitEmptyShowCreateRepositoryStatementContext(p *ShowCreateRepositoryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateRepositoryStatement } func (*ShowCreateRepositoryStatementContext) IsShowCreateRepositoryStatementContext() {} @@ -79243,7 +79243,7 @@ func NewShowCreateRepositoryStatementContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateRepositoryStatement return p } @@ -79251,15 +79251,15 @@ func NewShowCreateRepositoryStatementContext(parser antlr.Parser, parent antlr.P func (s *ShowCreateRepositoryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowCreateRepositoryStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateRepositoryStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateRepositoryStatementContext) REPOSITORY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORY, 0) + return s.GetToken(StarRocksSQLParserREPOSITORY, 0) } func (s *ShowCreateRepositoryStatementContext) Identifier() IIdentifierContext { @@ -79287,20 +79287,20 @@ func (s *ShowCreateRepositoryStatementContext) ToStringTree(ruleNames []string, } func (s *ShowCreateRepositoryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateRepositoryStatement(s) } } func (s *ShowCreateRepositoryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateRepositoryStatement(s) } } func (s *ShowCreateRepositoryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateRepositoryStatement(s) default: @@ -79308,13 +79308,13 @@ func (s *ShowCreateRepositoryStatementContext) Accept(visitor antlr.ParseTreeVis } } -func (p *DorisSQLParser) ShowCreateRepositoryStatement() (localctx IShowCreateRepositoryStatementContext) { +func (p *StarRocksSQLParser) ShowCreateRepositoryStatement() (localctx IShowCreateRepositoryStatementContext) { localctx = NewShowCreateRepositoryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 556, DorisSQLParserRULE_showCreateRepositoryStatement) + p.EnterRule(localctx, 556, StarRocksSQLParserRULE_showCreateRepositoryStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4858) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79322,7 +79322,7 @@ func (p *DorisSQLParser) ShowCreateRepositoryStatement() (localctx IShowCreateRe } { p.SetState(4859) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79330,7 +79330,7 @@ func (p *DorisSQLParser) ShowCreateRepositoryStatement() (localctx IShowCreateRe } { p.SetState(4860) - p.Match(DorisSQLParserREPOSITORY) + p.Match(StarRocksSQLParserREPOSITORY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79378,13 +79378,13 @@ type ShowLastInsertStatementContext struct { func NewEmptyShowLastInsertStatementContext() *ShowLastInsertStatementContext { var p = new(ShowLastInsertStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLastInsertStatement + p.RuleIndex = StarRocksSQLParserRULE_showLastInsertStatement return p } func InitEmptyShowLastInsertStatementContext(p *ShowLastInsertStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showLastInsertStatement + p.RuleIndex = StarRocksSQLParserRULE_showLastInsertStatement } func (*ShowLastInsertStatementContext) IsShowLastInsertStatementContext() {} @@ -79395,7 +79395,7 @@ func NewShowLastInsertStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showLastInsertStatement + p.RuleIndex = StarRocksSQLParserRULE_showLastInsertStatement return p } @@ -79403,15 +79403,15 @@ func NewShowLastInsertStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowLastInsertStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowLastInsertStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowLastInsertStatementContext) LAST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLAST, 0) + return s.GetToken(StarRocksSQLParserLAST, 0) } func (s *ShowLastInsertStatementContext) INSERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINSERT, 0) + return s.GetToken(StarRocksSQLParserINSERT, 0) } func (s *ShowLastInsertStatementContext) GetRuleContext() antlr.RuleContext { @@ -79423,20 +79423,20 @@ func (s *ShowLastInsertStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowLastInsertStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowLastInsertStatement(s) } } func (s *ShowLastInsertStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowLastInsertStatement(s) } } func (s *ShowLastInsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowLastInsertStatement(s) default: @@ -79444,13 +79444,13 @@ func (s *ShowLastInsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowLastInsertStatement() (localctx IShowLastInsertStatementContext) { +func (p *StarRocksSQLParser) ShowLastInsertStatement() (localctx IShowLastInsertStatementContext) { localctx = NewShowLastInsertStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 558, DorisSQLParserRULE_showLastInsertStatement) + p.EnterRule(localctx, 558, StarRocksSQLParserRULE_showLastInsertStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4863) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79458,7 +79458,7 @@ func (p *DorisSQLParser) ShowLastInsertStatement() (localctx IShowLastInsertStat } { p.SetState(4864) - p.Match(DorisSQLParserLAST) + p.Match(StarRocksSQLParserLAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79466,7 +79466,7 @@ func (p *DorisSQLParser) ShowLastInsertStatement() (localctx IShowLastInsertStat } { p.SetState(4865) - p.Match(DorisSQLParserINSERT) + p.Match(StarRocksSQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79510,13 +79510,13 @@ type ShowTableIdStatementContext struct { func NewEmptyShowTableIdStatementContext() *ShowTableIdStatementContext { var p = new(ShowTableIdStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableIdStatement return p } func InitEmptyShowTableIdStatementContext(p *ShowTableIdStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableIdStatement } func (*ShowTableIdStatementContext) IsShowTableIdStatementContext() {} @@ -79527,7 +79527,7 @@ func NewShowTableIdStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTableIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableIdStatement return p } @@ -79535,15 +79535,15 @@ func NewShowTableIdStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowTableIdStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowTableIdStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTableIdStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *ShowTableIdStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ShowTableIdStatementContext) GetRuleContext() antlr.RuleContext { @@ -79555,20 +79555,20 @@ func (s *ShowTableIdStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowTableIdStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTableIdStatement(s) } } func (s *ShowTableIdStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTableIdStatement(s) } } func (s *ShowTableIdStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTableIdStatement(s) default: @@ -79576,13 +79576,13 @@ func (s *ShowTableIdStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowTableIdStatement() (localctx IShowTableIdStatementContext) { +func (p *StarRocksSQLParser) ShowTableIdStatement() (localctx IShowTableIdStatementContext) { localctx = NewShowTableIdStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 560, DorisSQLParserRULE_showTableIdStatement) + p.EnterRule(localctx, 560, StarRocksSQLParserRULE_showTableIdStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4867) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79590,7 +79590,7 @@ func (p *DorisSQLParser) ShowTableIdStatement() (localctx IShowTableIdStatementC } { p.SetState(4868) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79598,7 +79598,7 @@ func (p *DorisSQLParser) ShowTableIdStatement() (localctx IShowTableIdStatementC } { p.SetState(4869) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79642,13 +79642,13 @@ type ShowDatabaseIdStatementContext struct { func NewEmptyShowDatabaseIdStatementContext() *ShowDatabaseIdStatementContext { var p = new(ShowDatabaseIdStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDatabaseIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showDatabaseIdStatement return p } func InitEmptyShowDatabaseIdStatementContext(p *ShowDatabaseIdStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDatabaseIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showDatabaseIdStatement } func (*ShowDatabaseIdStatementContext) IsShowDatabaseIdStatementContext() {} @@ -79659,7 +79659,7 @@ func NewShowDatabaseIdStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDatabaseIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showDatabaseIdStatement return p } @@ -79667,15 +79667,15 @@ func NewShowDatabaseIdStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowDatabaseIdStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDatabaseIdStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDatabaseIdStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *ShowDatabaseIdStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ShowDatabaseIdStatementContext) GetRuleContext() antlr.RuleContext { @@ -79687,20 +79687,20 @@ func (s *ShowDatabaseIdStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowDatabaseIdStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDatabaseIdStatement(s) } } func (s *ShowDatabaseIdStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDatabaseIdStatement(s) } } func (s *ShowDatabaseIdStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDatabaseIdStatement(s) default: @@ -79708,13 +79708,13 @@ func (s *ShowDatabaseIdStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowDatabaseIdStatement() (localctx IShowDatabaseIdStatementContext) { +func (p *StarRocksSQLParser) ShowDatabaseIdStatement() (localctx IShowDatabaseIdStatementContext) { localctx = NewShowDatabaseIdStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 562, DorisSQLParserRULE_showDatabaseIdStatement) + p.EnterRule(localctx, 562, StarRocksSQLParserRULE_showDatabaseIdStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4871) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79722,7 +79722,7 @@ func (p *DorisSQLParser) ShowDatabaseIdStatement() (localctx IShowDatabaseIdStat } { p.SetState(4872) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79730,7 +79730,7 @@ func (p *DorisSQLParser) ShowDatabaseIdStatement() (localctx IShowDatabaseIdStat } { p.SetState(4873) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79774,13 +79774,13 @@ type ShowPartitionIdStatementContext struct { func NewEmptyShowPartitionIdStatementContext() *ShowPartitionIdStatementContext { var p = new(ShowPartitionIdStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPartitionIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showPartitionIdStatement return p } func InitEmptyShowPartitionIdStatementContext(p *ShowPartitionIdStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPartitionIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showPartitionIdStatement } func (*ShowPartitionIdStatementContext) IsShowPartitionIdStatementContext() {} @@ -79791,7 +79791,7 @@ func NewShowPartitionIdStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPartitionIdStatement + p.RuleIndex = StarRocksSQLParserRULE_showPartitionIdStatement return p } @@ -79799,15 +79799,15 @@ func NewShowPartitionIdStatementContext(parser antlr.Parser, parent antlr.Parser func (s *ShowPartitionIdStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowPartitionIdStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPartitionIdStatementContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *ShowPartitionIdStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ShowPartitionIdStatementContext) GetRuleContext() antlr.RuleContext { @@ -79819,20 +79819,20 @@ func (s *ShowPartitionIdStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowPartitionIdStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPartitionIdStatement(s) } } func (s *ShowPartitionIdStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPartitionIdStatement(s) } } func (s *ShowPartitionIdStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPartitionIdStatement(s) default: @@ -79840,13 +79840,13 @@ func (s *ShowPartitionIdStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowPartitionIdStatement() (localctx IShowPartitionIdStatementContext) { +func (p *StarRocksSQLParser) ShowPartitionIdStatement() (localctx IShowPartitionIdStatementContext) { localctx = NewShowPartitionIdStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 564, DorisSQLParserRULE_showPartitionIdStatement) + p.EnterRule(localctx, 564, StarRocksSQLParserRULE_showPartitionIdStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4875) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79854,7 +79854,7 @@ func (p *DorisSQLParser) ShowPartitionIdStatement() (localctx IShowPartitionIdSt } { p.SetState(4876) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79862,7 +79862,7 @@ func (p *DorisSQLParser) ShowPartitionIdStatement() (localctx IShowPartitionIdSt } { p.SetState(4877) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -79907,13 +79907,13 @@ type ShowTableStatsStatementContext struct { func NewEmptyShowTableStatsStatementContext() *ShowTableStatsStatementContext { var p = new(ShowTableStatsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatsStatement return p } func InitEmptyShowTableStatsStatementContext(p *ShowTableStatsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTableStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatsStatement } func (*ShowTableStatsStatementContext) IsShowTableStatsStatementContext() {} @@ -79924,7 +79924,7 @@ func NewShowTableStatsStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTableStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showTableStatsStatement return p } @@ -79932,15 +79932,15 @@ func NewShowTableStatsStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowTableStatsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowTableStatsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTableStatsStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *ShowTableStatsStatementContext) STATS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATS, 0) + return s.GetToken(StarRocksSQLParserSTATS, 0) } func (s *ShowTableStatsStatementContext) QualifiedName() IQualifiedNameContext { @@ -79968,20 +79968,20 @@ func (s *ShowTableStatsStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowTableStatsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTableStatsStatement(s) } } func (s *ShowTableStatsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTableStatsStatement(s) } } func (s *ShowTableStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTableStatsStatement(s) default: @@ -79989,13 +79989,13 @@ func (s *ShowTableStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowTableStatsStatement() (localctx IShowTableStatsStatementContext) { +func (p *StarRocksSQLParser) ShowTableStatsStatement() (localctx IShowTableStatsStatementContext) { localctx = NewShowTableStatsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 566, DorisSQLParserRULE_showTableStatsStatement) + p.EnterRule(localctx, 566, StarRocksSQLParserRULE_showTableStatsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4879) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80003,7 +80003,7 @@ func (p *DorisSQLParser) ShowTableStatsStatement() (localctx IShowTableStatsStat } { p.SetState(4880) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80011,7 +80011,7 @@ func (p *DorisSQLParser) ShowTableStatsStatement() (localctx IShowTableStatsStat } { p.SetState(4881) - p.Match(DorisSQLParserSTATS) + p.Match(StarRocksSQLParserSTATS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80063,13 +80063,13 @@ type ShowColumnStatsStatementContext struct { func NewEmptyShowColumnStatsStatementContext() *ShowColumnStatsStatementContext { var p = new(ShowColumnStatsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showColumnStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showColumnStatsStatement return p } func InitEmptyShowColumnStatsStatementContext(p *ShowColumnStatsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showColumnStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showColumnStatsStatement } func (*ShowColumnStatsStatementContext) IsShowColumnStatsStatementContext() {} @@ -80080,7 +80080,7 @@ func NewShowColumnStatsStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showColumnStatsStatement + p.RuleIndex = StarRocksSQLParserRULE_showColumnStatsStatement return p } @@ -80088,15 +80088,15 @@ func NewShowColumnStatsStatementContext(parser antlr.Parser, parent antlr.Parser func (s *ShowColumnStatsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowColumnStatsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowColumnStatsStatementContext) COLUMN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMN, 0) + return s.GetToken(StarRocksSQLParserCOLUMN, 0) } func (s *ShowColumnStatsStatementContext) STATS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATS, 0) + return s.GetToken(StarRocksSQLParserSTATS, 0) } func (s *ShowColumnStatsStatementContext) QualifiedName() IQualifiedNameContext { @@ -80116,7 +80116,7 @@ func (s *ShowColumnStatsStatementContext) QualifiedName() IQualifiedNameContext } func (s *ShowColumnStatsStatementContext) CACHED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCACHED, 0) + return s.GetToken(StarRocksSQLParserCACHED, 0) } func (s *ShowColumnStatsStatementContext) AllIdentifier() []IIdentifierContext { @@ -80169,20 +80169,20 @@ func (s *ShowColumnStatsStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowColumnStatsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowColumnStatsStatement(s) } } func (s *ShowColumnStatsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowColumnStatsStatement(s) } } func (s *ShowColumnStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowColumnStatsStatement(s) default: @@ -80190,15 +80190,15 @@ func (s *ShowColumnStatsStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsStatementContext) { +func (p *StarRocksSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsStatementContext) { localctx = NewShowColumnStatsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 568, DorisSQLParserRULE_showColumnStatsStatement) + p.EnterRule(localctx, 568, StarRocksSQLParserRULE_showColumnStatsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4884) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80206,7 +80206,7 @@ func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsSt } { p.SetState(4885) - p.Match(DorisSQLParserCOLUMN) + p.Match(StarRocksSQLParserCOLUMN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80219,10 +80219,10 @@ func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCACHED { + if _la == StarRocksSQLParserCACHED { { p.SetState(4886) - p.Match(DorisSQLParserCACHED) + p.Match(StarRocksSQLParserCACHED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80232,7 +80232,7 @@ func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsSt } { p.SetState(4889) - p.Match(DorisSQLParserSTATS) + p.Match(StarRocksSQLParserSTATS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80249,10 +80249,10 @@ func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(4891) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80269,10 +80269,10 @@ func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsSt } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4893) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80292,7 +80292,7 @@ func (p *DorisSQLParser) ShowColumnStatsStatement() (localctx IShowColumnStatsSt } { p.SetState(4900) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80343,13 +80343,13 @@ type ShowConvertLightSchemaChangeStatementContext struct { func NewEmptyShowConvertLightSchemaChangeStatementContext() *ShowConvertLightSchemaChangeStatementContext { var p = new(ShowConvertLightSchemaChangeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showConvertLightSchemaChangeStatement + p.RuleIndex = StarRocksSQLParserRULE_showConvertLightSchemaChangeStatement return p } func InitEmptyShowConvertLightSchemaChangeStatementContext(p *ShowConvertLightSchemaChangeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showConvertLightSchemaChangeStatement + p.RuleIndex = StarRocksSQLParserRULE_showConvertLightSchemaChangeStatement } func (*ShowConvertLightSchemaChangeStatementContext) IsShowConvertLightSchemaChangeStatementContext() { @@ -80361,7 +80361,7 @@ func NewShowConvertLightSchemaChangeStatementContext(parser antlr.Parser, parent antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showConvertLightSchemaChangeStatement + p.RuleIndex = StarRocksSQLParserRULE_showConvertLightSchemaChangeStatement return p } @@ -80369,31 +80369,31 @@ func NewShowConvertLightSchemaChangeStatementContext(parser antlr.Parser, parent func (s *ShowConvertLightSchemaChangeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowConvertLightSchemaChangeStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) CONVERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONVERT, 0) + return s.GetToken(StarRocksSQLParserCONVERT, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) LIGHT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIGHT, 0) + return s.GetToken(StarRocksSQLParserLIGHT, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMA, 0) + return s.GetToken(StarRocksSQLParserSCHEMA, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) CHANGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHANGE, 0) + return s.GetToken(StarRocksSQLParserCHANGE, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) PROCESS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROCESS, 0) + return s.GetToken(StarRocksSQLParserPROCESS, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowConvertLightSchemaChangeStatementContext) QualifiedName() IQualifiedNameContext { @@ -80421,20 +80421,20 @@ func (s *ShowConvertLightSchemaChangeStatementContext) ToStringTree(ruleNames [] } func (s *ShowConvertLightSchemaChangeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowConvertLightSchemaChangeStatement(s) } } func (s *ShowConvertLightSchemaChangeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowConvertLightSchemaChangeStatement(s) } } func (s *ShowConvertLightSchemaChangeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowConvertLightSchemaChangeStatement(s) default: @@ -80442,13 +80442,13 @@ func (s *ShowConvertLightSchemaChangeStatementContext) Accept(visitor antlr.Pars } } -func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShowConvertLightSchemaChangeStatementContext) { +func (p *StarRocksSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShowConvertLightSchemaChangeStatementContext) { localctx = NewShowConvertLightSchemaChangeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 570, DorisSQLParserRULE_showConvertLightSchemaChangeStatement) + p.EnterRule(localctx, 570, StarRocksSQLParserRULE_showConvertLightSchemaChangeStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4904) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80456,7 +80456,7 @@ func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShow } { p.SetState(4905) - p.Match(DorisSQLParserCONVERT) + p.Match(StarRocksSQLParserCONVERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80464,7 +80464,7 @@ func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShow } { p.SetState(4906) - p.Match(DorisSQLParserLIGHT) + p.Match(StarRocksSQLParserLIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80472,7 +80472,7 @@ func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShow } { p.SetState(4907) - p.Match(DorisSQLParserSCHEMA) + p.Match(StarRocksSQLParserSCHEMA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80480,7 +80480,7 @@ func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShow } { p.SetState(4908) - p.Match(DorisSQLParserCHANGE) + p.Match(StarRocksSQLParserCHANGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80488,7 +80488,7 @@ func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShow } { p.SetState(4909) - p.Match(DorisSQLParserPROCESS) + p.Match(StarRocksSQLParserPROCESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80496,7 +80496,7 @@ func (p *DorisSQLParser) ShowConvertLightSchemaChangeStatement() (localctx IShow } { p.SetState(4910) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80550,13 +80550,13 @@ type ShowCatalogRecycleBinStatementContext struct { func NewEmptyShowCatalogRecycleBinStatementContext() *ShowCatalogRecycleBinStatementContext { var p = new(ShowCatalogRecycleBinStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCatalogRecycleBinStatement + p.RuleIndex = StarRocksSQLParserRULE_showCatalogRecycleBinStatement return p } func InitEmptyShowCatalogRecycleBinStatementContext(p *ShowCatalogRecycleBinStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCatalogRecycleBinStatement + p.RuleIndex = StarRocksSQLParserRULE_showCatalogRecycleBinStatement } func (*ShowCatalogRecycleBinStatementContext) IsShowCatalogRecycleBinStatementContext() {} @@ -80567,7 +80567,7 @@ func NewShowCatalogRecycleBinStatementContext(parser antlr.Parser, parent antlr. antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCatalogRecycleBinStatement + p.RuleIndex = StarRocksSQLParserRULE_showCatalogRecycleBinStatement return p } @@ -80575,31 +80575,31 @@ func NewShowCatalogRecycleBinStatementContext(parser antlr.Parser, parent antlr. func (s *ShowCatalogRecycleBinStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowCatalogRecycleBinStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCatalogRecycleBinStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *ShowCatalogRecycleBinStatementContext) RECYCLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRECYCLE, 0) + return s.GetToken(StarRocksSQLParserRECYCLE, 0) } func (s *ShowCatalogRecycleBinStatementContext) BIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBIN, 0) + return s.GetToken(StarRocksSQLParserBIN, 0) } func (s *ShowCatalogRecycleBinStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowCatalogRecycleBinStatementContext) NAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNAME, 0) + return s.GetToken(StarRocksSQLParserNAME, 0) } func (s *ShowCatalogRecycleBinStatementContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *ShowCatalogRecycleBinStatementContext) String_() IStringContext { @@ -80619,7 +80619,7 @@ func (s *ShowCatalogRecycleBinStatementContext) String_() IStringContext { } func (s *ShowCatalogRecycleBinStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowCatalogRecycleBinStatementContext) GetRuleContext() antlr.RuleContext { @@ -80631,20 +80631,20 @@ func (s *ShowCatalogRecycleBinStatementContext) ToStringTree(ruleNames []string, } func (s *ShowCatalogRecycleBinStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCatalogRecycleBinStatement(s) } } func (s *ShowCatalogRecycleBinStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCatalogRecycleBinStatement(s) } } func (s *ShowCatalogRecycleBinStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCatalogRecycleBinStatement(s) default: @@ -80652,15 +80652,15 @@ func (s *ShowCatalogRecycleBinStatementContext) Accept(visitor antlr.ParseTreeVi } } -func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalogRecycleBinStatementContext) { +func (p *StarRocksSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalogRecycleBinStatementContext) { localctx = NewShowCatalogRecycleBinStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 572, DorisSQLParserRULE_showCatalogRecycleBinStatement) + p.EnterRule(localctx, 572, StarRocksSQLParserRULE_showCatalogRecycleBinStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4913) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80668,7 +80668,7 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog } { p.SetState(4914) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80676,7 +80676,7 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog } { p.SetState(4915) - p.Match(DorisSQLParserRECYCLE) + p.Match(StarRocksSQLParserRECYCLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80684,7 +80684,7 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog } { p.SetState(4916) - p.Match(DorisSQLParserBIN) + p.Match(StarRocksSQLParserBIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80697,10 +80697,10 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(4917) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80708,7 +80708,7 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog } { p.SetState(4918) - p.Match(DorisSQLParserNAME) + p.Match(StarRocksSQLParserNAME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80721,10 +80721,10 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog } switch p.GetTokenStream().LA(1) { - case DorisSQLParserEQ: + case StarRocksSQLParserEQ: { p.SetState(4919) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80735,10 +80735,10 @@ func (p *DorisSQLParser) ShowCatalogRecycleBinStatement() (localctx IShowCatalog p.String_() } - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(4921) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80795,13 +80795,13 @@ type ShowTrashStatementContext struct { func NewEmptyShowTrashStatementContext() *ShowTrashStatementContext { var p = new(ShowTrashStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTrashStatement + p.RuleIndex = StarRocksSQLParserRULE_showTrashStatement return p } func InitEmptyShowTrashStatementContext(p *ShowTrashStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showTrashStatement + p.RuleIndex = StarRocksSQLParserRULE_showTrashStatement } func (*ShowTrashStatementContext) IsShowTrashStatementContext() {} @@ -80812,7 +80812,7 @@ func NewShowTrashStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showTrashStatement + p.RuleIndex = StarRocksSQLParserRULE_showTrashStatement return p } @@ -80820,15 +80820,15 @@ func NewShowTrashStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *ShowTrashStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowTrashStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowTrashStatementContext) TRASH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRASH, 0) + return s.GetToken(StarRocksSQLParserTRASH, 0) } func (s *ShowTrashStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *ShowTrashStatementContext) AllString_() []IStringContext { @@ -80881,20 +80881,20 @@ func (s *ShowTrashStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ShowTrashStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowTrashStatement(s) } } func (s *ShowTrashStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowTrashStatement(s) } } func (s *ShowTrashStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowTrashStatement(s) default: @@ -80902,15 +80902,15 @@ func (s *ShowTrashStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ShowTrashStatement() (localctx IShowTrashStatementContext) { +func (p *StarRocksSQLParser) ShowTrashStatement() (localctx IShowTrashStatementContext) { localctx = NewShowTrashStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 574, DorisSQLParserRULE_showTrashStatement) + p.EnterRule(localctx, 574, StarRocksSQLParserRULE_showTrashStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4927) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80918,7 +80918,7 @@ func (p *DorisSQLParser) ShowTrashStatement() (localctx IShowTrashStatementConte } { p.SetState(4928) - p.Match(DorisSQLParserTRASH) + p.Match(StarRocksSQLParserTRASH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80931,10 +80931,10 @@ func (p *DorisSQLParser) ShowTrashStatement() (localctx IShowTrashStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserON { + if _la == StarRocksSQLParserON { { p.SetState(4929) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80942,7 +80942,7 @@ func (p *DorisSQLParser) ShowTrashStatement() (localctx IShowTrashStatementConte } { p.SetState(4930) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80959,10 +80959,10 @@ func (p *DorisSQLParser) ShowTrashStatement() (localctx IShowTrashStatementConte } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(4932) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -80982,7 +80982,7 @@ func (p *DorisSQLParser) ShowTrashStatement() (localctx IShowTrashStatementConte } { p.SetState(4939) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81027,13 +81027,13 @@ type ShowMigrationsStatementContext struct { func NewEmptyShowMigrationsStatementContext() *ShowMigrationsStatementContext { var p = new(ShowMigrationsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showMigrationsStatement + p.RuleIndex = StarRocksSQLParserRULE_showMigrationsStatement return p } func InitEmptyShowMigrationsStatementContext(p *ShowMigrationsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showMigrationsStatement + p.RuleIndex = StarRocksSQLParserRULE_showMigrationsStatement } func (*ShowMigrationsStatementContext) IsShowMigrationsStatementContext() {} @@ -81044,7 +81044,7 @@ func NewShowMigrationsStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showMigrationsStatement + p.RuleIndex = StarRocksSQLParserRULE_showMigrationsStatement return p } @@ -81052,11 +81052,11 @@ func NewShowMigrationsStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *ShowMigrationsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowMigrationsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowMigrationsStatementContext) MIGRATIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMIGRATIONS, 0) + return s.GetToken(StarRocksSQLParserMIGRATIONS, 0) } func (s *ShowMigrationsStatementContext) GetRuleContext() antlr.RuleContext { @@ -81068,20 +81068,20 @@ func (s *ShowMigrationsStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowMigrationsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowMigrationsStatement(s) } } func (s *ShowMigrationsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowMigrationsStatement(s) } } func (s *ShowMigrationsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowMigrationsStatement(s) default: @@ -81089,13 +81089,13 @@ func (s *ShowMigrationsStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowMigrationsStatement() (localctx IShowMigrationsStatementContext) { +func (p *StarRocksSQLParser) ShowMigrationsStatement() (localctx IShowMigrationsStatementContext) { localctx = NewShowMigrationsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 576, DorisSQLParserRULE_showMigrationsStatement) + p.EnterRule(localctx, 576, StarRocksSQLParserRULE_showMigrationsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4943) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81103,7 +81103,7 @@ func (p *DorisSQLParser) ShowMigrationsStatement() (localctx IShowMigrationsStat } { p.SetState(4944) - p.Match(DorisSQLParserMIGRATIONS) + p.Match(StarRocksSQLParserMIGRATIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81147,13 +81147,13 @@ type ShowWorkloadGroupsStatementContext struct { func NewEmptyShowWorkloadGroupsStatementContext() *ShowWorkloadGroupsStatementContext { var p = new(ShowWorkloadGroupsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWorkloadGroupsStatement + p.RuleIndex = StarRocksSQLParserRULE_showWorkloadGroupsStatement return p } func InitEmptyShowWorkloadGroupsStatementContext(p *ShowWorkloadGroupsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWorkloadGroupsStatement + p.RuleIndex = StarRocksSQLParserRULE_showWorkloadGroupsStatement } func (*ShowWorkloadGroupsStatementContext) IsShowWorkloadGroupsStatementContext() {} @@ -81164,7 +81164,7 @@ func NewShowWorkloadGroupsStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showWorkloadGroupsStatement + p.RuleIndex = StarRocksSQLParserRULE_showWorkloadGroupsStatement return p } @@ -81172,15 +81172,15 @@ func NewShowWorkloadGroupsStatementContext(parser antlr.Parser, parent antlr.Par func (s *ShowWorkloadGroupsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowWorkloadGroupsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowWorkloadGroupsStatementContext) WORKLOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWORKLOAD, 0) + return s.GetToken(StarRocksSQLParserWORKLOAD, 0) } func (s *ShowWorkloadGroupsStatementContext) GROUPS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPS, 0) + return s.GetToken(StarRocksSQLParserGROUPS, 0) } func (s *ShowWorkloadGroupsStatementContext) GetRuleContext() antlr.RuleContext { @@ -81192,20 +81192,20 @@ func (s *ShowWorkloadGroupsStatementContext) ToStringTree(ruleNames []string, re } func (s *ShowWorkloadGroupsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowWorkloadGroupsStatement(s) } } func (s *ShowWorkloadGroupsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowWorkloadGroupsStatement(s) } } func (s *ShowWorkloadGroupsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowWorkloadGroupsStatement(s) default: @@ -81213,13 +81213,13 @@ func (s *ShowWorkloadGroupsStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) ShowWorkloadGroupsStatement() (localctx IShowWorkloadGroupsStatementContext) { +func (p *StarRocksSQLParser) ShowWorkloadGroupsStatement() (localctx IShowWorkloadGroupsStatementContext) { localctx = NewShowWorkloadGroupsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 578, DorisSQLParserRULE_showWorkloadGroupsStatement) + p.EnterRule(localctx, 578, StarRocksSQLParserRULE_showWorkloadGroupsStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4946) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81227,7 +81227,7 @@ func (p *DorisSQLParser) ShowWorkloadGroupsStatement() (localctx IShowWorkloadGr } { p.SetState(4947) - p.Match(DorisSQLParserWORKLOAD) + p.Match(StarRocksSQLParserWORKLOAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81235,7 +81235,7 @@ func (p *DorisSQLParser) ShowWorkloadGroupsStatement() (localctx IShowWorkloadGr } { p.SetState(4948) - p.Match(DorisSQLParserGROUPS) + p.Match(StarRocksSQLParserGROUPS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81281,13 +81281,13 @@ type ShowJobTaskStatementContext struct { func NewEmptyShowJobTaskStatementContext() *ShowJobTaskStatementContext { var p = new(ShowJobTaskStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showJobTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_showJobTaskStatement return p } func InitEmptyShowJobTaskStatementContext(p *ShowJobTaskStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showJobTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_showJobTaskStatement } func (*ShowJobTaskStatementContext) IsShowJobTaskStatementContext() {} @@ -81298,7 +81298,7 @@ func NewShowJobTaskStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showJobTaskStatement + p.RuleIndex = StarRocksSQLParserRULE_showJobTaskStatement return p } @@ -81306,19 +81306,19 @@ func NewShowJobTaskStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *ShowJobTaskStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowJobTaskStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowJobTaskStatementContext) JOB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOB, 0) + return s.GetToken(StarRocksSQLParserJOB, 0) } func (s *ShowJobTaskStatementContext) TASKS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTASKS, 0) + return s.GetToken(StarRocksSQLParserTASKS, 0) } func (s *ShowJobTaskStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowJobTaskStatementContext) Identifier() IIdentifierContext { @@ -81346,20 +81346,20 @@ func (s *ShowJobTaskStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowJobTaskStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowJobTaskStatement(s) } } func (s *ShowJobTaskStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowJobTaskStatement(s) } } func (s *ShowJobTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowJobTaskStatement(s) default: @@ -81367,13 +81367,13 @@ func (s *ShowJobTaskStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowJobTaskStatement() (localctx IShowJobTaskStatementContext) { +func (p *StarRocksSQLParser) ShowJobTaskStatement() (localctx IShowJobTaskStatementContext) { localctx = NewShowJobTaskStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 580, DorisSQLParserRULE_showJobTaskStatement) + p.EnterRule(localctx, 580, StarRocksSQLParserRULE_showJobTaskStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(4950) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81381,7 +81381,7 @@ func (p *DorisSQLParser) ShowJobTaskStatement() (localctx IShowJobTaskStatementC } { p.SetState(4951) - p.Match(DorisSQLParserJOB) + p.Match(StarRocksSQLParserJOB) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81389,7 +81389,7 @@ func (p *DorisSQLParser) ShowJobTaskStatement() (localctx IShowJobTaskStatementC } { p.SetState(4952) - p.Match(DorisSQLParserTASKS) + p.Match(StarRocksSQLParserTASKS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81397,7 +81397,7 @@ func (p *DorisSQLParser) ShowJobTaskStatement() (localctx IShowJobTaskStatementC } { p.SetState(4953) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81453,13 +81453,13 @@ type CreateUserStatementContext struct { func NewEmptyCreateUserStatementContext() *CreateUserStatementContext { var p = new(CreateUserStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createUserStatement + p.RuleIndex = StarRocksSQLParserRULE_createUserStatement return p } func InitEmptyCreateUserStatementContext(p *CreateUserStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createUserStatement + p.RuleIndex = StarRocksSQLParserRULE_createUserStatement } func (*CreateUserStatementContext) IsCreateUserStatementContext() {} @@ -81470,7 +81470,7 @@ func NewCreateUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createUserStatement + p.RuleIndex = StarRocksSQLParserRULE_createUserStatement return p } @@ -81478,11 +81478,11 @@ func NewCreateUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *CreateUserStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateUserStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateUserStatementContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *CreateUserStatementContext) User() IUserContext { @@ -81502,15 +81502,15 @@ func (s *CreateUserStatementContext) User() IUserContext { } func (s *CreateUserStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateUserStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateUserStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateUserStatementContext) AuthOption() IAuthOptionContext { @@ -81530,11 +81530,11 @@ func (s *CreateUserStatementContext) AuthOption() IAuthOptionContext { } func (s *CreateUserStatementContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *CreateUserStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *CreateUserStatementContext) RoleList() IRoleListContext { @@ -81578,20 +81578,20 @@ func (s *CreateUserStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *CreateUserStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateUserStatement(s) } } func (s *CreateUserStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateUserStatement(s) } } func (s *CreateUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateUserStatement(s) default: @@ -81599,15 +81599,15 @@ func (s *CreateUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementContext) { +func (p *StarRocksSQLParser) CreateUserStatement() (localctx ICreateUserStatementContext) { localctx = NewCreateUserStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 582, DorisSQLParserRULE_createUserStatement) + p.EnterRule(localctx, 582, StarRocksSQLParserRULE_createUserStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4956) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81615,7 +81615,7 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } { p.SetState(4957) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81628,10 +81628,10 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(4958) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81639,7 +81639,7 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } { p.SetState(4959) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81647,7 +81647,7 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } { p.SetState(4960) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81666,7 +81666,7 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIDENTIFIED { + if _la == StarRocksSQLParserIDENTIFIED { { p.SetState(4964) p.AuthOption() @@ -81680,10 +81680,10 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDEFAULT { + if _la == StarRocksSQLParserDEFAULT { { p.SetState(4967) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81691,7 +81691,7 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } { p.SetState(4968) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81710,7 +81710,7 @@ func (p *DorisSQLParser) CreateUserStatement() (localctx ICreateUserStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(4972) p.Properties() @@ -81757,13 +81757,13 @@ type DropUserStatementContext struct { func NewEmptyDropUserStatementContext() *DropUserStatementContext { var p = new(DropUserStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropUserStatement + p.RuleIndex = StarRocksSQLParserRULE_dropUserStatement return p } func InitEmptyDropUserStatementContext(p *DropUserStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropUserStatement + p.RuleIndex = StarRocksSQLParserRULE_dropUserStatement } func (*DropUserStatementContext) IsDropUserStatementContext() {} @@ -81774,7 +81774,7 @@ func NewDropUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropUserStatement + p.RuleIndex = StarRocksSQLParserRULE_dropUserStatement return p } @@ -81782,11 +81782,11 @@ func NewDropUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DropUserStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropUserStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropUserStatementContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *DropUserStatementContext) User() IUserContext { @@ -81806,11 +81806,11 @@ func (s *DropUserStatementContext) User() IUserContext { } func (s *DropUserStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropUserStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropUserStatementContext) GetRuleContext() antlr.RuleContext { @@ -81822,20 +81822,20 @@ func (s *DropUserStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropUserStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropUserStatement(s) } } func (s *DropUserStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropUserStatement(s) } } func (s *DropUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropUserStatement(s) default: @@ -81843,15 +81843,15 @@ func (s *DropUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropUserStatement() (localctx IDropUserStatementContext) { +func (p *StarRocksSQLParser) DropUserStatement() (localctx IDropUserStatementContext) { localctx = NewDropUserStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 584, DorisSQLParserRULE_dropUserStatement) + p.EnterRule(localctx, 584, StarRocksSQLParserRULE_dropUserStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(4975) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81859,7 +81859,7 @@ func (p *DorisSQLParser) DropUserStatement() (localctx IDropUserStatementContext } { p.SetState(4976) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81872,10 +81872,10 @@ func (p *DorisSQLParser) DropUserStatement() (localctx IDropUserStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(4977) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81883,7 +81883,7 @@ func (p *DorisSQLParser) DropUserStatement() (localctx IDropUserStatementContext } { p.SetState(4978) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -81943,13 +81943,13 @@ type AlterUserStatementContext struct { func NewEmptyAlterUserStatementContext() *AlterUserStatementContext { var p = new(AlterUserStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterUserStatement + p.RuleIndex = StarRocksSQLParserRULE_alterUserStatement return p } func InitEmptyAlterUserStatementContext(p *AlterUserStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterUserStatement + p.RuleIndex = StarRocksSQLParserRULE_alterUserStatement } func (*AlterUserStatementContext) IsAlterUserStatementContext() {} @@ -81960,7 +81960,7 @@ func NewAlterUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterUserStatement + p.RuleIndex = StarRocksSQLParserRULE_alterUserStatement return p } @@ -81968,11 +81968,11 @@ func NewAlterUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *AlterUserStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterUserStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterUserStatementContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *AlterUserStatementContext) User() IUserContext { @@ -82008,27 +82008,27 @@ func (s *AlterUserStatementContext) AuthOption() IAuthOptionContext { } func (s *AlterUserStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *AlterUserStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *AlterUserStatementContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *AlterUserStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *AlterUserStatementContext) NONE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNONE, 0) + return s.GetToken(StarRocksSQLParserNONE, 0) } func (s *AlterUserStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *AlterUserStatementContext) RoleList() IRoleListContext { @@ -82048,7 +82048,7 @@ func (s *AlterUserStatementContext) RoleList() IRoleListContext { } func (s *AlterUserStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterUserStatementContext) Properties() IPropertiesContext { @@ -82076,20 +82076,20 @@ func (s *AlterUserStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *AlterUserStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterUserStatement(s) } } func (s *AlterUserStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterUserStatement(s) } } func (s *AlterUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterUserStatement(s) default: @@ -82097,9 +82097,9 @@ func (s *AlterUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementContext) { +func (p *StarRocksSQLParser) AlterUserStatement() (localctx IAlterUserStatementContext) { localctx = NewAlterUserStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 586, DorisSQLParserRULE_alterUserStatement) + p.EnterRule(localctx, 586, StarRocksSQLParserRULE_alterUserStatement) var _la int p.SetState(5016) @@ -82113,7 +82113,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte p.EnterOuterAlt(localctx, 1) { p.SetState(4983) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82121,7 +82121,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(4984) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82134,10 +82134,10 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(4985) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82145,7 +82145,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(4986) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82166,7 +82166,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte p.EnterOuterAlt(localctx, 2) { p.SetState(4992) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82174,7 +82174,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(4993) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82187,10 +82187,10 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(4994) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82198,7 +82198,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(4995) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82212,7 +82212,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(4999) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82220,7 +82220,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(5000) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82236,7 +82236,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte case 1: { p.SetState(5001) - p.Match(DorisSQLParserNONE) + p.Match(StarRocksSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82246,7 +82246,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte case 2: { p.SetState(5002) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82267,7 +82267,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte p.EnterOuterAlt(localctx, 3) { p.SetState(5006) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82275,7 +82275,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(5007) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82288,10 +82288,10 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(5008) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82299,7 +82299,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(5009) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82313,7 +82313,7 @@ func (p *DorisSQLParser) AlterUserStatement() (localctx IAlterUserStatementConte } { p.SetState(5013) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82365,13 +82365,13 @@ type ShowUserStatementContext struct { func NewEmptyShowUserStatementContext() *ShowUserStatementContext { var p = new(ShowUserStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showUserStatement + p.RuleIndex = StarRocksSQLParserRULE_showUserStatement return p } func InitEmptyShowUserStatementContext(p *ShowUserStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showUserStatement + p.RuleIndex = StarRocksSQLParserRULE_showUserStatement } func (*ShowUserStatementContext) IsShowUserStatementContext() {} @@ -82382,7 +82382,7 @@ func NewShowUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showUserStatement + p.RuleIndex = StarRocksSQLParserRULE_showUserStatement return p } @@ -82390,15 +82390,15 @@ func NewShowUserStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *ShowUserStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowUserStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowUserStatementContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *ShowUserStatementContext) USERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSERS, 0) + return s.GetToken(StarRocksSQLParserUSERS, 0) } func (s *ShowUserStatementContext) GetRuleContext() antlr.RuleContext { @@ -82410,20 +82410,20 @@ func (s *ShowUserStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *ShowUserStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowUserStatement(s) } } func (s *ShowUserStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowUserStatement(s) } } func (s *ShowUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowUserStatement(s) default: @@ -82431,15 +82431,15 @@ func (s *ShowUserStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) ShowUserStatement() (localctx IShowUserStatementContext) { +func (p *StarRocksSQLParser) ShowUserStatement() (localctx IShowUserStatementContext) { localctx = NewShowUserStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 588, DorisSQLParserRULE_showUserStatement) + p.EnterRule(localctx, 588, StarRocksSQLParserRULE_showUserStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5018) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82449,7 +82449,7 @@ func (p *DorisSQLParser) ShowUserStatement() (localctx IShowUserStatementContext p.SetState(5019) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserUSER || _la == DorisSQLParserUSERS) { + if !(_la == StarRocksSQLParserUSER || _la == StarRocksSQLParserUSERS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -82488,13 +82488,13 @@ type ShowAuthenticationStatementContext struct { func NewEmptyShowAuthenticationStatementContext() *ShowAuthenticationStatementContext { var p = new(ShowAuthenticationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAuthenticationStatement + p.RuleIndex = StarRocksSQLParserRULE_showAuthenticationStatement return p } func InitEmptyShowAuthenticationStatementContext(p *ShowAuthenticationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showAuthenticationStatement + p.RuleIndex = StarRocksSQLParserRULE_showAuthenticationStatement } func (*ShowAuthenticationStatementContext) IsShowAuthenticationStatementContext() {} @@ -82505,7 +82505,7 @@ func NewShowAuthenticationStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showAuthenticationStatement + p.RuleIndex = StarRocksSQLParserRULE_showAuthenticationStatement return p } @@ -82543,32 +82543,32 @@ func (s *ShowAllAuthenticationContext) GetRuleContext() antlr.RuleContext { } func (s *ShowAllAuthenticationContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowAllAuthenticationContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *ShowAllAuthenticationContext) AUTHENTICATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTHENTICATION, 0) + return s.GetToken(StarRocksSQLParserAUTHENTICATION, 0) } func (s *ShowAllAuthenticationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowAllAuthentication(s) } } func (s *ShowAllAuthenticationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowAllAuthentication(s) } } func (s *ShowAllAuthenticationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowAllAuthentication(s) default: @@ -82595,15 +82595,15 @@ func (s *ShowAuthenticationForUserContext) GetRuleContext() antlr.RuleContext { } func (s *ShowAuthenticationForUserContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowAuthenticationForUserContext) AUTHENTICATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTHENTICATION, 0) + return s.GetToken(StarRocksSQLParserAUTHENTICATION, 0) } func (s *ShowAuthenticationForUserContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowAuthenticationForUserContext) User() IUserContext { @@ -82623,20 +82623,20 @@ func (s *ShowAuthenticationForUserContext) User() IUserContext { } func (s *ShowAuthenticationForUserContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowAuthenticationForUser(s) } } func (s *ShowAuthenticationForUserContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowAuthenticationForUser(s) } } func (s *ShowAuthenticationForUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowAuthenticationForUser(s) default: @@ -82644,9 +82644,9 @@ func (s *ShowAuthenticationForUserContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthenticationStatementContext) { +func (p *StarRocksSQLParser) ShowAuthenticationStatement() (localctx IShowAuthenticationStatementContext) { localctx = NewShowAuthenticationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 590, DorisSQLParserRULE_showAuthenticationStatement) + p.EnterRule(localctx, 590, StarRocksSQLParserRULE_showAuthenticationStatement) var _la int p.SetState(5030) @@ -82661,7 +82661,7 @@ func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthentica p.EnterOuterAlt(localctx, 1) { p.SetState(5021) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82669,7 +82669,7 @@ func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthentica } { p.SetState(5022) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82677,7 +82677,7 @@ func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthentica } { p.SetState(5023) - p.Match(DorisSQLParserAUTHENTICATION) + p.Match(StarRocksSQLParserAUTHENTICATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82689,7 +82689,7 @@ func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthentica p.EnterOuterAlt(localctx, 2) { p.SetState(5024) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82697,7 +82697,7 @@ func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthentica } { p.SetState(5025) - p.Match(DorisSQLParserAUTHENTICATION) + p.Match(StarRocksSQLParserAUTHENTICATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82710,10 +82710,10 @@ func (p *DorisSQLParser) ShowAuthenticationStatement() (localctx IShowAuthentica } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(5026) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82770,13 +82770,13 @@ type ExecuteAsStatementContext struct { func NewEmptyExecuteAsStatementContext() *ExecuteAsStatementContext { var p = new(ExecuteAsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_executeAsStatement + p.RuleIndex = StarRocksSQLParserRULE_executeAsStatement return p } func InitEmptyExecuteAsStatementContext(p *ExecuteAsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_executeAsStatement + p.RuleIndex = StarRocksSQLParserRULE_executeAsStatement } func (*ExecuteAsStatementContext) IsExecuteAsStatementContext() {} @@ -82787,7 +82787,7 @@ func NewExecuteAsStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_executeAsStatement + p.RuleIndex = StarRocksSQLParserRULE_executeAsStatement return p } @@ -82795,11 +82795,11 @@ func NewExecuteAsStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *ExecuteAsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ExecuteAsStatementContext) EXECUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXECUTE, 0) + return s.GetToken(StarRocksSQLParserEXECUTE, 0) } func (s *ExecuteAsStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *ExecuteAsStatementContext) User() IUserContext { @@ -82819,15 +82819,15 @@ func (s *ExecuteAsStatementContext) User() IUserContext { } func (s *ExecuteAsStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *ExecuteAsStatementContext) NO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNO, 0) + return s.GetToken(StarRocksSQLParserNO, 0) } func (s *ExecuteAsStatementContext) REVERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVERT, 0) + return s.GetToken(StarRocksSQLParserREVERT, 0) } func (s *ExecuteAsStatementContext) GetRuleContext() antlr.RuleContext { @@ -82839,20 +82839,20 @@ func (s *ExecuteAsStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ExecuteAsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExecuteAsStatement(s) } } func (s *ExecuteAsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExecuteAsStatement(s) } } func (s *ExecuteAsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExecuteAsStatement(s) default: @@ -82860,15 +82860,15 @@ func (s *ExecuteAsStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ExecuteAsStatement() (localctx IExecuteAsStatementContext) { +func (p *StarRocksSQLParser) ExecuteAsStatement() (localctx IExecuteAsStatementContext) { localctx = NewExecuteAsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 592, DorisSQLParserRULE_executeAsStatement) + p.EnterRule(localctx, 592, StarRocksSQLParserRULE_executeAsStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5032) - p.Match(DorisSQLParserEXECUTE) + p.Match(StarRocksSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82876,7 +82876,7 @@ func (p *DorisSQLParser) ExecuteAsStatement() (localctx IExecuteAsStatementConte } { p.SetState(5033) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82893,10 +82893,10 @@ func (p *DorisSQLParser) ExecuteAsStatement() (localctx IExecuteAsStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5035) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82904,7 +82904,7 @@ func (p *DorisSQLParser) ExecuteAsStatement() (localctx IExecuteAsStatementConte } { p.SetState(5036) - p.Match(DorisSQLParserNO) + p.Match(StarRocksSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82912,7 +82912,7 @@ func (p *DorisSQLParser) ExecuteAsStatement() (localctx IExecuteAsStatementConte } { p.SetState(5037) - p.Match(DorisSQLParserREVERT) + p.Match(StarRocksSQLParserREVERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -82962,13 +82962,13 @@ type CreateRoleStatementContext struct { func NewEmptyCreateRoleStatementContext() *CreateRoleStatementContext { var p = new(CreateRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_createRoleStatement return p } func InitEmptyCreateRoleStatementContext(p *CreateRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_createRoleStatement } func (*CreateRoleStatementContext) IsCreateRoleStatementContext() {} @@ -82979,7 +82979,7 @@ func NewCreateRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_createRoleStatement return p } @@ -82987,11 +82987,11 @@ func NewCreateRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *CreateRoleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateRoleStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateRoleStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *CreateRoleStatementContext) RoleList() IRoleListContext { @@ -83011,15 +83011,15 @@ func (s *CreateRoleStatementContext) RoleList() IRoleListContext { } func (s *CreateRoleStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateRoleStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateRoleStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateRoleStatementContext) Comment() ICommentContext { @@ -83047,20 +83047,20 @@ func (s *CreateRoleStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *CreateRoleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateRoleStatement(s) } } func (s *CreateRoleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateRoleStatement(s) } } func (s *CreateRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateRoleStatement(s) default: @@ -83068,15 +83068,15 @@ func (s *CreateRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementContext) { +func (p *StarRocksSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementContext) { localctx = NewCreateRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 594, DorisSQLParserRULE_createRoleStatement) + p.EnterRule(localctx, 594, StarRocksSQLParserRULE_createRoleStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5040) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83084,7 +83084,7 @@ func (p *DorisSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementCon } { p.SetState(5041) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83097,10 +83097,10 @@ func (p *DorisSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(5042) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83108,7 +83108,7 @@ func (p *DorisSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementCon } { p.SetState(5043) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83116,7 +83116,7 @@ func (p *DorisSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementCon } { p.SetState(5044) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83135,7 +83135,7 @@ func (p *DorisSQLParser) CreateRoleStatement() (localctx ICreateRoleStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(5048) p.Comment() @@ -83186,13 +83186,13 @@ type AlterRoleStatementContext struct { func NewEmptyAlterRoleStatementContext() *AlterRoleStatementContext { var p = new(AlterRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_alterRoleStatement return p } func InitEmptyAlterRoleStatementContext(p *AlterRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_alterRoleStatement } func (*AlterRoleStatementContext) IsAlterRoleStatementContext() {} @@ -83203,7 +83203,7 @@ func NewAlterRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_alterRoleStatement return p } @@ -83211,11 +83211,11 @@ func NewAlterRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *AlterRoleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterRoleStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterRoleStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *AlterRoleStatementContext) RoleList() IRoleListContext { @@ -83235,15 +83235,15 @@ func (s *AlterRoleStatementContext) RoleList() IRoleListContext { } func (s *AlterRoleStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterRoleStatementContext) COMMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMENT, 0) + return s.GetToken(StarRocksSQLParserCOMMENT, 0) } func (s *AlterRoleStatementContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *AlterRoleStatementContext) String_() IStringContext { @@ -83263,11 +83263,11 @@ func (s *AlterRoleStatementContext) String_() IStringContext { } func (s *AlterRoleStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *AlterRoleStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *AlterRoleStatementContext) GetRuleContext() antlr.RuleContext { @@ -83279,20 +83279,20 @@ func (s *AlterRoleStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *AlterRoleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterRoleStatement(s) } } func (s *AlterRoleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterRoleStatement(s) } } func (s *AlterRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterRoleStatement(s) default: @@ -83300,15 +83300,15 @@ func (s *AlterRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementContext) { +func (p *StarRocksSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementContext) { localctx = NewAlterRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 596, DorisSQLParserRULE_alterRoleStatement) + p.EnterRule(localctx, 596, StarRocksSQLParserRULE_alterRoleStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5051) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83316,7 +83316,7 @@ func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementConte } { p.SetState(5052) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83329,10 +83329,10 @@ func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(5053) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83340,7 +83340,7 @@ func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementConte } { p.SetState(5054) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83354,7 +83354,7 @@ func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementConte } { p.SetState(5058) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83362,7 +83362,7 @@ func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementConte } { p.SetState(5059) - p.Match(DorisSQLParserCOMMENT) + p.Match(StarRocksSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83370,7 +83370,7 @@ func (p *DorisSQLParser) AlterRoleStatement() (localctx IAlterRoleStatementConte } { p.SetState(5060) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83420,13 +83420,13 @@ type DropRoleStatementContext struct { func NewEmptyDropRoleStatementContext() *DropRoleStatementContext { var p = new(DropRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_dropRoleStatement return p } func InitEmptyDropRoleStatementContext(p *DropRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_dropRoleStatement } func (*DropRoleStatementContext) IsDropRoleStatementContext() {} @@ -83437,7 +83437,7 @@ func NewDropRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_dropRoleStatement return p } @@ -83445,11 +83445,11 @@ func NewDropRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DropRoleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropRoleStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropRoleStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *DropRoleStatementContext) RoleList() IRoleListContext { @@ -83469,11 +83469,11 @@ func (s *DropRoleStatementContext) RoleList() IRoleListContext { } func (s *DropRoleStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropRoleStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropRoleStatementContext) GetRuleContext() antlr.RuleContext { @@ -83485,20 +83485,20 @@ func (s *DropRoleStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropRoleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropRoleStatement(s) } } func (s *DropRoleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropRoleStatement(s) } } func (s *DropRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropRoleStatement(s) default: @@ -83506,15 +83506,15 @@ func (s *DropRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropRoleStatement() (localctx IDropRoleStatementContext) { +func (p *StarRocksSQLParser) DropRoleStatement() (localctx IDropRoleStatementContext) { localctx = NewDropRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 598, DorisSQLParserRULE_dropRoleStatement) + p.EnterRule(localctx, 598, StarRocksSQLParserRULE_dropRoleStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5063) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83522,7 +83522,7 @@ func (p *DorisSQLParser) DropRoleStatement() (localctx IDropRoleStatementContext } { p.SetState(5064) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83535,10 +83535,10 @@ func (p *DorisSQLParser) DropRoleStatement() (localctx IDropRoleStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(5065) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83546,7 +83546,7 @@ func (p *DorisSQLParser) DropRoleStatement() (localctx IDropRoleStatementContext } { p.SetState(5066) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83595,13 +83595,13 @@ type ShowRolesStatementContext struct { func NewEmptyShowRolesStatementContext() *ShowRolesStatementContext { var p = new(ShowRolesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRolesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRolesStatement return p } func InitEmptyShowRolesStatementContext(p *ShowRolesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRolesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRolesStatement } func (*ShowRolesStatementContext) IsShowRolesStatementContext() {} @@ -83612,7 +83612,7 @@ func NewShowRolesStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showRolesStatement + p.RuleIndex = StarRocksSQLParserRULE_showRolesStatement return p } @@ -83620,11 +83620,11 @@ func NewShowRolesStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *ShowRolesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowRolesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowRolesStatementContext) ROLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLES, 0) + return s.GetToken(StarRocksSQLParserROLES, 0) } func (s *ShowRolesStatementContext) GetRuleContext() antlr.RuleContext { @@ -83636,20 +83636,20 @@ func (s *ShowRolesStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ShowRolesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowRolesStatement(s) } } func (s *ShowRolesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowRolesStatement(s) } } func (s *ShowRolesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowRolesStatement(s) default: @@ -83657,13 +83657,13 @@ func (s *ShowRolesStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ShowRolesStatement() (localctx IShowRolesStatementContext) { +func (p *StarRocksSQLParser) ShowRolesStatement() (localctx IShowRolesStatementContext) { localctx = NewShowRolesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 600, DorisSQLParserRULE_showRolesStatement) + p.EnterRule(localctx, 600, StarRocksSQLParserRULE_showRolesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5071) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83671,7 +83671,7 @@ func (p *DorisSQLParser) ShowRolesStatement() (localctx IShowRolesStatementConte } { p.SetState(5072) - p.Match(DorisSQLParserROLES) + p.Match(StarRocksSQLParserROLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83709,13 +83709,13 @@ type GrantRoleStatementContext struct { func NewEmptyGrantRoleStatementContext() *GrantRoleStatementContext { var p = new(GrantRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_grantRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_grantRoleStatement return p } func InitEmptyGrantRoleStatementContext(p *GrantRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_grantRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_grantRoleStatement } func (*GrantRoleStatementContext) IsGrantRoleStatementContext() {} @@ -83726,7 +83726,7 @@ func NewGrantRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_grantRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_grantRoleStatement return p } @@ -83764,7 +83764,7 @@ func (s *GrantRoleToUserContext) GetRuleContext() antlr.RuleContext { } func (s *GrantRoleToUserContext) GRANT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, 0) + return s.GetToken(StarRocksSQLParserGRANT, 0) } func (s *GrantRoleToUserContext) IdentifierOrStringList() IIdentifierOrStringListContext { @@ -83784,7 +83784,7 @@ func (s *GrantRoleToUserContext) IdentifierOrStringList() IIdentifierOrStringLis } func (s *GrantRoleToUserContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantRoleToUserContext) User() IUserContext { @@ -83804,24 +83804,24 @@ func (s *GrantRoleToUserContext) User() IUserContext { } func (s *GrantRoleToUserContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *GrantRoleToUserContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantRoleToUser(s) } } func (s *GrantRoleToUserContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantRoleToUser(s) } } func (s *GrantRoleToUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantRoleToUser(s) default: @@ -83848,7 +83848,7 @@ func (s *GrantRoleToRoleContext) GetRuleContext() antlr.RuleContext { } func (s *GrantRoleToRoleContext) GRANT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, 0) + return s.GetToken(StarRocksSQLParserGRANT, 0) } func (s *GrantRoleToRoleContext) IdentifierOrStringList() IIdentifierOrStringListContext { @@ -83868,11 +83868,11 @@ func (s *GrantRoleToRoleContext) IdentifierOrStringList() IIdentifierOrStringLis } func (s *GrantRoleToRoleContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantRoleToRoleContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *GrantRoleToRoleContext) IdentifierOrString() IIdentifierOrStringContext { @@ -83892,20 +83892,20 @@ func (s *GrantRoleToRoleContext) IdentifierOrString() IIdentifierOrStringContext } func (s *GrantRoleToRoleContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantRoleToRole(s) } } func (s *GrantRoleToRoleContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantRoleToRole(s) } } func (s *GrantRoleToRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantRoleToRole(s) default: @@ -83913,9 +83913,9 @@ func (s *GrantRoleToRoleContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementContext) { +func (p *StarRocksSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementContext) { localctx = NewGrantRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 602, DorisSQLParserRULE_grantRoleStatement) + p.EnterRule(localctx, 602, StarRocksSQLParserRULE_grantRoleStatement) p.SetState(5088) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -83928,7 +83928,7 @@ func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementConte p.EnterOuterAlt(localctx, 1) { p.SetState(5074) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83940,7 +83940,7 @@ func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementConte } { p.SetState(5076) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83952,7 +83952,7 @@ func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementConte if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext()) == 1 { { p.SetState(5077) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83972,7 +83972,7 @@ func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementConte p.EnterOuterAlt(localctx, 2) { p.SetState(5082) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83984,7 +83984,7 @@ func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementConte } { p.SetState(5084) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -83992,7 +83992,7 @@ func (p *DorisSQLParser) GrantRoleStatement() (localctx IGrantRoleStatementConte } { p.SetState(5085) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84038,13 +84038,13 @@ type RevokeRoleStatementContext struct { func NewEmptyRevokeRoleStatementContext() *RevokeRoleStatementContext { var p = new(RevokeRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_revokeRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_revokeRoleStatement return p } func InitEmptyRevokeRoleStatementContext(p *RevokeRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_revokeRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_revokeRoleStatement } func (*RevokeRoleStatementContext) IsRevokeRoleStatementContext() {} @@ -84055,7 +84055,7 @@ func NewRevokeRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_revokeRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_revokeRoleStatement return p } @@ -84093,7 +84093,7 @@ func (s *RevokeRoleFromUserContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeRoleFromUserContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeRoleFromUserContext) IdentifierOrStringList() IIdentifierOrStringListContext { @@ -84113,7 +84113,7 @@ func (s *RevokeRoleFromUserContext) IdentifierOrStringList() IIdentifierOrString } func (s *RevokeRoleFromUserContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeRoleFromUserContext) User() IUserContext { @@ -84133,24 +84133,24 @@ func (s *RevokeRoleFromUserContext) User() IUserContext { } func (s *RevokeRoleFromUserContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *RevokeRoleFromUserContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeRoleFromUser(s) } } func (s *RevokeRoleFromUserContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeRoleFromUser(s) } } func (s *RevokeRoleFromUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeRoleFromUser(s) default: @@ -84177,7 +84177,7 @@ func (s *RevokeRoleFromRoleContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeRoleFromRoleContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeRoleFromRoleContext) IdentifierOrStringList() IIdentifierOrStringListContext { @@ -84197,11 +84197,11 @@ func (s *RevokeRoleFromRoleContext) IdentifierOrStringList() IIdentifierOrString } func (s *RevokeRoleFromRoleContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeRoleFromRoleContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *RevokeRoleFromRoleContext) IdentifierOrString() IIdentifierOrStringContext { @@ -84221,20 +84221,20 @@ func (s *RevokeRoleFromRoleContext) IdentifierOrString() IIdentifierOrStringCont } func (s *RevokeRoleFromRoleContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeRoleFromRole(s) } } func (s *RevokeRoleFromRoleContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeRoleFromRole(s) } } func (s *RevokeRoleFromRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeRoleFromRole(s) default: @@ -84242,9 +84242,9 @@ func (s *RevokeRoleFromRoleContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementContext) { +func (p *StarRocksSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementContext) { localctx = NewRevokeRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 604, DorisSQLParserRULE_revokeRoleStatement) + p.EnterRule(localctx, 604, StarRocksSQLParserRULE_revokeRoleStatement) p.SetState(5104) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -84257,7 +84257,7 @@ func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementCon p.EnterOuterAlt(localctx, 1) { p.SetState(5090) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84269,7 +84269,7 @@ func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementCon } { p.SetState(5092) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84281,7 +84281,7 @@ func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementCon if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) == 1 { { p.SetState(5093) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84301,7 +84301,7 @@ func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementCon p.EnterOuterAlt(localctx, 2) { p.SetState(5098) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84313,7 +84313,7 @@ func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementCon } { p.SetState(5100) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84321,7 +84321,7 @@ func (p *DorisSQLParser) RevokeRoleStatement() (localctx IRevokeRoleStatementCon } { p.SetState(5101) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84377,13 +84377,13 @@ type SetRoleStatementContext struct { func NewEmptySetRoleStatementContext() *SetRoleStatementContext { var p = new(SetRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_setRoleStatement return p } func InitEmptySetRoleStatementContext(p *SetRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_setRoleStatement } func (*SetRoleStatementContext) IsSetRoleStatementContext() {} @@ -84394,7 +84394,7 @@ func NewSetRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_setRoleStatement return p } @@ -84402,27 +84402,27 @@ func NewSetRoleStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *SetRoleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetRoleStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetRoleStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *SetRoleStatementContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *SetRoleStatementContext) NONE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNONE, 0) + return s.GetToken(StarRocksSQLParserNONE, 0) } func (s *SetRoleStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *SetRoleStatementContext) EXCEPT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXCEPT, 0) + return s.GetToken(StarRocksSQLParserEXCEPT, 0) } func (s *SetRoleStatementContext) RoleList() IRoleListContext { @@ -84450,20 +84450,20 @@ func (s *SetRoleStatementContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *SetRoleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetRoleStatement(s) } } func (s *SetRoleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetRoleStatement(s) } } func (s *SetRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetRoleStatement(s) default: @@ -84471,9 +84471,9 @@ func (s *SetRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) { +func (p *StarRocksSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) { localctx = NewSetRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 606, DorisSQLParserRULE_setRoleStatement) + p.EnterRule(localctx, 606, StarRocksSQLParserRULE_setRoleStatement) var _la int p.SetState(5122) @@ -84487,7 +84487,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) p.EnterOuterAlt(localctx, 1) { p.SetState(5106) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84495,7 +84495,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5107) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84503,7 +84503,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5108) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84514,7 +84514,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) p.EnterOuterAlt(localctx, 2) { p.SetState(5109) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84522,7 +84522,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5110) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84530,7 +84530,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5111) - p.Match(DorisSQLParserNONE) + p.Match(StarRocksSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84541,7 +84541,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) p.EnterOuterAlt(localctx, 3) { p.SetState(5112) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84549,7 +84549,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5113) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84557,7 +84557,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5114) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84570,10 +84570,10 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEXCEPT { + if _la == StarRocksSQLParserEXCEPT { { p.SetState(5115) - p.Match(DorisSQLParserEXCEPT) + p.Match(StarRocksSQLParserEXCEPT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84590,7 +84590,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) p.EnterOuterAlt(localctx, 4) { p.SetState(5119) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84598,7 +84598,7 @@ func (p *DorisSQLParser) SetRoleStatement() (localctx ISetRoleStatementContext) } { p.SetState(5120) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84655,13 +84655,13 @@ type SetDefaultRoleStatementContext struct { func NewEmptySetDefaultRoleStatementContext() *SetDefaultRoleStatementContext { var p = new(SetDefaultRoleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setDefaultRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_setDefaultRoleStatement return p } func InitEmptySetDefaultRoleStatementContext(p *SetDefaultRoleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setDefaultRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_setDefaultRoleStatement } func (*SetDefaultRoleStatementContext) IsSetDefaultRoleStatementContext() {} @@ -84672,7 +84672,7 @@ func NewSetDefaultRoleStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setDefaultRoleStatement + p.RuleIndex = StarRocksSQLParserRULE_setDefaultRoleStatement return p } @@ -84680,19 +84680,19 @@ func NewSetDefaultRoleStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *SetDefaultRoleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetDefaultRoleStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetDefaultRoleStatementContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *SetDefaultRoleStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *SetDefaultRoleStatementContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *SetDefaultRoleStatementContext) User() IUserContext { @@ -84712,11 +84712,11 @@ func (s *SetDefaultRoleStatementContext) User() IUserContext { } func (s *SetDefaultRoleStatementContext) NONE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNONE, 0) + return s.GetToken(StarRocksSQLParserNONE, 0) } func (s *SetDefaultRoleStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *SetDefaultRoleStatementContext) RoleList() IRoleListContext { @@ -84744,20 +84744,20 @@ func (s *SetDefaultRoleStatementContext) ToStringTree(ruleNames []string, recog } func (s *SetDefaultRoleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetDefaultRoleStatement(s) } } func (s *SetDefaultRoleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetDefaultRoleStatement(s) } } func (s *SetDefaultRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetDefaultRoleStatement(s) default: @@ -84765,13 +84765,13 @@ func (s *SetDefaultRoleStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStatementContext) { +func (p *StarRocksSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStatementContext) { localctx = NewSetDefaultRoleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 608, DorisSQLParserRULE_setDefaultRoleStatement) + p.EnterRule(localctx, 608, StarRocksSQLParserRULE_setDefaultRoleStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5124) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84779,7 +84779,7 @@ func (p *DorisSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStat } { p.SetState(5125) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84787,7 +84787,7 @@ func (p *DorisSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStat } { p.SetState(5126) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84803,7 +84803,7 @@ func (p *DorisSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStat case 1: { p.SetState(5127) - p.Match(DorisSQLParserNONE) + p.Match(StarRocksSQLParserNONE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84813,7 +84813,7 @@ func (p *DorisSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStat case 2: { p.SetState(5128) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84831,7 +84831,7 @@ func (p *DorisSQLParser) SetDefaultRoleStatement() (localctx ISetDefaultRoleStat } { p.SetState(5132) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -84880,13 +84880,13 @@ type GrantRevokeClauseContext struct { func NewEmptyGrantRevokeClauseContext() *GrantRevokeClauseContext { var p = new(GrantRevokeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_grantRevokeClause + p.RuleIndex = StarRocksSQLParserRULE_grantRevokeClause return p } func InitEmptyGrantRevokeClauseContext(p *GrantRevokeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_grantRevokeClause + p.RuleIndex = StarRocksSQLParserRULE_grantRevokeClause } func (*GrantRevokeClauseContext) IsGrantRevokeClauseContext() {} @@ -84897,7 +84897,7 @@ func NewGrantRevokeClauseContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_grantRevokeClause + p.RuleIndex = StarRocksSQLParserRULE_grantRevokeClause return p } @@ -84921,7 +84921,7 @@ func (s *GrantRevokeClauseContext) User() IUserContext { } func (s *GrantRevokeClauseContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *GrantRevokeClauseContext) IdentifierOrString() IIdentifierOrStringContext { @@ -84941,7 +84941,7 @@ func (s *GrantRevokeClauseContext) IdentifierOrString() IIdentifierOrStringConte } func (s *GrantRevokeClauseContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *GrantRevokeClauseContext) GetRuleContext() antlr.RuleContext { @@ -84953,20 +84953,20 @@ func (s *GrantRevokeClauseContext) ToStringTree(ruleNames []string, recog antlr. } func (s *GrantRevokeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantRevokeClause(s) } } func (s *GrantRevokeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantRevokeClause(s) } } func (s *GrantRevokeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantRevokeClause(s) default: @@ -84974,9 +84974,9 @@ func (s *GrantRevokeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) GrantRevokeClause() (localctx IGrantRevokeClauseContext) { +func (p *StarRocksSQLParser) GrantRevokeClause() (localctx IGrantRevokeClauseContext) { localctx = NewGrantRevokeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 610, DorisSQLParserRULE_grantRevokeClause) + p.EnterRule(localctx, 610, StarRocksSQLParserRULE_grantRevokeClause) p.EnterOuterAlt(localctx, 1) p.SetState(5141) p.GetErrorHandler().Sync(p) @@ -84992,7 +84992,7 @@ func (p *DorisSQLParser) GrantRevokeClause() (localctx IGrantRevokeClauseContext if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext()) == 1 { { p.SetState(5135) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85010,7 +85010,7 @@ func (p *DorisSQLParser) GrantRevokeClause() (localctx IGrantRevokeClauseContext case 2: { p.SetState(5139) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85056,13 +85056,13 @@ type GrantPrivilegeStatementContext struct { func NewEmptyGrantPrivilegeStatementContext() *GrantPrivilegeStatementContext { var p = new(GrantPrivilegeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_grantPrivilegeStatement + p.RuleIndex = StarRocksSQLParserRULE_grantPrivilegeStatement return p } func InitEmptyGrantPrivilegeStatementContext(p *GrantPrivilegeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_grantPrivilegeStatement + p.RuleIndex = StarRocksSQLParserRULE_grantPrivilegeStatement } func (*GrantPrivilegeStatementContext) IsGrantPrivilegeStatementContext() {} @@ -85073,7 +85073,7 @@ func NewGrantPrivilegeStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_grantPrivilegeStatement + p.RuleIndex = StarRocksSQLParserRULE_grantPrivilegeStatement return p } @@ -85116,11 +85116,11 @@ func (s *GrantOnAllContext) GetRuleContext() antlr.RuleContext { } func (s *GrantOnAllContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserGRANT) + return s.GetTokens(StarRocksSQLParserGRANT) } func (s *GrantOnAllContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, i) + return s.GetToken(StarRocksSQLParserGRANT, i) } func (s *GrantOnAllContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -85140,15 +85140,15 @@ func (s *GrantOnAllContext) PrivilegeTypeList() IPrivilegeTypeListContext { } func (s *GrantOnAllContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *GrantOnAllContext) AllALL() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserALL) + return s.GetTokens(StarRocksSQLParserALL) } func (s *GrantOnAllContext) ALL(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, i) + return s.GetToken(StarRocksSQLParserALL, i) } func (s *GrantOnAllContext) PrivObjectTypePlural() IPrivObjectTypePluralContext { @@ -85168,7 +85168,7 @@ func (s *GrantOnAllContext) PrivObjectTypePlural() IPrivObjectTypePluralContext } func (s *GrantOnAllContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantOnAllContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -85188,15 +85188,15 @@ func (s *GrantOnAllContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *GrantOnAllContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *GrantOnAllContext) DATABASES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASES, 0) + return s.GetToken(StarRocksSQLParserDATABASES, 0) } func (s *GrantOnAllContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *GrantOnAllContext) IdentifierOrString() IIdentifierOrStringContext { @@ -85216,28 +85216,28 @@ func (s *GrantOnAllContext) IdentifierOrString() IIdentifierOrStringContext { } func (s *GrantOnAllContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *GrantOnAllContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *GrantOnAllContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantOnAll(s) } } func (s *GrantOnAllContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantOnAll(s) } } func (s *GrantOnAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantOnAll(s) default: @@ -85264,11 +85264,11 @@ func (s *GrantOnFuncContext) GetRuleContext() antlr.RuleContext { } func (s *GrantOnFuncContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserGRANT) + return s.GetTokens(StarRocksSQLParserGRANT) } func (s *GrantOnFuncContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, i) + return s.GetToken(StarRocksSQLParserGRANT, i) } func (s *GrantOnFuncContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -85288,11 +85288,11 @@ func (s *GrantOnFuncContext) PrivilegeTypeList() IPrivilegeTypeListContext { } func (s *GrantOnFuncContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *GrantOnFuncContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *GrantOnFuncContext) PrivFunctionObjectNameList() IPrivFunctionObjectNameListContext { @@ -85312,7 +85312,7 @@ func (s *GrantOnFuncContext) PrivFunctionObjectNameList() IPrivFunctionObjectNam } func (s *GrantOnFuncContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantOnFuncContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -85332,32 +85332,32 @@ func (s *GrantOnFuncContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *GrantOnFuncContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *GrantOnFuncContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *GrantOnFuncContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *GrantOnFuncContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantOnFunc(s) } } func (s *GrantOnFuncContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantOnFunc(s) } } func (s *GrantOnFuncContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantOnFunc(s) default: @@ -85384,11 +85384,11 @@ func (s *GrantOnPrimaryObjContext) GetRuleContext() antlr.RuleContext { } func (s *GrantOnPrimaryObjContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserGRANT) + return s.GetTokens(StarRocksSQLParserGRANT) } func (s *GrantOnPrimaryObjContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, i) + return s.GetToken(StarRocksSQLParserGRANT, i) } func (s *GrantOnPrimaryObjContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -85408,7 +85408,7 @@ func (s *GrantOnPrimaryObjContext) PrivilegeTypeList() IPrivilegeTypeListContext } func (s *GrantOnPrimaryObjContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *GrantOnPrimaryObjContext) PrivObjectType() IPrivObjectTypeContext { @@ -85444,7 +85444,7 @@ func (s *GrantOnPrimaryObjContext) PrivObjectNameList() IPrivObjectNameListConte } func (s *GrantOnPrimaryObjContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantOnPrimaryObjContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -85464,28 +85464,28 @@ func (s *GrantOnPrimaryObjContext) GrantRevokeClause() IGrantRevokeClauseContext } func (s *GrantOnPrimaryObjContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *GrantOnPrimaryObjContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *GrantOnPrimaryObjContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantOnPrimaryObj(s) } } func (s *GrantOnPrimaryObjContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantOnPrimaryObj(s) } } func (s *GrantOnPrimaryObjContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantOnPrimaryObj(s) default: @@ -85512,11 +85512,11 @@ func (s *GrantOnTableBriefContext) GetRuleContext() antlr.RuleContext { } func (s *GrantOnTableBriefContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserGRANT) + return s.GetTokens(StarRocksSQLParserGRANT) } func (s *GrantOnTableBriefContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, i) + return s.GetToken(StarRocksSQLParserGRANT, i) } func (s *GrantOnTableBriefContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -85536,7 +85536,7 @@ func (s *GrantOnTableBriefContext) PrivilegeTypeList() IPrivilegeTypeListContext } func (s *GrantOnTableBriefContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *GrantOnTableBriefContext) PrivObjectNameList() IPrivObjectNameListContext { @@ -85556,7 +85556,7 @@ func (s *GrantOnTableBriefContext) PrivObjectNameList() IPrivObjectNameListConte } func (s *GrantOnTableBriefContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantOnTableBriefContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -85576,28 +85576,28 @@ func (s *GrantOnTableBriefContext) GrantRevokeClause() IGrantRevokeClauseContext } func (s *GrantOnTableBriefContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *GrantOnTableBriefContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *GrantOnTableBriefContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantOnTableBrief(s) } } func (s *GrantOnTableBriefContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantOnTableBrief(s) } } func (s *GrantOnTableBriefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantOnTableBrief(s) default: @@ -85624,23 +85624,23 @@ func (s *GrantOnUserContext) GetRuleContext() antlr.RuleContext { } func (s *GrantOnUserContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserGRANT) + return s.GetTokens(StarRocksSQLParserGRANT) } func (s *GrantOnUserContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, i) + return s.GetToken(StarRocksSQLParserGRANT, i) } func (s *GrantOnUserContext) IMPERSONATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMPERSONATE, 0) + return s.GetToken(StarRocksSQLParserIMPERSONATE, 0) } func (s *GrantOnUserContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *GrantOnUserContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *GrantOnUserContext) AllUser() []IUserContext { @@ -85685,7 +85685,7 @@ func (s *GrantOnUserContext) User(i int) IUserContext { } func (s *GrantOnUserContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantOnUserContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -85705,28 +85705,28 @@ func (s *GrantOnUserContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *GrantOnUserContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *GrantOnUserContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *GrantOnUserContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantOnUser(s) } } func (s *GrantOnUserContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantOnUser(s) } } func (s *GrantOnUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantOnUser(s) default: @@ -85753,11 +85753,11 @@ func (s *GrantOnSystemContext) GetRuleContext() antlr.RuleContext { } func (s *GrantOnSystemContext) AllGRANT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserGRANT) + return s.GetTokens(StarRocksSQLParserGRANT) } func (s *GrantOnSystemContext) GRANT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, i) + return s.GetToken(StarRocksSQLParserGRANT, i) } func (s *GrantOnSystemContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -85777,15 +85777,15 @@ func (s *GrantOnSystemContext) PrivilegeTypeList() IPrivilegeTypeListContext { } func (s *GrantOnSystemContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *GrantOnSystemContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYSTEM, 0) + return s.GetToken(StarRocksSQLParserSYSTEM, 0) } func (s *GrantOnSystemContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *GrantOnSystemContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -85805,28 +85805,28 @@ func (s *GrantOnSystemContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *GrantOnSystemContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *GrantOnSystemContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *GrantOnSystemContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGrantOnSystem(s) } } func (s *GrantOnSystemContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGrantOnSystem(s) } } func (s *GrantOnSystemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGrantOnSystem(s) default: @@ -85834,9 +85834,9 @@ func (s *GrantOnSystemContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStatementContext) { +func (p *StarRocksSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStatementContext) { localctx = NewGrantPrivilegeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 612, DorisSQLParserRULE_grantPrivilegeStatement) + p.EnterRule(localctx, 612, StarRocksSQLParserRULE_grantPrivilegeStatement) var _la int p.SetState(5231) @@ -85851,7 +85851,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat p.EnterOuterAlt(localctx, 1) { p.SetState(5143) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85859,7 +85859,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5144) - p.Match(DorisSQLParserIMPERSONATE) + p.Match(StarRocksSQLParserIMPERSONATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85867,7 +85867,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5145) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85875,7 +85875,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5146) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85892,10 +85892,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5148) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85915,7 +85915,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5155) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85932,10 +85932,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5157) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85943,7 +85943,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5158) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85951,7 +85951,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5159) - p.Match(DorisSQLParserOPTION) + p.Match(StarRocksSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85965,7 +85965,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat p.EnterOuterAlt(localctx, 2) { p.SetState(5162) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85977,7 +85977,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5164) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -85989,7 +85989,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5166) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86006,10 +86006,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5168) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86017,7 +86017,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5169) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86025,7 +86025,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5170) - p.Match(DorisSQLParserOPTION) + p.Match(StarRocksSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86039,7 +86039,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat p.EnterOuterAlt(localctx, 3) { p.SetState(5173) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86051,7 +86051,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5175) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86064,10 +86064,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL { + if _la == StarRocksSQLParserGLOBAL { { p.SetState(5176) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86077,7 +86077,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5179) - p.Match(DorisSQLParserFUNCTION) + p.Match(StarRocksSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86089,7 +86089,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5181) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86106,10 +86106,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5183) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86117,7 +86117,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5184) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86125,7 +86125,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5185) - p.Match(DorisSQLParserOPTION) + p.Match(StarRocksSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86139,7 +86139,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat p.EnterOuterAlt(localctx, 4) { p.SetState(5188) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86151,7 +86151,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5190) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86159,7 +86159,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5191) - p.Match(DorisSQLParserSYSTEM) + p.Match(StarRocksSQLParserSYSTEM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86167,7 +86167,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5192) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86184,10 +86184,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5194) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86195,7 +86195,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5195) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86203,7 +86203,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5196) - p.Match(DorisSQLParserOPTION) + p.Match(StarRocksSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86217,7 +86217,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat p.EnterOuterAlt(localctx, 5) { p.SetState(5199) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86229,7 +86229,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5201) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86245,7 +86245,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5204) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86262,10 +86262,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5206) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86273,7 +86273,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5207) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86281,7 +86281,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5208) - p.Match(DorisSQLParserOPTION) + p.Match(StarRocksSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86295,7 +86295,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat p.EnterOuterAlt(localctx, 6) { p.SetState(5211) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86307,7 +86307,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5213) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86315,7 +86315,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5214) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86331,7 +86331,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 552, p.GetParserRuleContext()) == 1 { { p.SetState(5216) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86340,7 +86340,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat { p.SetState(5217) - var _m = p.Match(DorisSQLParserALL) + var _m = p.Match(StarRocksSQLParserALL) localctx.(*GrantOnAllContext).isAll = _m if p.HasError() { @@ -86350,7 +86350,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5218) - p.Match(DorisSQLParserDATABASES) + p.Match(StarRocksSQLParserDATABASES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86362,7 +86362,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 552, p.GetParserRuleContext()) == 2 { { p.SetState(5219) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86370,7 +86370,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5220) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86386,7 +86386,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5224) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86403,10 +86403,10 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5226) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86414,7 +86414,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5227) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86422,7 +86422,7 @@ func (p *DorisSQLParser) GrantPrivilegeStatement() (localctx IGrantPrivilegeStat } { p.SetState(5228) - p.Match(DorisSQLParserOPTION) + p.Match(StarRocksSQLParserOPTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -86466,13 +86466,13 @@ type RevokePrivilegeStatementContext struct { func NewEmptyRevokePrivilegeStatementContext() *RevokePrivilegeStatementContext { var p = new(RevokePrivilegeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_revokePrivilegeStatement + p.RuleIndex = StarRocksSQLParserRULE_revokePrivilegeStatement return p } func InitEmptyRevokePrivilegeStatementContext(p *RevokePrivilegeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_revokePrivilegeStatement + p.RuleIndex = StarRocksSQLParserRULE_revokePrivilegeStatement } func (*RevokePrivilegeStatementContext) IsRevokePrivilegeStatementContext() {} @@ -86483,7 +86483,7 @@ func NewRevokePrivilegeStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_revokePrivilegeStatement + p.RuleIndex = StarRocksSQLParserRULE_revokePrivilegeStatement return p } @@ -86521,7 +86521,7 @@ func (s *RevokeOnPrimaryObjContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeOnPrimaryObjContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeOnPrimaryObjContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -86541,7 +86541,7 @@ func (s *RevokeOnPrimaryObjContext) PrivilegeTypeList() IPrivilegeTypeListContex } func (s *RevokeOnPrimaryObjContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RevokeOnPrimaryObjContext) PrivObjectType() IPrivObjectTypeContext { @@ -86577,7 +86577,7 @@ func (s *RevokeOnPrimaryObjContext) PrivObjectNameList() IPrivObjectNameListCont } func (s *RevokeOnPrimaryObjContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeOnPrimaryObjContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -86597,20 +86597,20 @@ func (s *RevokeOnPrimaryObjContext) GrantRevokeClause() IGrantRevokeClauseContex } func (s *RevokeOnPrimaryObjContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeOnPrimaryObj(s) } } func (s *RevokeOnPrimaryObjContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeOnPrimaryObj(s) } } func (s *RevokeOnPrimaryObjContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeOnPrimaryObj(s) default: @@ -86637,7 +86637,7 @@ func (s *RevokeOnTableBriefContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeOnTableBriefContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeOnTableBriefContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -86657,7 +86657,7 @@ func (s *RevokeOnTableBriefContext) PrivilegeTypeList() IPrivilegeTypeListContex } func (s *RevokeOnTableBriefContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RevokeOnTableBriefContext) PrivObjectNameList() IPrivObjectNameListContext { @@ -86677,7 +86677,7 @@ func (s *RevokeOnTableBriefContext) PrivObjectNameList() IPrivObjectNameListCont } func (s *RevokeOnTableBriefContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeOnTableBriefContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -86697,20 +86697,20 @@ func (s *RevokeOnTableBriefContext) GrantRevokeClause() IGrantRevokeClauseContex } func (s *RevokeOnTableBriefContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeOnTableBrief(s) } } func (s *RevokeOnTableBriefContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeOnTableBrief(s) } } func (s *RevokeOnTableBriefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeOnTableBrief(s) default: @@ -86742,7 +86742,7 @@ func (s *RevokeOnAllContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeOnAllContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeOnAllContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -86762,15 +86762,15 @@ func (s *RevokeOnAllContext) PrivilegeTypeList() IPrivilegeTypeListContext { } func (s *RevokeOnAllContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RevokeOnAllContext) AllALL() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserALL) + return s.GetTokens(StarRocksSQLParserALL) } func (s *RevokeOnAllContext) ALL(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, i) + return s.GetToken(StarRocksSQLParserALL, i) } func (s *RevokeOnAllContext) PrivObjectTypePlural() IPrivObjectTypePluralContext { @@ -86790,7 +86790,7 @@ func (s *RevokeOnAllContext) PrivObjectTypePlural() IPrivObjectTypePluralContext } func (s *RevokeOnAllContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeOnAllContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -86810,15 +86810,15 @@ func (s *RevokeOnAllContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *RevokeOnAllContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *RevokeOnAllContext) DATABASES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASES, 0) + return s.GetToken(StarRocksSQLParserDATABASES, 0) } func (s *RevokeOnAllContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *RevokeOnAllContext) IdentifierOrString() IIdentifierOrStringContext { @@ -86838,20 +86838,20 @@ func (s *RevokeOnAllContext) IdentifierOrString() IIdentifierOrStringContext { } func (s *RevokeOnAllContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeOnAll(s) } } func (s *RevokeOnAllContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeOnAll(s) } } func (s *RevokeOnAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeOnAll(s) default: @@ -86878,19 +86878,19 @@ func (s *RevokeOnUserContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeOnUserContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeOnUserContext) IMPERSONATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMPERSONATE, 0) + return s.GetToken(StarRocksSQLParserIMPERSONATE, 0) } func (s *RevokeOnUserContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RevokeOnUserContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *RevokeOnUserContext) AllUser() []IUserContext { @@ -86935,7 +86935,7 @@ func (s *RevokeOnUserContext) User(i int) IUserContext { } func (s *RevokeOnUserContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeOnUserContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -86955,20 +86955,20 @@ func (s *RevokeOnUserContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *RevokeOnUserContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeOnUser(s) } } func (s *RevokeOnUserContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeOnUser(s) } } func (s *RevokeOnUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeOnUser(s) default: @@ -86995,7 +86995,7 @@ func (s *RevokeOnFuncContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeOnFuncContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeOnFuncContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -87015,11 +87015,11 @@ func (s *RevokeOnFuncContext) PrivilegeTypeList() IPrivilegeTypeListContext { } func (s *RevokeOnFuncContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RevokeOnFuncContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *RevokeOnFuncContext) PrivFunctionObjectNameList() IPrivFunctionObjectNameListContext { @@ -87039,7 +87039,7 @@ func (s *RevokeOnFuncContext) PrivFunctionObjectNameList() IPrivFunctionObjectNa } func (s *RevokeOnFuncContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeOnFuncContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -87059,24 +87059,24 @@ func (s *RevokeOnFuncContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *RevokeOnFuncContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *RevokeOnFuncContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeOnFunc(s) } } func (s *RevokeOnFuncContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeOnFunc(s) } } func (s *RevokeOnFuncContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeOnFunc(s) default: @@ -87103,7 +87103,7 @@ func (s *RevokeOnSystemContext) GetRuleContext() antlr.RuleContext { } func (s *RevokeOnSystemContext) REVOKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVOKE, 0) + return s.GetToken(StarRocksSQLParserREVOKE, 0) } func (s *RevokeOnSystemContext) PrivilegeTypeList() IPrivilegeTypeListContext { @@ -87123,15 +87123,15 @@ func (s *RevokeOnSystemContext) PrivilegeTypeList() IPrivilegeTypeListContext { } func (s *RevokeOnSystemContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RevokeOnSystemContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYSTEM, 0) + return s.GetToken(StarRocksSQLParserSYSTEM, 0) } func (s *RevokeOnSystemContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RevokeOnSystemContext) GrantRevokeClause() IGrantRevokeClauseContext { @@ -87151,20 +87151,20 @@ func (s *RevokeOnSystemContext) GrantRevokeClause() IGrantRevokeClauseContext { } func (s *RevokeOnSystemContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRevokeOnSystem(s) } } func (s *RevokeOnSystemContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRevokeOnSystem(s) } } func (s *RevokeOnSystemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRevokeOnSystem(s) default: @@ -87172,9 +87172,9 @@ func (s *RevokeOnSystemContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeStatementContext) { +func (p *StarRocksSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeStatementContext) { localctx = NewRevokePrivilegeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 614, DorisSQLParserRULE_revokePrivilegeStatement) + p.EnterRule(localctx, 614, StarRocksSQLParserRULE_revokePrivilegeStatement) var _la int p.SetState(5297) @@ -87189,7 +87189,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt p.EnterOuterAlt(localctx, 1) { p.SetState(5233) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87197,7 +87197,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5234) - p.Match(DorisSQLParserIMPERSONATE) + p.Match(StarRocksSQLParserIMPERSONATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87205,7 +87205,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5235) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87213,7 +87213,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5236) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87230,10 +87230,10 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5238) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87253,7 +87253,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5245) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87269,7 +87269,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt p.EnterOuterAlt(localctx, 2) { p.SetState(5248) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87281,7 +87281,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5250) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87293,7 +87293,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5252) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87309,7 +87309,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt p.EnterOuterAlt(localctx, 3) { p.SetState(5255) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87321,7 +87321,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5257) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87334,10 +87334,10 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL { + if _la == StarRocksSQLParserGLOBAL { { p.SetState(5258) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87347,7 +87347,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5261) - p.Match(DorisSQLParserFUNCTION) + p.Match(StarRocksSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87359,7 +87359,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5263) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87375,7 +87375,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt p.EnterOuterAlt(localctx, 4) { p.SetState(5266) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87387,7 +87387,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5268) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87395,7 +87395,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5269) - p.Match(DorisSQLParserSYSTEM) + p.Match(StarRocksSQLParserSYSTEM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87403,7 +87403,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5270) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87419,7 +87419,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt p.EnterOuterAlt(localctx, 5) { p.SetState(5273) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87431,7 +87431,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5275) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87447,7 +87447,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5278) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87463,7 +87463,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt p.EnterOuterAlt(localctx, 6) { p.SetState(5281) - p.Match(DorisSQLParserREVOKE) + p.Match(StarRocksSQLParserREVOKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87475,7 +87475,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5283) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87483,7 +87483,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5284) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87499,7 +87499,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) == 1 { { p.SetState(5286) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87508,7 +87508,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt { p.SetState(5287) - var _m = p.Match(DorisSQLParserALL) + var _m = p.Match(StarRocksSQLParserALL) localctx.(*RevokeOnAllContext).isAll = _m if p.HasError() { @@ -87518,7 +87518,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5288) - p.Match(DorisSQLParserDATABASES) + p.Match(StarRocksSQLParserDATABASES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87530,7 +87530,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) == 2 { { p.SetState(5289) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87538,7 +87538,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5290) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87554,7 +87554,7 @@ func (p *DorisSQLParser) RevokePrivilegeStatement() (localctx IRevokePrivilegeSt } { p.SetState(5294) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87610,13 +87610,13 @@ type ShowGrantsStatementContext struct { func NewEmptyShowGrantsStatementContext() *ShowGrantsStatementContext { var p = new(ShowGrantsStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showGrantsStatement + p.RuleIndex = StarRocksSQLParserRULE_showGrantsStatement return p } func InitEmptyShowGrantsStatementContext(p *ShowGrantsStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showGrantsStatement + p.RuleIndex = StarRocksSQLParserRULE_showGrantsStatement } func (*ShowGrantsStatementContext) IsShowGrantsStatementContext() {} @@ -87627,7 +87627,7 @@ func NewShowGrantsStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showGrantsStatement + p.RuleIndex = StarRocksSQLParserRULE_showGrantsStatement return p } @@ -87635,15 +87635,15 @@ func NewShowGrantsStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ShowGrantsStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowGrantsStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowGrantsStatementContext) GRANTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANTS, 0) + return s.GetToken(StarRocksSQLParserGRANTS, 0) } func (s *ShowGrantsStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *ShowGrantsStatementContext) User() IUserContext { @@ -87663,11 +87663,11 @@ func (s *ShowGrantsStatementContext) User() IUserContext { } func (s *ShowGrantsStatementContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *ShowGrantsStatementContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *ShowGrantsStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -87695,20 +87695,20 @@ func (s *ShowGrantsStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowGrantsStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowGrantsStatement(s) } } func (s *ShowGrantsStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowGrantsStatement(s) } } func (s *ShowGrantsStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowGrantsStatement(s) default: @@ -87716,9 +87716,9 @@ func (s *ShowGrantsStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementContext) { +func (p *StarRocksSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementContext) { localctx = NewShowGrantsStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 616, DorisSQLParserRULE_showGrantsStatement) + p.EnterRule(localctx, 616, StarRocksSQLParserRULE_showGrantsStatement) p.SetState(5313) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -87730,7 +87730,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon p.EnterOuterAlt(localctx, 1) { p.SetState(5299) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87738,7 +87738,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon } { p.SetState(5300) - p.Match(DorisSQLParserGRANTS) + p.Match(StarRocksSQLParserGRANTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87749,7 +87749,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon p.EnterOuterAlt(localctx, 2) { p.SetState(5301) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87757,7 +87757,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon } { p.SetState(5302) - p.Match(DorisSQLParserGRANTS) + p.Match(StarRocksSQLParserGRANTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87765,7 +87765,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon } { p.SetState(5303) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87777,7 +87777,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 559, p.GetParserRuleContext()) == 1 { { p.SetState(5304) - p.Match(DorisSQLParserUSER) + p.Match(StarRocksSQLParserUSER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87796,7 +87796,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon p.EnterOuterAlt(localctx, 3) { p.SetState(5308) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87804,7 +87804,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon } { p.SetState(5309) - p.Match(DorisSQLParserGRANTS) + p.Match(StarRocksSQLParserGRANTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87812,7 +87812,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon } { p.SetState(5310) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87820,7 +87820,7 @@ func (p *DorisSQLParser) ShowGrantsStatement() (localctx IShowGrantsStatementCon } { p.SetState(5311) - p.Match(DorisSQLParserROLE) + p.Match(StarRocksSQLParserROLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -87866,13 +87866,13 @@ type AuthOptionContext struct { func NewEmptyAuthOptionContext() *AuthOptionContext { var p = new(AuthOptionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_authOption + p.RuleIndex = StarRocksSQLParserRULE_authOption return p } func InitEmptyAuthOptionContext(p *AuthOptionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_authOption + p.RuleIndex = StarRocksSQLParserRULE_authOption } func (*AuthOptionContext) IsAuthOptionContext() {} @@ -87883,7 +87883,7 @@ func NewAuthOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_authOption + p.RuleIndex = StarRocksSQLParserRULE_authOption return p } @@ -87921,11 +87921,11 @@ func (s *AuthWithPluginContext) GetRuleContext() antlr.RuleContext { } func (s *AuthWithPluginContext) IDENTIFIED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIDENTIFIED, 0) + return s.GetToken(StarRocksSQLParserIDENTIFIED, 0) } func (s *AuthWithPluginContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *AuthWithPluginContext) IdentifierOrString() IIdentifierOrStringContext { @@ -87961,28 +87961,28 @@ func (s *AuthWithPluginContext) String_() IStringContext { } func (s *AuthWithPluginContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *AuthWithPluginContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *AuthWithPluginContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAuthWithPlugin(s) } } func (s *AuthWithPluginContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAuthWithPlugin(s) } } func (s *AuthWithPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAuthWithPlugin(s) default: @@ -88009,11 +88009,11 @@ func (s *AuthWithoutPluginContext) GetRuleContext() antlr.RuleContext { } func (s *AuthWithoutPluginContext) IDENTIFIED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIDENTIFIED, 0) + return s.GetToken(StarRocksSQLParserIDENTIFIED, 0) } func (s *AuthWithoutPluginContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *AuthWithoutPluginContext) String_() IStringContext { @@ -88033,24 +88033,24 @@ func (s *AuthWithoutPluginContext) String_() IStringContext { } func (s *AuthWithoutPluginContext) PASSWORD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPASSWORD, 0) + return s.GetToken(StarRocksSQLParserPASSWORD, 0) } func (s *AuthWithoutPluginContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAuthWithoutPlugin(s) } } func (s *AuthWithoutPluginContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAuthWithoutPlugin(s) } } func (s *AuthWithoutPluginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAuthWithoutPlugin(s) default: @@ -88058,9 +88058,9 @@ func (s *AuthWithoutPluginContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { +func (p *StarRocksSQLParser) AuthOption() (localctx IAuthOptionContext) { localctx = NewAuthOptionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 618, DorisSQLParserRULE_authOption) + p.EnterRule(localctx, 618, StarRocksSQLParserRULE_authOption) var _la int p.SetState(5328) @@ -88075,7 +88075,7 @@ func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(5315) - p.Match(DorisSQLParserIDENTIFIED) + p.Match(StarRocksSQLParserIDENTIFIED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88083,7 +88083,7 @@ func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { } { p.SetState(5316) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88096,10 +88096,10 @@ func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPASSWORD { + if _la == StarRocksSQLParserPASSWORD { { p.SetState(5317) - p.Match(DorisSQLParserPASSWORD) + p.Match(StarRocksSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88117,7 +88117,7 @@ func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(5321) - p.Match(DorisSQLParserIDENTIFIED) + p.Match(StarRocksSQLParserIDENTIFIED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88125,7 +88125,7 @@ func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { } { p.SetState(5322) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88142,12 +88142,12 @@ func (p *DorisSQLParser) AuthOption() (localctx IAuthOptionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS || _la == DorisSQLParserBY { + if _la == StarRocksSQLParserAS || _la == StarRocksSQLParserBY { { p.SetState(5324) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserAS || _la == DorisSQLParserBY) { + if !(_la == StarRocksSQLParserAS || _la == StarRocksSQLParserBY) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -88201,13 +88201,13 @@ type PrivObjectNameContext struct { func NewEmptyPrivObjectNameContext() *PrivObjectNameContext { var p = new(PrivObjectNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectName + p.RuleIndex = StarRocksSQLParserRULE_privObjectName return p } func InitEmptyPrivObjectNameContext(p *PrivObjectNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectName + p.RuleIndex = StarRocksSQLParserRULE_privObjectName } func (*PrivObjectNameContext) IsPrivObjectNameContext() {} @@ -88218,7 +88218,7 @@ func NewPrivObjectNameContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privObjectName + p.RuleIndex = StarRocksSQLParserRULE_privObjectName return p } @@ -88275,20 +88275,20 @@ func (s *PrivObjectNameContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *PrivObjectNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivObjectName(s) } } func (s *PrivObjectNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivObjectName(s) } } func (s *PrivObjectNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivObjectName(s) default: @@ -88296,9 +88296,9 @@ func (s *PrivObjectNameContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) PrivObjectName() (localctx IPrivObjectNameContext) { +func (p *StarRocksSQLParser) PrivObjectName() (localctx IPrivObjectNameContext) { localctx = NewPrivObjectNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 620, DorisSQLParserRULE_privObjectName) + p.EnterRule(localctx, 620, StarRocksSQLParserRULE_privObjectName) var _la int p.EnterOuterAlt(localctx, 1) @@ -88313,10 +88313,10 @@ func (p *DorisSQLParser) PrivObjectName() (localctx IPrivObjectNameContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__0 { + if _la == StarRocksSQLParserT__0 { { p.SetState(5331) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88365,13 +88365,13 @@ type PrivObjectNameListContext struct { func NewEmptyPrivObjectNameListContext() *PrivObjectNameListContext { var p = new(PrivObjectNameListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectNameList + p.RuleIndex = StarRocksSQLParserRULE_privObjectNameList return p } func InitEmptyPrivObjectNameListContext(p *PrivObjectNameListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectNameList + p.RuleIndex = StarRocksSQLParserRULE_privObjectNameList } func (*PrivObjectNameListContext) IsPrivObjectNameListContext() {} @@ -88382,7 +88382,7 @@ func NewPrivObjectNameListContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privObjectNameList + p.RuleIndex = StarRocksSQLParserRULE_privObjectNameList return p } @@ -88439,20 +88439,20 @@ func (s *PrivObjectNameListContext) ToStringTree(ruleNames []string, recog antlr } func (s *PrivObjectNameListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivObjectNameList(s) } } func (s *PrivObjectNameListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivObjectNameList(s) } } func (s *PrivObjectNameListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivObjectNameList(s) default: @@ -88460,9 +88460,9 @@ func (s *PrivObjectNameListContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) PrivObjectNameList() (localctx IPrivObjectNameListContext) { +func (p *StarRocksSQLParser) PrivObjectNameList() (localctx IPrivObjectNameListContext) { localctx = NewPrivObjectNameListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 622, DorisSQLParserRULE_privObjectNameList) + p.EnterRule(localctx, 622, StarRocksSQLParserRULE_privObjectNameList) var _la int p.EnterOuterAlt(localctx, 1) @@ -88477,10 +88477,10 @@ func (p *DorisSQLParser) PrivObjectNameList() (localctx IPrivObjectNameListConte } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5336) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88537,13 +88537,13 @@ type PrivFunctionObjectNameListContext struct { func NewEmptyPrivFunctionObjectNameListContext() *PrivFunctionObjectNameListContext { var p = new(PrivFunctionObjectNameListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privFunctionObjectNameList + p.RuleIndex = StarRocksSQLParserRULE_privFunctionObjectNameList return p } func InitEmptyPrivFunctionObjectNameListContext(p *PrivFunctionObjectNameListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privFunctionObjectNameList + p.RuleIndex = StarRocksSQLParserRULE_privFunctionObjectNameList } func (*PrivFunctionObjectNameListContext) IsPrivFunctionObjectNameListContext() {} @@ -88554,7 +88554,7 @@ func NewPrivFunctionObjectNameListContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privFunctionObjectNameList + p.RuleIndex = StarRocksSQLParserRULE_privFunctionObjectNameList return p } @@ -88652,20 +88652,20 @@ func (s *PrivFunctionObjectNameListContext) ToStringTree(ruleNames []string, rec } func (s *PrivFunctionObjectNameListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivFunctionObjectNameList(s) } } func (s *PrivFunctionObjectNameListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivFunctionObjectNameList(s) } } func (s *PrivFunctionObjectNameListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivFunctionObjectNameList(s) default: @@ -88673,9 +88673,9 @@ func (s *PrivFunctionObjectNameListContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObjectNameListContext) { +func (p *StarRocksSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObjectNameListContext) { localctx = NewPrivFunctionObjectNameListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 624, DorisSQLParserRULE_privFunctionObjectNameList) + p.EnterRule(localctx, 624, StarRocksSQLParserRULE_privFunctionObjectNameList) var _la int p.EnterOuterAlt(localctx, 1) @@ -88685,7 +88685,7 @@ func (p *DorisSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObj } { p.SetState(5344) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88697,7 +88697,7 @@ func (p *DorisSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObj } { p.SetState(5346) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88710,10 +88710,10 @@ func (p *DorisSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObj } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5347) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88725,7 +88725,7 @@ func (p *DorisSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObj } { p.SetState(5349) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88737,7 +88737,7 @@ func (p *DorisSQLParser) PrivFunctionObjectNameList() (localctx IPrivFunctionObj } { p.SetState(5351) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88788,13 +88788,13 @@ type PrivilegeTypeListContext struct { func NewEmptyPrivilegeTypeListContext() *PrivilegeTypeListContext { var p = new(PrivilegeTypeListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privilegeTypeList + p.RuleIndex = StarRocksSQLParserRULE_privilegeTypeList return p } func InitEmptyPrivilegeTypeListContext(p *PrivilegeTypeListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privilegeTypeList + p.RuleIndex = StarRocksSQLParserRULE_privilegeTypeList } func (*PrivilegeTypeListContext) IsPrivilegeTypeListContext() {} @@ -88805,7 +88805,7 @@ func NewPrivilegeTypeListContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privilegeTypeList + p.RuleIndex = StarRocksSQLParserRULE_privilegeTypeList return p } @@ -88862,20 +88862,20 @@ func (s *PrivilegeTypeListContext) ToStringTree(ruleNames []string, recog antlr. } func (s *PrivilegeTypeListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivilegeTypeList(s) } } func (s *PrivilegeTypeListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivilegeTypeList(s) } } func (s *PrivilegeTypeListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivilegeTypeList(s) default: @@ -88883,9 +88883,9 @@ func (s *PrivilegeTypeListContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) PrivilegeTypeList() (localctx IPrivilegeTypeListContext) { +func (p *StarRocksSQLParser) PrivilegeTypeList() (localctx IPrivilegeTypeListContext) { localctx = NewPrivilegeTypeListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 626, DorisSQLParserRULE_privilegeTypeList) + p.EnterRule(localctx, 626, StarRocksSQLParserRULE_privilegeTypeList) var _la int p.EnterOuterAlt(localctx, 1) @@ -88900,10 +88900,10 @@ func (p *DorisSQLParser) PrivilegeTypeList() (localctx IPrivilegeTypeListContext } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5359) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -88992,13 +88992,13 @@ type PrivilegeTypeContext struct { func NewEmptyPrivilegeTypeContext() *PrivilegeTypeContext { var p = new(PrivilegeTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privilegeType + p.RuleIndex = StarRocksSQLParserRULE_privilegeType return p } func InitEmptyPrivilegeTypeContext(p *PrivilegeTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privilegeType + p.RuleIndex = StarRocksSQLParserRULE_privilegeType } func (*PrivilegeTypeContext) IsPrivilegeTypeContext() {} @@ -89009,7 +89009,7 @@ func NewPrivilegeTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privilegeType + p.RuleIndex = StarRocksSQLParserRULE_privilegeType return p } @@ -89017,147 +89017,147 @@ func NewPrivilegeTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *PrivilegeTypeContext) GetParser() antlr.Parser { return s.parser } func (s *PrivilegeTypeContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *PrivilegeTypeContext) PRIVILEGES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIVILEGES, 0) + return s.GetToken(StarRocksSQLParserPRIVILEGES, 0) } func (s *PrivilegeTypeContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *PrivilegeTypeContext) APPLY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAPPLY, 0) + return s.GetToken(StarRocksSQLParserAPPLY, 0) } func (s *PrivilegeTypeContext) BLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserBLACKLIST, 0) } func (s *PrivilegeTypeContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *PrivilegeTypeContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *PrivilegeTypeContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *PrivilegeTypeContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *PrivilegeTypeContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *PrivilegeTypeContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *PrivilegeTypeContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *PrivilegeTypeContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *PrivilegeTypeContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *PrivilegeTypeContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *PrivilegeTypeContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *PrivilegeTypeContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *PrivilegeTypeContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *PrivilegeTypeContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *PrivilegeTypeContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *PrivilegeTypeContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *PrivilegeTypeContext) DELETE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDELETE, 0) + return s.GetToken(StarRocksSQLParserDELETE, 0) } func (s *PrivilegeTypeContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *PrivilegeTypeContext) EXPORT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPORT, 0) + return s.GetToken(StarRocksSQLParserEXPORT, 0) } func (s *PrivilegeTypeContext) FILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILE, 0) + return s.GetToken(StarRocksSQLParserFILE, 0) } func (s *PrivilegeTypeContext) IMPERSONATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMPERSONATE, 0) + return s.GetToken(StarRocksSQLParserIMPERSONATE, 0) } func (s *PrivilegeTypeContext) INSERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINSERT, 0) + return s.GetToken(StarRocksSQLParserINSERT, 0) } func (s *PrivilegeTypeContext) GRANT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANT, 0) + return s.GetToken(StarRocksSQLParserGRANT, 0) } func (s *PrivilegeTypeContext) NODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODE, 0) + return s.GetToken(StarRocksSQLParserNODE, 0) } func (s *PrivilegeTypeContext) OPERATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPERATE, 0) + return s.GetToken(StarRocksSQLParserOPERATE, 0) } func (s *PrivilegeTypeContext) PLUGIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUGIN, 0) + return s.GetToken(StarRocksSQLParserPLUGIN, 0) } func (s *PrivilegeTypeContext) REPOSITORY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORY, 0) + return s.GetToken(StarRocksSQLParserREPOSITORY, 0) } func (s *PrivilegeTypeContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *PrivilegeTypeContext) SELECT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSELECT, 0) + return s.GetToken(StarRocksSQLParserSELECT, 0) } func (s *PrivilegeTypeContext) UPDATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUPDATE, 0) + return s.GetToken(StarRocksSQLParserUPDATE, 0) } func (s *PrivilegeTypeContext) USAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSAGE, 0) + return s.GetToken(StarRocksSQLParserUSAGE, 0) } func (s *PrivilegeTypeContext) GetRuleContext() antlr.RuleContext { @@ -89169,20 +89169,20 @@ func (s *PrivilegeTypeContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *PrivilegeTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivilegeType(s) } } func (s *PrivilegeTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivilegeType(s) } } func (s *PrivilegeTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivilegeType(s) default: @@ -89190,9 +89190,9 @@ func (s *PrivilegeTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { +func (p *StarRocksSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { localctx = NewPrivilegeTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 628, DorisSQLParserRULE_privilegeType) + p.EnterRule(localctx, 628, StarRocksSQLParserRULE_privilegeType) var _la int p.SetState(5409) @@ -89202,11 +89202,11 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: p.EnterOuterAlt(localctx, 1) { p.SetState(5366) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89219,10 +89219,10 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPRIVILEGES { + if _la == StarRocksSQLParserPRIVILEGES { { p.SetState(5367) - p.Match(DorisSQLParserPRIVILEGES) + p.Match(StarRocksSQLParserPRIVILEGES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89231,44 +89231,44 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } - case DorisSQLParserALTER: + case StarRocksSQLParserALTER: p.EnterOuterAlt(localctx, 2) { p.SetState(5370) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserAPPLY: + case StarRocksSQLParserAPPLY: p.EnterOuterAlt(localctx, 3) { p.SetState(5371) - p.Match(DorisSQLParserAPPLY) + p.Match(StarRocksSQLParserAPPLY) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserBLACKLIST: + case StarRocksSQLParserBLACKLIST: p.EnterOuterAlt(localctx, 4) { p.SetState(5372) - p.Match(DorisSQLParserBLACKLIST) + p.Match(StarRocksSQLParserBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCREATE: + case StarRocksSQLParserCREATE: p.EnterOuterAlt(localctx, 5) { p.SetState(5373) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89284,7 +89284,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 1: { p.SetState(5374) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89294,7 +89294,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 2: { p.SetState(5375) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89304,7 +89304,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 3: { p.SetState(5376) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89314,7 +89314,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 4: { p.SetState(5377) - p.Match(DorisSQLParserFUNCTION) + p.Match(StarRocksSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89324,7 +89324,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 5: { p.SetState(5378) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89332,7 +89332,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } { p.SetState(5379) - p.Match(DorisSQLParserFUNCTION) + p.Match(StarRocksSQLParserFUNCTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89342,7 +89342,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 6: { p.SetState(5380) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89350,7 +89350,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } { p.SetState(5381) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89360,7 +89360,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 7: { p.SetState(5382) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89370,7 +89370,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 8: { p.SetState(5383) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89378,7 +89378,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } { p.SetState(5384) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89388,7 +89388,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 9: { p.SetState(5385) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89396,7 +89396,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } { p.SetState(5386) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89406,7 +89406,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 10: { p.SetState(5387) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89414,7 +89414,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { } { p.SetState(5388) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89424,7 +89424,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 11: { p.SetState(5389) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89434,7 +89434,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 12: { p.SetState(5390) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89444,7 +89444,7 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { case 13: { p.SetState(5391) - p.Match(DorisSQLParserPIPE) + p.Match(StarRocksSQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89455,165 +89455,165 @@ func (p *DorisSQLParser) PrivilegeType() (localctx IPrivilegeTypeContext) { goto errorExit } - case DorisSQLParserDELETE: + case StarRocksSQLParserDELETE: p.EnterOuterAlt(localctx, 6) { p.SetState(5394) - p.Match(DorisSQLParserDELETE) + p.Match(StarRocksSQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDROP: + case StarRocksSQLParserDROP: p.EnterOuterAlt(localctx, 7) { p.SetState(5395) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserEXPORT: + case StarRocksSQLParserEXPORT: p.EnterOuterAlt(localctx, 8) { p.SetState(5396) - p.Match(DorisSQLParserEXPORT) + p.Match(StarRocksSQLParserEXPORT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserFILE: + case StarRocksSQLParserFILE: p.EnterOuterAlt(localctx, 9) { p.SetState(5397) - p.Match(DorisSQLParserFILE) + p.Match(StarRocksSQLParserFILE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserIMPERSONATE: + case StarRocksSQLParserIMPERSONATE: p.EnterOuterAlt(localctx, 10) { p.SetState(5398) - p.Match(DorisSQLParserIMPERSONATE) + p.Match(StarRocksSQLParserIMPERSONATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserINSERT: + case StarRocksSQLParserINSERT: p.EnterOuterAlt(localctx, 11) { p.SetState(5399) - p.Match(DorisSQLParserINSERT) + p.Match(StarRocksSQLParserINSERT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserGRANT: + case StarRocksSQLParserGRANT: p.EnterOuterAlt(localctx, 12) { p.SetState(5400) - p.Match(DorisSQLParserGRANT) + p.Match(StarRocksSQLParserGRANT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserNODE: + case StarRocksSQLParserNODE: p.EnterOuterAlt(localctx, 13) { p.SetState(5401) - p.Match(DorisSQLParserNODE) + p.Match(StarRocksSQLParserNODE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserOPERATE: + case StarRocksSQLParserOPERATE: p.EnterOuterAlt(localctx, 14) { p.SetState(5402) - p.Match(DorisSQLParserOPERATE) + p.Match(StarRocksSQLParserOPERATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserPLUGIN: + case StarRocksSQLParserPLUGIN: p.EnterOuterAlt(localctx, 15) { p.SetState(5403) - p.Match(DorisSQLParserPLUGIN) + p.Match(StarRocksSQLParserPLUGIN) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserREPOSITORY: + case StarRocksSQLParserREPOSITORY: p.EnterOuterAlt(localctx, 16) { p.SetState(5404) - p.Match(DorisSQLParserREPOSITORY) + p.Match(StarRocksSQLParserREPOSITORY) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserREFRESH: + case StarRocksSQLParserREFRESH: p.EnterOuterAlt(localctx, 17) { p.SetState(5405) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserSELECT: + case StarRocksSQLParserSELECT: p.EnterOuterAlt(localctx, 18) { p.SetState(5406) - p.Match(DorisSQLParserSELECT) + p.Match(StarRocksSQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserUPDATE: + case StarRocksSQLParserUPDATE: p.EnterOuterAlt(localctx, 19) { p.SetState(5407) - p.Match(DorisSQLParserUPDATE) + p.Match(StarRocksSQLParserUPDATE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserUSAGE: + case StarRocksSQLParserUSAGE: p.EnterOuterAlt(localctx, 20) { p.SetState(5408) - p.Match(DorisSQLParserUSAGE) + p.Match(StarRocksSQLParserUSAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89671,13 +89671,13 @@ type PrivObjectTypeContext struct { func NewEmptyPrivObjectTypeContext() *PrivObjectTypeContext { var p = new(PrivObjectTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectType + p.RuleIndex = StarRocksSQLParserRULE_privObjectType return p } func InitEmptyPrivObjectTypeContext(p *PrivObjectTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectType + p.RuleIndex = StarRocksSQLParserRULE_privObjectType } func (*PrivObjectTypeContext) IsPrivObjectTypeContext() {} @@ -89688,7 +89688,7 @@ func NewPrivObjectTypeContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privObjectType + p.RuleIndex = StarRocksSQLParserRULE_privObjectType return p } @@ -89696,51 +89696,51 @@ func NewPrivObjectTypeContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *PrivObjectTypeContext) GetParser() antlr.Parser { return s.parser } func (s *PrivObjectTypeContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *PrivObjectTypeContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *PrivObjectTypeContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *PrivObjectTypeContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *PrivObjectTypeContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *PrivObjectTypeContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *PrivObjectTypeContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *PrivObjectTypeContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *PrivObjectTypeContext) SYSTEM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYSTEM, 0) + return s.GetToken(StarRocksSQLParserSYSTEM, 0) } func (s *PrivObjectTypeContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *PrivObjectTypeContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *PrivObjectTypeContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *PrivObjectTypeContext) GetRuleContext() antlr.RuleContext { @@ -89752,20 +89752,20 @@ func (s *PrivObjectTypeContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *PrivObjectTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivObjectType(s) } } func (s *PrivObjectTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivObjectType(s) } } func (s *PrivObjectTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivObjectType(s) default: @@ -89773,9 +89773,9 @@ func (s *PrivObjectTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { +func (p *StarRocksSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { localctx = NewPrivObjectTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 630, DorisSQLParserRULE_privObjectType) + p.EnterRule(localctx, 630, StarRocksSQLParserRULE_privObjectType) p.SetState(5425) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -89787,7 +89787,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(5411) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89798,7 +89798,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(5412) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89809,7 +89809,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(5413) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89817,7 +89817,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { } { p.SetState(5414) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89828,7 +89828,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(5415) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89839,7 +89839,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 5) { p.SetState(5416) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89847,7 +89847,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { } { p.SetState(5417) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89858,7 +89858,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 6) { p.SetState(5418) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89866,7 +89866,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { } { p.SetState(5419) - p.Match(DorisSQLParserVOLUME) + p.Match(StarRocksSQLParserVOLUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89877,7 +89877,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 7) { p.SetState(5420) - p.Match(DorisSQLParserSYSTEM) + p.Match(StarRocksSQLParserSYSTEM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89888,7 +89888,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 8) { p.SetState(5421) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89899,7 +89899,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 9) { p.SetState(5422) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89910,7 +89910,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 10) { p.SetState(5423) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89921,7 +89921,7 @@ func (p *DorisSQLParser) PrivObjectType() (localctx IPrivObjectTypeContext) { p.EnterOuterAlt(localctx, 11) { p.SetState(5424) - p.Match(DorisSQLParserPIPE) + p.Match(StarRocksSQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -89982,13 +89982,13 @@ type PrivObjectTypePluralContext struct { func NewEmptyPrivObjectTypePluralContext() *PrivObjectTypePluralContext { var p = new(PrivObjectTypePluralContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectTypePlural + p.RuleIndex = StarRocksSQLParserRULE_privObjectTypePlural return p } func InitEmptyPrivObjectTypePluralContext(p *PrivObjectTypePluralContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_privObjectTypePlural + p.RuleIndex = StarRocksSQLParserRULE_privObjectTypePlural } func (*PrivObjectTypePluralContext) IsPrivObjectTypePluralContext() {} @@ -89999,7 +89999,7 @@ func NewPrivObjectTypePluralContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_privObjectTypePlural + p.RuleIndex = StarRocksSQLParserRULE_privObjectTypePlural return p } @@ -90007,67 +90007,67 @@ func NewPrivObjectTypePluralContext(parser antlr.Parser, parent antlr.ParserRule func (s *PrivObjectTypePluralContext) GetParser() antlr.Parser { return s.parser } func (s *PrivObjectTypePluralContext) CATALOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOGS, 0) + return s.GetToken(StarRocksSQLParserCATALOGS, 0) } func (s *PrivObjectTypePluralContext) DATABASES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASES, 0) + return s.GetToken(StarRocksSQLParserDATABASES, 0) } func (s *PrivObjectTypePluralContext) FUNCTIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTIONS, 0) + return s.GetToken(StarRocksSQLParserFUNCTIONS, 0) } func (s *PrivObjectTypePluralContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *PrivObjectTypePluralContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *PrivObjectTypePluralContext) VIEWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEWS, 0) + return s.GetToken(StarRocksSQLParserVIEWS, 0) } func (s *PrivObjectTypePluralContext) POLICIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPOLICIES, 0) + return s.GetToken(StarRocksSQLParserPOLICIES, 0) } func (s *PrivObjectTypePluralContext) RESOURCES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCES, 0) + return s.GetToken(StarRocksSQLParserRESOURCES, 0) } func (s *PrivObjectTypePluralContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *PrivObjectTypePluralContext) GROUPS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPS, 0) + return s.GetToken(StarRocksSQLParserGROUPS, 0) } func (s *PrivObjectTypePluralContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *PrivObjectTypePluralContext) VOLUMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUMES, 0) + return s.GetToken(StarRocksSQLParserVOLUMES, 0) } func (s *PrivObjectTypePluralContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *PrivObjectTypePluralContext) USERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSERS, 0) + return s.GetToken(StarRocksSQLParserUSERS, 0) } func (s *PrivObjectTypePluralContext) WAREHOUSES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSES, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSES, 0) } func (s *PrivObjectTypePluralContext) PIPES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPES, 0) + return s.GetToken(StarRocksSQLParserPIPES, 0) } func (s *PrivObjectTypePluralContext) GetRuleContext() antlr.RuleContext { @@ -90079,20 +90079,20 @@ func (s *PrivObjectTypePluralContext) ToStringTree(ruleNames []string, recog ant } func (s *PrivObjectTypePluralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrivObjectTypePlural(s) } } func (s *PrivObjectTypePluralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrivObjectTypePlural(s) } } func (s *PrivObjectTypePluralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrivObjectTypePlural(s) default: @@ -90100,9 +90100,9 @@ func (s *PrivObjectTypePluralContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralContext) { +func (p *StarRocksSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralContext) { localctx = NewPrivObjectTypePluralContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 632, DorisSQLParserRULE_privObjectTypePlural) + p.EnterRule(localctx, 632, StarRocksSQLParserRULE_privObjectTypePlural) p.SetState(5445) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -90110,44 +90110,44 @@ func (p *DorisSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCATALOGS: + case StarRocksSQLParserCATALOGS: p.EnterOuterAlt(localctx, 1) { p.SetState(5427) - p.Match(DorisSQLParserCATALOGS) + p.Match(StarRocksSQLParserCATALOGS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDATABASES: + case StarRocksSQLParserDATABASES: p.EnterOuterAlt(localctx, 2) { p.SetState(5428) - p.Match(DorisSQLParserDATABASES) + p.Match(StarRocksSQLParserDATABASES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserFUNCTIONS: + case StarRocksSQLParserFUNCTIONS: p.EnterOuterAlt(localctx, 3) { p.SetState(5429) - p.Match(DorisSQLParserFUNCTIONS) + p.Match(StarRocksSQLParserFUNCTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserGLOBAL: + case StarRocksSQLParserGLOBAL: p.EnterOuterAlt(localctx, 4) { p.SetState(5430) - p.Match(DorisSQLParserGLOBAL) + p.Match(StarRocksSQLParserGLOBAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90155,18 +90155,18 @@ func (p *DorisSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralC } { p.SetState(5431) - p.Match(DorisSQLParserFUNCTIONS) + p.Match(StarRocksSQLParserFUNCTIONS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserMATERIALIZED: + case StarRocksSQLParserMATERIALIZED: p.EnterOuterAlt(localctx, 5) { p.SetState(5432) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90174,40 +90174,40 @@ func (p *DorisSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralC } { p.SetState(5433) - p.Match(DorisSQLParserVIEWS) + p.Match(StarRocksSQLParserVIEWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserPOLICIES: + case StarRocksSQLParserPOLICIES: p.EnterOuterAlt(localctx, 6) { p.SetState(5434) - p.Match(DorisSQLParserPOLICIES) + p.Match(StarRocksSQLParserPOLICIES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserRESOURCES: + case StarRocksSQLParserRESOURCES: p.EnterOuterAlt(localctx, 7) { p.SetState(5435) - p.Match(DorisSQLParserRESOURCES) + p.Match(StarRocksSQLParserRESOURCES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserRESOURCE: + case StarRocksSQLParserRESOURCE: p.EnterOuterAlt(localctx, 8) { p.SetState(5436) - p.Match(DorisSQLParserRESOURCE) + p.Match(StarRocksSQLParserRESOURCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90215,18 +90215,18 @@ func (p *DorisSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralC } { p.SetState(5437) - p.Match(DorisSQLParserGROUPS) + p.Match(StarRocksSQLParserGROUPS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserSTORAGE: + case StarRocksSQLParserSTORAGE: p.EnterOuterAlt(localctx, 9) { p.SetState(5438) - p.Match(DorisSQLParserSTORAGE) + p.Match(StarRocksSQLParserSTORAGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90234,62 +90234,62 @@ func (p *DorisSQLParser) PrivObjectTypePlural() (localctx IPrivObjectTypePluralC } { p.SetState(5439) - p.Match(DorisSQLParserVOLUMES) + p.Match(StarRocksSQLParserVOLUMES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserTABLES: + case StarRocksSQLParserTABLES: p.EnterOuterAlt(localctx, 10) { p.SetState(5440) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserUSERS: + case StarRocksSQLParserUSERS: p.EnterOuterAlt(localctx, 11) { p.SetState(5441) - p.Match(DorisSQLParserUSERS) + p.Match(StarRocksSQLParserUSERS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserVIEWS: + case StarRocksSQLParserVIEWS: p.EnterOuterAlt(localctx, 12) { p.SetState(5442) - p.Match(DorisSQLParserVIEWS) + p.Match(StarRocksSQLParserVIEWS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserWAREHOUSES: + case StarRocksSQLParserWAREHOUSES: p.EnterOuterAlt(localctx, 13) { p.SetState(5443) - p.Match(DorisSQLParserWAREHOUSES) + p.Match(StarRocksSQLParserWAREHOUSES) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserPIPES: + case StarRocksSQLParserPIPES: p.EnterOuterAlt(localctx, 14) { p.SetState(5444) - p.Match(DorisSQLParserPIPES) + p.Match(StarRocksSQLParserPIPES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90340,13 +90340,13 @@ type CreateSecurityIntegrationStatementContext struct { func NewEmptyCreateSecurityIntegrationStatementContext() *CreateSecurityIntegrationStatementContext { var p = new(CreateSecurityIntegrationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_createSecurityIntegrationStatement return p } func InitEmptyCreateSecurityIntegrationStatementContext(p *CreateSecurityIntegrationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_createSecurityIntegrationStatement } func (*CreateSecurityIntegrationStatementContext) IsCreateSecurityIntegrationStatementContext() {} @@ -90357,7 +90357,7 @@ func NewCreateSecurityIntegrationStatementContext(parser antlr.Parser, parent an antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_createSecurityIntegrationStatement return p } @@ -90365,15 +90365,15 @@ func NewCreateSecurityIntegrationStatementContext(parser antlr.Parser, parent an func (s *CreateSecurityIntegrationStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateSecurityIntegrationStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateSecurityIntegrationStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *CreateSecurityIntegrationStatementContext) INTEGRATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATION, 0) + return s.GetToken(StarRocksSQLParserINTEGRATION, 0) } func (s *CreateSecurityIntegrationStatementContext) Identifier() IIdentifierContext { @@ -90417,20 +90417,20 @@ func (s *CreateSecurityIntegrationStatementContext) ToStringTree(ruleNames []str } func (s *CreateSecurityIntegrationStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateSecurityIntegrationStatement(s) } } func (s *CreateSecurityIntegrationStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateSecurityIntegrationStatement(s) } } func (s *CreateSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateSecurityIntegrationStatement(s) default: @@ -90438,13 +90438,13 @@ func (s *CreateSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTr } } -func (p *DorisSQLParser) CreateSecurityIntegrationStatement() (localctx ICreateSecurityIntegrationStatementContext) { +func (p *StarRocksSQLParser) CreateSecurityIntegrationStatement() (localctx ICreateSecurityIntegrationStatementContext) { localctx = NewCreateSecurityIntegrationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 634, DorisSQLParserRULE_createSecurityIntegrationStatement) + p.EnterRule(localctx, 634, StarRocksSQLParserRULE_createSecurityIntegrationStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5447) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90452,7 +90452,7 @@ func (p *DorisSQLParser) CreateSecurityIntegrationStatement() (localctx ICreateS } { p.SetState(5448) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90460,7 +90460,7 @@ func (p *DorisSQLParser) CreateSecurityIntegrationStatement() (localctx ICreateS } { p.SetState(5449) - p.Match(DorisSQLParserINTEGRATION) + p.Match(StarRocksSQLParserINTEGRATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90515,13 +90515,13 @@ type AlterSecurityIntegrationStatementContext struct { func NewEmptyAlterSecurityIntegrationStatementContext() *AlterSecurityIntegrationStatementContext { var p = new(AlterSecurityIntegrationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_alterSecurityIntegrationStatement return p } func InitEmptyAlterSecurityIntegrationStatementContext(p *AlterSecurityIntegrationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_alterSecurityIntegrationStatement } func (*AlterSecurityIntegrationStatementContext) IsAlterSecurityIntegrationStatementContext() {} @@ -90532,7 +90532,7 @@ func NewAlterSecurityIntegrationStatementContext(parser antlr.Parser, parent ant antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_alterSecurityIntegrationStatement return p } @@ -90540,15 +90540,15 @@ func NewAlterSecurityIntegrationStatementContext(parser antlr.Parser, parent ant func (s *AlterSecurityIntegrationStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterSecurityIntegrationStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterSecurityIntegrationStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *AlterSecurityIntegrationStatementContext) INTEGRATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATION, 0) + return s.GetToken(StarRocksSQLParserINTEGRATION, 0) } func (s *AlterSecurityIntegrationStatementContext) Identifier() IIdentifierContext { @@ -90568,7 +90568,7 @@ func (s *AlterSecurityIntegrationStatementContext) Identifier() IIdentifierConte } func (s *AlterSecurityIntegrationStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterSecurityIntegrationStatementContext) PropertyList() IPropertyListContext { @@ -90596,20 +90596,20 @@ func (s *AlterSecurityIntegrationStatementContext) ToStringTree(ruleNames []stri } func (s *AlterSecurityIntegrationStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterSecurityIntegrationStatement(s) } } func (s *AlterSecurityIntegrationStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterSecurityIntegrationStatement(s) } } func (s *AlterSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterSecurityIntegrationStatement(s) default: @@ -90617,13 +90617,13 @@ func (s *AlterSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTre } } -func (p *DorisSQLParser) AlterSecurityIntegrationStatement() (localctx IAlterSecurityIntegrationStatementContext) { +func (p *StarRocksSQLParser) AlterSecurityIntegrationStatement() (localctx IAlterSecurityIntegrationStatementContext) { localctx = NewAlterSecurityIntegrationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 636, DorisSQLParserRULE_alterSecurityIntegrationStatement) + p.EnterRule(localctx, 636, StarRocksSQLParserRULE_alterSecurityIntegrationStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5453) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90631,7 +90631,7 @@ func (p *DorisSQLParser) AlterSecurityIntegrationStatement() (localctx IAlterSec } { p.SetState(5454) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90639,7 +90639,7 @@ func (p *DorisSQLParser) AlterSecurityIntegrationStatement() (localctx IAlterSec } { p.SetState(5455) - p.Match(DorisSQLParserINTEGRATION) + p.Match(StarRocksSQLParserINTEGRATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90651,7 +90651,7 @@ func (p *DorisSQLParser) AlterSecurityIntegrationStatement() (localctx IAlterSec } { p.SetState(5457) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90700,13 +90700,13 @@ type DropSecurityIntegrationStatementContext struct { func NewEmptyDropSecurityIntegrationStatementContext() *DropSecurityIntegrationStatementContext { var p = new(DropSecurityIntegrationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_dropSecurityIntegrationStatement return p } func InitEmptyDropSecurityIntegrationStatementContext(p *DropSecurityIntegrationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_dropSecurityIntegrationStatement } func (*DropSecurityIntegrationStatementContext) IsDropSecurityIntegrationStatementContext() {} @@ -90717,7 +90717,7 @@ func NewDropSecurityIntegrationStatementContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_dropSecurityIntegrationStatement return p } @@ -90725,15 +90725,15 @@ func NewDropSecurityIntegrationStatementContext(parser antlr.Parser, parent antl func (s *DropSecurityIntegrationStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropSecurityIntegrationStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropSecurityIntegrationStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *DropSecurityIntegrationStatementContext) INTEGRATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATION, 0) + return s.GetToken(StarRocksSQLParserINTEGRATION, 0) } func (s *DropSecurityIntegrationStatementContext) Identifier() IIdentifierContext { @@ -90761,20 +90761,20 @@ func (s *DropSecurityIntegrationStatementContext) ToStringTree(ruleNames []strin } func (s *DropSecurityIntegrationStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropSecurityIntegrationStatement(s) } } func (s *DropSecurityIntegrationStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropSecurityIntegrationStatement(s) } } func (s *DropSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropSecurityIntegrationStatement(s) default: @@ -90782,13 +90782,13 @@ func (s *DropSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) DropSecurityIntegrationStatement() (localctx IDropSecurityIntegrationStatementContext) { +func (p *StarRocksSQLParser) DropSecurityIntegrationStatement() (localctx IDropSecurityIntegrationStatementContext) { localctx = NewDropSecurityIntegrationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 638, DorisSQLParserRULE_dropSecurityIntegrationStatement) + p.EnterRule(localctx, 638, StarRocksSQLParserRULE_dropSecurityIntegrationStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5460) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90796,7 +90796,7 @@ func (p *DorisSQLParser) DropSecurityIntegrationStatement() (localctx IDropSecur } { p.SetState(5461) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90804,7 +90804,7 @@ func (p *DorisSQLParser) DropSecurityIntegrationStatement() (localctx IDropSecur } { p.SetState(5462) - p.Match(DorisSQLParserINTEGRATION) + p.Match(StarRocksSQLParserINTEGRATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90852,13 +90852,13 @@ type ShowSecurityIntegrationStatementContext struct { func NewEmptyShowSecurityIntegrationStatementContext() *ShowSecurityIntegrationStatementContext { var p = new(ShowSecurityIntegrationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_showSecurityIntegrationStatement return p } func InitEmptyShowSecurityIntegrationStatementContext(p *ShowSecurityIntegrationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_showSecurityIntegrationStatement } func (*ShowSecurityIntegrationStatementContext) IsShowSecurityIntegrationStatementContext() {} @@ -90869,7 +90869,7 @@ func NewShowSecurityIntegrationStatementContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_showSecurityIntegrationStatement return p } @@ -90877,15 +90877,15 @@ func NewShowSecurityIntegrationStatementContext(parser antlr.Parser, parent antl func (s *ShowSecurityIntegrationStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowSecurityIntegrationStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowSecurityIntegrationStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *ShowSecurityIntegrationStatementContext) INTEGRATIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATIONS, 0) + return s.GetToken(StarRocksSQLParserINTEGRATIONS, 0) } func (s *ShowSecurityIntegrationStatementContext) GetRuleContext() antlr.RuleContext { @@ -90897,20 +90897,20 @@ func (s *ShowSecurityIntegrationStatementContext) ToStringTree(ruleNames []strin } func (s *ShowSecurityIntegrationStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowSecurityIntegrationStatement(s) } } func (s *ShowSecurityIntegrationStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowSecurityIntegrationStatement(s) } } func (s *ShowSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowSecurityIntegrationStatement(s) default: @@ -90918,13 +90918,13 @@ func (s *ShowSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) ShowSecurityIntegrationStatement() (localctx IShowSecurityIntegrationStatementContext) { +func (p *StarRocksSQLParser) ShowSecurityIntegrationStatement() (localctx IShowSecurityIntegrationStatementContext) { localctx = NewShowSecurityIntegrationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 640, DorisSQLParserRULE_showSecurityIntegrationStatement) + p.EnterRule(localctx, 640, StarRocksSQLParserRULE_showSecurityIntegrationStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5465) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90932,7 +90932,7 @@ func (p *DorisSQLParser) ShowSecurityIntegrationStatement() (localctx IShowSecur } { p.SetState(5466) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90940,7 +90940,7 @@ func (p *DorisSQLParser) ShowSecurityIntegrationStatement() (localctx IShowSecur } { p.SetState(5467) - p.Match(DorisSQLParserINTEGRATIONS) + p.Match(StarRocksSQLParserINTEGRATIONS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -90986,13 +90986,13 @@ type ShowCreateSecurityIntegrationStatementContext struct { func NewEmptyShowCreateSecurityIntegrationStatementContext() *ShowCreateSecurityIntegrationStatementContext { var p = new(ShowCreateSecurityIntegrationStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateSecurityIntegrationStatement return p } func InitEmptyShowCreateSecurityIntegrationStatementContext(p *ShowCreateSecurityIntegrationStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateSecurityIntegrationStatement } func (*ShowCreateSecurityIntegrationStatementContext) IsShowCreateSecurityIntegrationStatementContext() { @@ -91004,7 +91004,7 @@ func NewShowCreateSecurityIntegrationStatementContext(parser antlr.Parser, paren antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateSecurityIntegrationStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateSecurityIntegrationStatement return p } @@ -91012,19 +91012,19 @@ func NewShowCreateSecurityIntegrationStatementContext(parser antlr.Parser, paren func (s *ShowCreateSecurityIntegrationStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowCreateSecurityIntegrationStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateSecurityIntegrationStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateSecurityIntegrationStatementContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *ShowCreateSecurityIntegrationStatementContext) INTEGRATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATION, 0) + return s.GetToken(StarRocksSQLParserINTEGRATION, 0) } func (s *ShowCreateSecurityIntegrationStatementContext) Identifier() IIdentifierContext { @@ -91052,20 +91052,20 @@ func (s *ShowCreateSecurityIntegrationStatementContext) ToStringTree(ruleNames [ } func (s *ShowCreateSecurityIntegrationStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateSecurityIntegrationStatement(s) } } func (s *ShowCreateSecurityIntegrationStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateSecurityIntegrationStatement(s) } } func (s *ShowCreateSecurityIntegrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateSecurityIntegrationStatement(s) default: @@ -91073,13 +91073,13 @@ func (s *ShowCreateSecurityIntegrationStatementContext) Accept(visitor antlr.Par } } -func (p *DorisSQLParser) ShowCreateSecurityIntegrationStatement() (localctx IShowCreateSecurityIntegrationStatementContext) { +func (p *StarRocksSQLParser) ShowCreateSecurityIntegrationStatement() (localctx IShowCreateSecurityIntegrationStatementContext) { localctx = NewShowCreateSecurityIntegrationStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 642, DorisSQLParserRULE_showCreateSecurityIntegrationStatement) + p.EnterRule(localctx, 642, StarRocksSQLParserRULE_showCreateSecurityIntegrationStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5469) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91087,7 +91087,7 @@ func (p *DorisSQLParser) ShowCreateSecurityIntegrationStatement() (localctx ISho } { p.SetState(5470) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91095,7 +91095,7 @@ func (p *DorisSQLParser) ShowCreateSecurityIntegrationStatement() (localctx ISho } { p.SetState(5471) - p.Match(DorisSQLParserSECURITY) + p.Match(StarRocksSQLParserSECURITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91103,7 +91103,7 @@ func (p *DorisSQLParser) ShowCreateSecurityIntegrationStatement() (localctx ISho } { p.SetState(5472) - p.Match(DorisSQLParserINTEGRATION) + p.Match(StarRocksSQLParserINTEGRATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91153,13 +91153,13 @@ type CreateGroupProviderStatementContext struct { func NewEmptyCreateGroupProviderStatementContext() *CreateGroupProviderStatementContext { var p = new(CreateGroupProviderStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_createGroupProviderStatement return p } func InitEmptyCreateGroupProviderStatementContext(p *CreateGroupProviderStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_createGroupProviderStatement } func (*CreateGroupProviderStatementContext) IsCreateGroupProviderStatementContext() {} @@ -91170,7 +91170,7 @@ func NewCreateGroupProviderStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_createGroupProviderStatement return p } @@ -91178,15 +91178,15 @@ func NewCreateGroupProviderStatementContext(parser antlr.Parser, parent antlr.Pa func (s *CreateGroupProviderStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateGroupProviderStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateGroupProviderStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *CreateGroupProviderStatementContext) PROVIDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROVIDER, 0) + return s.GetToken(StarRocksSQLParserPROVIDER, 0) } func (s *CreateGroupProviderStatementContext) Identifier() IIdentifierContext { @@ -91230,20 +91230,20 @@ func (s *CreateGroupProviderStatementContext) ToStringTree(ruleNames []string, r } func (s *CreateGroupProviderStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateGroupProviderStatement(s) } } func (s *CreateGroupProviderStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateGroupProviderStatement(s) } } func (s *CreateGroupProviderStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateGroupProviderStatement(s) default: @@ -91251,13 +91251,13 @@ func (s *CreateGroupProviderStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CreateGroupProviderStatement() (localctx ICreateGroupProviderStatementContext) { +func (p *StarRocksSQLParser) CreateGroupProviderStatement() (localctx ICreateGroupProviderStatementContext) { localctx = NewCreateGroupProviderStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 644, DorisSQLParserRULE_createGroupProviderStatement) + p.EnterRule(localctx, 644, StarRocksSQLParserRULE_createGroupProviderStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5475) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91265,7 +91265,7 @@ func (p *DorisSQLParser) CreateGroupProviderStatement() (localctx ICreateGroupPr } { p.SetState(5476) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91273,7 +91273,7 @@ func (p *DorisSQLParser) CreateGroupProviderStatement() (localctx ICreateGroupPr } { p.SetState(5477) - p.Match(DorisSQLParserPROVIDER) + p.Match(StarRocksSQLParserPROVIDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91326,13 +91326,13 @@ type DropGroupProviderStatementContext struct { func NewEmptyDropGroupProviderStatementContext() *DropGroupProviderStatementContext { var p = new(DropGroupProviderStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_dropGroupProviderStatement return p } func InitEmptyDropGroupProviderStatementContext(p *DropGroupProviderStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_dropGroupProviderStatement } func (*DropGroupProviderStatementContext) IsDropGroupProviderStatementContext() {} @@ -91343,7 +91343,7 @@ func NewDropGroupProviderStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_dropGroupProviderStatement return p } @@ -91351,15 +91351,15 @@ func NewDropGroupProviderStatementContext(parser antlr.Parser, parent antlr.Pars func (s *DropGroupProviderStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropGroupProviderStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropGroupProviderStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *DropGroupProviderStatementContext) PROVIDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROVIDER, 0) + return s.GetToken(StarRocksSQLParserPROVIDER, 0) } func (s *DropGroupProviderStatementContext) Identifier() IIdentifierContext { @@ -91387,20 +91387,20 @@ func (s *DropGroupProviderStatementContext) ToStringTree(ruleNames []string, rec } func (s *DropGroupProviderStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropGroupProviderStatement(s) } } func (s *DropGroupProviderStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropGroupProviderStatement(s) } } func (s *DropGroupProviderStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropGroupProviderStatement(s) default: @@ -91408,13 +91408,13 @@ func (s *DropGroupProviderStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) DropGroupProviderStatement() (localctx IDropGroupProviderStatementContext) { +func (p *StarRocksSQLParser) DropGroupProviderStatement() (localctx IDropGroupProviderStatementContext) { localctx = NewDropGroupProviderStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 646, DorisSQLParserRULE_dropGroupProviderStatement) + p.EnterRule(localctx, 646, StarRocksSQLParserRULE_dropGroupProviderStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5481) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91422,7 +91422,7 @@ func (p *DorisSQLParser) DropGroupProviderStatement() (localctx IDropGroupProvid } { p.SetState(5482) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91430,7 +91430,7 @@ func (p *DorisSQLParser) DropGroupProviderStatement() (localctx IDropGroupProvid } { p.SetState(5483) - p.Match(DorisSQLParserPROVIDER) + p.Match(StarRocksSQLParserPROVIDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91478,13 +91478,13 @@ type ShowGroupProvidersStatementContext struct { func NewEmptyShowGroupProvidersStatementContext() *ShowGroupProvidersStatementContext { var p = new(ShowGroupProvidersStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showGroupProvidersStatement + p.RuleIndex = StarRocksSQLParserRULE_showGroupProvidersStatement return p } func InitEmptyShowGroupProvidersStatementContext(p *ShowGroupProvidersStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showGroupProvidersStatement + p.RuleIndex = StarRocksSQLParserRULE_showGroupProvidersStatement } func (*ShowGroupProvidersStatementContext) IsShowGroupProvidersStatementContext() {} @@ -91495,7 +91495,7 @@ func NewShowGroupProvidersStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showGroupProvidersStatement + p.RuleIndex = StarRocksSQLParserRULE_showGroupProvidersStatement return p } @@ -91503,15 +91503,15 @@ func NewShowGroupProvidersStatementContext(parser antlr.Parser, parent antlr.Par func (s *ShowGroupProvidersStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowGroupProvidersStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowGroupProvidersStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *ShowGroupProvidersStatementContext) PROVIDERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROVIDERS, 0) + return s.GetToken(StarRocksSQLParserPROVIDERS, 0) } func (s *ShowGroupProvidersStatementContext) GetRuleContext() antlr.RuleContext { @@ -91523,20 +91523,20 @@ func (s *ShowGroupProvidersStatementContext) ToStringTree(ruleNames []string, re } func (s *ShowGroupProvidersStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowGroupProvidersStatement(s) } } func (s *ShowGroupProvidersStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowGroupProvidersStatement(s) } } func (s *ShowGroupProvidersStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowGroupProvidersStatement(s) default: @@ -91544,13 +91544,13 @@ func (s *ShowGroupProvidersStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) ShowGroupProvidersStatement() (localctx IShowGroupProvidersStatementContext) { +func (p *StarRocksSQLParser) ShowGroupProvidersStatement() (localctx IShowGroupProvidersStatementContext) { localctx = NewShowGroupProvidersStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 648, DorisSQLParserRULE_showGroupProvidersStatement) + p.EnterRule(localctx, 648, StarRocksSQLParserRULE_showGroupProvidersStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5486) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91558,7 +91558,7 @@ func (p *DorisSQLParser) ShowGroupProvidersStatement() (localctx IShowGroupProvi } { p.SetState(5487) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91566,7 +91566,7 @@ func (p *DorisSQLParser) ShowGroupProvidersStatement() (localctx IShowGroupProvi } { p.SetState(5488) - p.Match(DorisSQLParserPROVIDERS) + p.Match(StarRocksSQLParserPROVIDERS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91612,13 +91612,13 @@ type ShowCreateGroupProviderStatementContext struct { func NewEmptyShowCreateGroupProviderStatementContext() *ShowCreateGroupProviderStatementContext { var p = new(ShowCreateGroupProviderStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateGroupProviderStatement return p } func InitEmptyShowCreateGroupProviderStatementContext(p *ShowCreateGroupProviderStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showCreateGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateGroupProviderStatement } func (*ShowCreateGroupProviderStatementContext) IsShowCreateGroupProviderStatementContext() {} @@ -91629,7 +91629,7 @@ func NewShowCreateGroupProviderStatementContext(parser antlr.Parser, parent antl antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showCreateGroupProviderStatement + p.RuleIndex = StarRocksSQLParserRULE_showCreateGroupProviderStatement return p } @@ -91637,19 +91637,19 @@ func NewShowCreateGroupProviderStatementContext(parser antlr.Parser, parent antl func (s *ShowCreateGroupProviderStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowCreateGroupProviderStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowCreateGroupProviderStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *ShowCreateGroupProviderStatementContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *ShowCreateGroupProviderStatementContext) PROVIDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROVIDER, 0) + return s.GetToken(StarRocksSQLParserPROVIDER, 0) } func (s *ShowCreateGroupProviderStatementContext) Identifier() IIdentifierContext { @@ -91677,20 +91677,20 @@ func (s *ShowCreateGroupProviderStatementContext) ToStringTree(ruleNames []strin } func (s *ShowCreateGroupProviderStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowCreateGroupProviderStatement(s) } } func (s *ShowCreateGroupProviderStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowCreateGroupProviderStatement(s) } } func (s *ShowCreateGroupProviderStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowCreateGroupProviderStatement(s) default: @@ -91698,13 +91698,13 @@ func (s *ShowCreateGroupProviderStatementContext) Accept(visitor antlr.ParseTree } } -func (p *DorisSQLParser) ShowCreateGroupProviderStatement() (localctx IShowCreateGroupProviderStatementContext) { +func (p *StarRocksSQLParser) ShowCreateGroupProviderStatement() (localctx IShowCreateGroupProviderStatementContext) { localctx = NewShowCreateGroupProviderStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 650, DorisSQLParserRULE_showCreateGroupProviderStatement) + p.EnterRule(localctx, 650, StarRocksSQLParserRULE_showCreateGroupProviderStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5490) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91712,7 +91712,7 @@ func (p *DorisSQLParser) ShowCreateGroupProviderStatement() (localctx IShowCreat } { p.SetState(5491) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91720,7 +91720,7 @@ func (p *DorisSQLParser) ShowCreateGroupProviderStatement() (localctx IShowCreat } { p.SetState(5492) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91728,7 +91728,7 @@ func (p *DorisSQLParser) ShowCreateGroupProviderStatement() (localctx IShowCreat } { p.SetState(5493) - p.Match(DorisSQLParserPROVIDER) + p.Match(StarRocksSQLParserPROVIDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -91804,13 +91804,13 @@ type BackupStatementContext struct { func NewEmptyBackupStatementContext() *BackupStatementContext { var p = new(BackupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_backupStatement + p.RuleIndex = StarRocksSQLParserRULE_backupStatement return p } func InitEmptyBackupStatementContext(p *BackupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_backupStatement + p.RuleIndex = StarRocksSQLParserRULE_backupStatement } func (*BackupStatementContext) IsBackupStatementContext() {} @@ -91821,7 +91821,7 @@ func NewBackupStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_backupStatement + p.RuleIndex = StarRocksSQLParserRULE_backupStatement return p } @@ -91837,11 +91837,11 @@ func (s *BackupStatementContext) SetDbName(v IIdentifierContext) { s.dbName = v func (s *BackupStatementContext) SetRepoName(v IIdentifierContext) { s.repoName = v } func (s *BackupStatementContext) BACKUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKUP, 0) + return s.GetToken(StarRocksSQLParserBACKUP, 0) } func (s *BackupStatementContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *BackupStatementContext) QualifiedName() IQualifiedNameContext { @@ -91861,7 +91861,7 @@ func (s *BackupStatementContext) QualifiedName() IQualifiedNameContext { } func (s *BackupStatementContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *BackupStatementContext) AllIdentifier() []IIdentifierContext { @@ -91906,15 +91906,15 @@ func (s *BackupStatementContext) Identifier(i int) IIdentifierContext { } func (s *BackupStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *BackupStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *BackupStatementContext) CATALOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOGS, 0) + return s.GetToken(StarRocksSQLParserCATALOGS, 0) } func (s *BackupStatementContext) IdentifierList() IIdentifierListContext { @@ -91934,11 +91934,11 @@ func (s *BackupStatementContext) IdentifierList() IIdentifierListContext { } func (s *BackupStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *BackupStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *BackupStatementContext) AllBackupRestoreObjectDesc() []IBackupRestoreObjectDescContext { @@ -91983,7 +91983,7 @@ func (s *BackupStatementContext) BackupRestoreObjectDesc(i int) IBackupRestoreOb } func (s *BackupStatementContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *BackupStatementContext) PropertyList() IPropertyListContext { @@ -92003,7 +92003,7 @@ func (s *BackupStatementContext) PropertyList() IPropertyListContext { } func (s *BackupStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *BackupStatementContext) GetRuleContext() antlr.RuleContext { @@ -92015,20 +92015,20 @@ func (s *BackupStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *BackupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBackupStatement(s) } } func (s *BackupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBackupStatement(s) } } func (s *BackupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBackupStatement(s) default: @@ -92036,15 +92036,15 @@ func (s *BackupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { +func (p *StarRocksSQLParser) BackupStatement() (localctx IBackupStatementContext) { localctx = NewBackupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 652, DorisSQLParserRULE_backupStatement) + p.EnterRule(localctx, 652, StarRocksSQLParserRULE_backupStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5496) - p.Match(DorisSQLParserBACKUP) + p.Match(StarRocksSQLParserBACKUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92056,10 +92056,10 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: { p.SetState(5497) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92067,7 +92067,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } { p.SetState(5498) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92075,17 +92075,17 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } { p.SetState(5499) - p.Match(DorisSQLParserCATALOGS) + p.Match(StarRocksSQLParserCATALOGS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserEXTERNAL: + case StarRocksSQLParserEXTERNAL: { p.SetState(5500) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92095,7 +92095,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { p.SetState(5501) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCATALOG || _la == DorisSQLParserCATALOGS) { + if !(_la == StarRocksSQLParserCATALOG || _la == StarRocksSQLParserCATALOGS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -92107,7 +92107,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { p.IdentifierList() } - case DorisSQLParserDATABASE, DorisSQLParserSNAPSHOT: + case StarRocksSQLParserDATABASE, StarRocksSQLParserSNAPSHOT: default: } @@ -92118,10 +92118,10 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDATABASE { + if _la == StarRocksSQLParserDATABASE { { p.SetState(5505) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92138,7 +92138,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } { p.SetState(5509) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92150,7 +92150,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } { p.SetState(5511) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92170,10 +92170,10 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserON { + if _la == StarRocksSQLParserON { { p.SetState(5513) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92181,7 +92181,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } { p.SetState(5514) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92198,10 +92198,10 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5516) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92221,7 +92221,7 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } { p.SetState(5523) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92236,10 +92236,10 @@ func (p *DorisSQLParser) BackupStatement() (localctx IBackupStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5527) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92294,13 +92294,13 @@ type CancelBackupStatementContext struct { func NewEmptyCancelBackupStatementContext() *CancelBackupStatementContext { var p = new(CancelBackupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelBackupStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelBackupStatement return p } func InitEmptyCancelBackupStatementContext(p *CancelBackupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelBackupStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelBackupStatement } func (*CancelBackupStatementContext) IsCancelBackupStatementContext() {} @@ -92311,7 +92311,7 @@ func NewCancelBackupStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelBackupStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelBackupStatement return p } @@ -92319,11 +92319,11 @@ func NewCancelBackupStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *CancelBackupStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelBackupStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelBackupStatementContext) BACKUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKUP, 0) + return s.GetToken(StarRocksSQLParserBACKUP, 0) } func (s *CancelBackupStatementContext) Identifier() IIdentifierContext { @@ -92343,23 +92343,23 @@ func (s *CancelBackupStatementContext) Identifier() IIdentifierContext { } func (s *CancelBackupStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *CancelBackupStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *CancelBackupStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *CancelBackupStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CancelBackupStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *CancelBackupStatementContext) GetRuleContext() antlr.RuleContext { @@ -92371,20 +92371,20 @@ func (s *CancelBackupStatementContext) ToStringTree(ruleNames []string, recog an } func (s *CancelBackupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelBackupStatement(s) } } func (s *CancelBackupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelBackupStatement(s) } } func (s *CancelBackupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelBackupStatement(s) default: @@ -92392,15 +92392,15 @@ func (s *CancelBackupStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) CancelBackupStatement() (localctx ICancelBackupStatementContext) { +func (p *StarRocksSQLParser) CancelBackupStatement() (localctx ICancelBackupStatementContext) { localctx = NewCancelBackupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 654, DorisSQLParserRULE_cancelBackupStatement) + p.EnterRule(localctx, 654, StarRocksSQLParserRULE_cancelBackupStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5531) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92408,7 +92408,7 @@ func (p *DorisSQLParser) CancelBackupStatement() (localctx ICancelBackupStatemen } { p.SetState(5532) - p.Match(DorisSQLParserBACKUP) + p.Match(StarRocksSQLParserBACKUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92420,12 +92420,12 @@ func (p *DorisSQLParser) CancelBackupStatement() (localctx ICancelBackupStatemen goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserFROM, DorisSQLParserIN: + case StarRocksSQLParserFROM, StarRocksSQLParserIN: { p.SetState(5533) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -92437,10 +92437,10 @@ func (p *DorisSQLParser) CancelBackupStatement() (localctx ICancelBackupStatemen p.Identifier() } - case DorisSQLParserFOR: + case StarRocksSQLParserFOR: { p.SetState(5535) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92448,7 +92448,7 @@ func (p *DorisSQLParser) CancelBackupStatement() (localctx ICancelBackupStatemen } { p.SetState(5536) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92456,14 +92456,14 @@ func (p *DorisSQLParser) CancelBackupStatement() (localctx ICancelBackupStatemen } { p.SetState(5537) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -92507,13 +92507,13 @@ type ShowBackupStatementContext struct { func NewEmptyShowBackupStatementContext() *ShowBackupStatementContext { var p = new(ShowBackupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBackupStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackupStatement return p } func InitEmptyShowBackupStatementContext(p *ShowBackupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBackupStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackupStatement } func (*ShowBackupStatementContext) IsShowBackupStatementContext() {} @@ -92524,7 +92524,7 @@ func NewShowBackupStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showBackupStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackupStatement return p } @@ -92532,11 +92532,11 @@ func NewShowBackupStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *ShowBackupStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowBackupStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowBackupStatementContext) BACKUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKUP, 0) + return s.GetToken(StarRocksSQLParserBACKUP, 0) } func (s *ShowBackupStatementContext) Identifier() IIdentifierContext { @@ -92556,11 +92556,11 @@ func (s *ShowBackupStatementContext) Identifier() IIdentifierContext { } func (s *ShowBackupStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowBackupStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowBackupStatementContext) GetRuleContext() antlr.RuleContext { @@ -92572,20 +92572,20 @@ func (s *ShowBackupStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowBackupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowBackupStatement(s) } } func (s *ShowBackupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowBackupStatement(s) } } func (s *ShowBackupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowBackupStatement(s) default: @@ -92593,15 +92593,15 @@ func (s *ShowBackupStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowBackupStatement() (localctx IShowBackupStatementContext) { +func (p *StarRocksSQLParser) ShowBackupStatement() (localctx IShowBackupStatementContext) { localctx = NewShowBackupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 656, DorisSQLParserRULE_showBackupStatement) + p.EnterRule(localctx, 656, StarRocksSQLParserRULE_showBackupStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5540) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92609,7 +92609,7 @@ func (p *DorisSQLParser) ShowBackupStatement() (localctx IShowBackupStatementCon } { p.SetState(5541) - p.Match(DorisSQLParserBACKUP) + p.Match(StarRocksSQLParserBACKUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92622,12 +92622,12 @@ func (p *DorisSQLParser) ShowBackupStatement() (localctx IShowBackupStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5542) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -92714,13 +92714,13 @@ type RestoreStatementContext struct { func NewEmptyRestoreStatementContext() *RestoreStatementContext { var p = new(RestoreStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_restoreStatement + p.RuleIndex = StarRocksSQLParserRULE_restoreStatement return p } func InitEmptyRestoreStatementContext(p *RestoreStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_restoreStatement + p.RuleIndex = StarRocksSQLParserRULE_restoreStatement } func (*RestoreStatementContext) IsRestoreStatementContext() {} @@ -92731,7 +92731,7 @@ func NewRestoreStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_restoreStatement + p.RuleIndex = StarRocksSQLParserRULE_restoreStatement return p } @@ -92751,11 +92751,11 @@ func (s *RestoreStatementContext) SetDbName(v IIdentifierContext) { s.dbName = v func (s *RestoreStatementContext) SetDbAlias(v IIdentifierContext) { s.dbAlias = v } func (s *RestoreStatementContext) RESTORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESTORE, 0) + return s.GetToken(StarRocksSQLParserRESTORE, 0) } func (s *RestoreStatementContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *RestoreStatementContext) QualifiedName() IQualifiedNameContext { @@ -92775,7 +92775,7 @@ func (s *RestoreStatementContext) QualifiedName() IQualifiedNameContext { } func (s *RestoreStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *RestoreStatementContext) AllIdentifier() []IIdentifierContext { @@ -92820,15 +92820,15 @@ func (s *RestoreStatementContext) Identifier(i int) IIdentifierContext { } func (s *RestoreStatementContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *RestoreStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *RestoreStatementContext) CATALOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOGS, 0) + return s.GetToken(StarRocksSQLParserCATALOGS, 0) } func (s *RestoreStatementContext) IdentifierWithAliasList() IIdentifierWithAliasListContext { @@ -92848,11 +92848,11 @@ func (s *RestoreStatementContext) IdentifierWithAliasList() IIdentifierWithAlias } func (s *RestoreStatementContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *RestoreStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *RestoreStatementContext) AllBackupRestoreObjectDesc() []IBackupRestoreObjectDescContext { @@ -92897,7 +92897,7 @@ func (s *RestoreStatementContext) BackupRestoreObjectDesc(i int) IBackupRestoreO } func (s *RestoreStatementContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *RestoreStatementContext) PropertyList() IPropertyListContext { @@ -92917,11 +92917,11 @@ func (s *RestoreStatementContext) PropertyList() IPropertyListContext { } func (s *RestoreStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *RestoreStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *RestoreStatementContext) GetRuleContext() antlr.RuleContext { @@ -92933,20 +92933,20 @@ func (s *RestoreStatementContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *RestoreStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRestoreStatement(s) } } func (s *RestoreStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRestoreStatement(s) } } func (s *RestoreStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRestoreStatement(s) default: @@ -92954,15 +92954,15 @@ func (s *RestoreStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) { +func (p *StarRocksSQLParser) RestoreStatement() (localctx IRestoreStatementContext) { localctx = NewRestoreStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 658, DorisSQLParserRULE_restoreStatement) + p.EnterRule(localctx, 658, StarRocksSQLParserRULE_restoreStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5546) - p.Match(DorisSQLParserRESTORE) + p.Match(StarRocksSQLParserRESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92970,7 +92970,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } { p.SetState(5547) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -92982,7 +92982,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } { p.SetState(5549) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93001,10 +93001,10 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: { p.SetState(5551) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93012,7 +93012,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } { p.SetState(5552) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93020,17 +93020,17 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } { p.SetState(5553) - p.Match(DorisSQLParserCATALOGS) + p.Match(StarRocksSQLParserCATALOGS) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserEXTERNAL: + case StarRocksSQLParserEXTERNAL: { p.SetState(5554) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93040,7 +93040,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) p.SetState(5555) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCATALOG || _la == DorisSQLParserCATALOGS) { + if !(_la == StarRocksSQLParserCATALOG || _la == StarRocksSQLParserCATALOGS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -93052,7 +93052,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) p.IdentifierWithAliasList() } - case DorisSQLParserEOF, DorisSQLParserDATABASE, DorisSQLParserON, DorisSQLParserPROPERTIES, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserDATABASE, StarRocksSQLParserON, StarRocksSQLParserPROPERTIES, StarRocksSQLParserSEMICOLON: default: } @@ -93063,10 +93063,10 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDATABASE { + if _la == StarRocksSQLParserDATABASE { { p.SetState(5559) - p.Match(DorisSQLParserDATABASE) + p.Match(StarRocksSQLParserDATABASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93086,10 +93086,10 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(5561) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93113,10 +93113,10 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserON { + if _la == StarRocksSQLParserON { { p.SetState(5567) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93124,7 +93124,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } { p.SetState(5568) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93141,10 +93141,10 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5570) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93164,7 +93164,7 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } { p.SetState(5577) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93179,10 +93179,10 @@ func (p *DorisSQLParser) RestoreStatement() (localctx IRestoreStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5581) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93237,13 +93237,13 @@ type CancelRestoreStatementContext struct { func NewEmptyCancelRestoreStatementContext() *CancelRestoreStatementContext { var p = new(CancelRestoreStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelRestoreStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRestoreStatement return p } func InitEmptyCancelRestoreStatementContext(p *CancelRestoreStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelRestoreStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRestoreStatement } func (*CancelRestoreStatementContext) IsCancelRestoreStatementContext() {} @@ -93254,7 +93254,7 @@ func NewCancelRestoreStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelRestoreStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelRestoreStatement return p } @@ -93262,11 +93262,11 @@ func NewCancelRestoreStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *CancelRestoreStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CancelRestoreStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelRestoreStatementContext) RESTORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESTORE, 0) + return s.GetToken(StarRocksSQLParserRESTORE, 0) } func (s *CancelRestoreStatementContext) Identifier() IIdentifierContext { @@ -93286,23 +93286,23 @@ func (s *CancelRestoreStatementContext) Identifier() IIdentifierContext { } func (s *CancelRestoreStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *CancelRestoreStatementContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *CancelRestoreStatementContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *CancelRestoreStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CancelRestoreStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *CancelRestoreStatementContext) GetRuleContext() antlr.RuleContext { @@ -93314,20 +93314,20 @@ func (s *CancelRestoreStatementContext) ToStringTree(ruleNames []string, recog a } func (s *CancelRestoreStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelRestoreStatement(s) } } func (s *CancelRestoreStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelRestoreStatement(s) } } func (s *CancelRestoreStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelRestoreStatement(s) default: @@ -93335,15 +93335,15 @@ func (s *CancelRestoreStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatementContext) { +func (p *StarRocksSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatementContext) { localctx = NewCancelRestoreStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 660, DorisSQLParserRULE_cancelRestoreStatement) + p.EnterRule(localctx, 660, StarRocksSQLParserRULE_cancelRestoreStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5585) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93351,7 +93351,7 @@ func (p *DorisSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatem } { p.SetState(5586) - p.Match(DorisSQLParserRESTORE) + p.Match(StarRocksSQLParserRESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93363,12 +93363,12 @@ func (p *DorisSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatem goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserFROM, DorisSQLParserIN: + case StarRocksSQLParserFROM, StarRocksSQLParserIN: { p.SetState(5587) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -93380,10 +93380,10 @@ func (p *DorisSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatem p.Identifier() } - case DorisSQLParserFOR: + case StarRocksSQLParserFOR: { p.SetState(5589) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93391,7 +93391,7 @@ func (p *DorisSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatem } { p.SetState(5590) - p.Match(DorisSQLParserEXTERNAL) + p.Match(StarRocksSQLParserEXTERNAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93399,14 +93399,14 @@ func (p *DorisSQLParser) CancelRestoreStatement() (localctx ICancelRestoreStatem } { p.SetState(5591) - p.Match(DorisSQLParserCATALOG) + p.Match(StarRocksSQLParserCATALOG) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -93459,13 +93459,13 @@ type ShowRestoreStatementContext struct { func NewEmptyShowRestoreStatementContext() *ShowRestoreStatementContext { var p = new(ShowRestoreStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRestoreStatement + p.RuleIndex = StarRocksSQLParserRULE_showRestoreStatement return p } func InitEmptyShowRestoreStatementContext(p *ShowRestoreStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showRestoreStatement + p.RuleIndex = StarRocksSQLParserRULE_showRestoreStatement } func (*ShowRestoreStatementContext) IsShowRestoreStatementContext() {} @@ -93476,7 +93476,7 @@ func NewShowRestoreStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showRestoreStatement + p.RuleIndex = StarRocksSQLParserRULE_showRestoreStatement return p } @@ -93488,11 +93488,11 @@ func (s *ShowRestoreStatementContext) GetWhere() IExpressionContext { return s.w func (s *ShowRestoreStatementContext) SetWhere(v IExpressionContext) { s.where = v } func (s *ShowRestoreStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowRestoreStatementContext) RESTORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESTORE, 0) + return s.GetToken(StarRocksSQLParserRESTORE, 0) } func (s *ShowRestoreStatementContext) Identifier() IIdentifierContext { @@ -93512,15 +93512,15 @@ func (s *ShowRestoreStatementContext) Identifier() IIdentifierContext { } func (s *ShowRestoreStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowRestoreStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowRestoreStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowRestoreStatementContext) Expression() IExpressionContext { @@ -93548,20 +93548,20 @@ func (s *ShowRestoreStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *ShowRestoreStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowRestoreStatement(s) } } func (s *ShowRestoreStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowRestoreStatement(s) } } func (s *ShowRestoreStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowRestoreStatement(s) default: @@ -93569,15 +93569,15 @@ func (s *ShowRestoreStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) ShowRestoreStatement() (localctx IShowRestoreStatementContext) { +func (p *StarRocksSQLParser) ShowRestoreStatement() (localctx IShowRestoreStatementContext) { localctx = NewShowRestoreStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 662, DorisSQLParserRULE_showRestoreStatement) + p.EnterRule(localctx, 662, StarRocksSQLParserRULE_showRestoreStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5594) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93585,7 +93585,7 @@ func (p *DorisSQLParser) ShowRestoreStatement() (localctx IShowRestoreStatementC } { p.SetState(5595) - p.Match(DorisSQLParserRESTORE) + p.Match(StarRocksSQLParserRESTORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93598,12 +93598,12 @@ func (p *DorisSQLParser) ShowRestoreStatement() (localctx IShowRestoreStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5596) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -93623,10 +93623,10 @@ func (p *DorisSQLParser) ShowRestoreStatement() (localctx IShowRestoreStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(5600) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93682,13 +93682,13 @@ type ShowSnapshotStatementContext struct { func NewEmptyShowSnapshotStatementContext() *ShowSnapshotStatementContext { var p = new(ShowSnapshotStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSnapshotStatement + p.RuleIndex = StarRocksSQLParserRULE_showSnapshotStatement return p } func InitEmptyShowSnapshotStatementContext(p *ShowSnapshotStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSnapshotStatement + p.RuleIndex = StarRocksSQLParserRULE_showSnapshotStatement } func (*ShowSnapshotStatementContext) IsShowSnapshotStatementContext() {} @@ -93699,7 +93699,7 @@ func NewShowSnapshotStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showSnapshotStatement + p.RuleIndex = StarRocksSQLParserRULE_showSnapshotStatement return p } @@ -93707,15 +93707,15 @@ func NewShowSnapshotStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *ShowSnapshotStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowSnapshotStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowSnapshotStatementContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *ShowSnapshotStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *ShowSnapshotStatementContext) Identifier() IIdentifierContext { @@ -93735,7 +93735,7 @@ func (s *ShowSnapshotStatementContext) Identifier() IIdentifierContext { } func (s *ShowSnapshotStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowSnapshotStatementContext) Expression() IExpressionContext { @@ -93763,20 +93763,20 @@ func (s *ShowSnapshotStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowSnapshotStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowSnapshotStatement(s) } } func (s *ShowSnapshotStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowSnapshotStatement(s) } } func (s *ShowSnapshotStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowSnapshotStatement(s) default: @@ -93784,15 +93784,15 @@ func (s *ShowSnapshotStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowSnapshotStatement() (localctx IShowSnapshotStatementContext) { +func (p *StarRocksSQLParser) ShowSnapshotStatement() (localctx IShowSnapshotStatementContext) { localctx = NewShowSnapshotStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 664, DorisSQLParserRULE_showSnapshotStatement) + p.EnterRule(localctx, 664, StarRocksSQLParserRULE_showSnapshotStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5604) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93800,7 +93800,7 @@ func (p *DorisSQLParser) ShowSnapshotStatement() (localctx IShowSnapshotStatemen } { p.SetState(5605) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93808,7 +93808,7 @@ func (p *DorisSQLParser) ShowSnapshotStatement() (localctx IShowSnapshotStatemen } { p.SetState(5606) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93825,10 +93825,10 @@ func (p *DorisSQLParser) ShowSnapshotStatement() (localctx IShowSnapshotStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(5608) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -93909,13 +93909,13 @@ type CreateRepositoryStatementContext struct { func NewEmptyCreateRepositoryStatementContext() *CreateRepositoryStatementContext { var p = new(CreateRepositoryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_createRepositoryStatement return p } func InitEmptyCreateRepositoryStatementContext(p *CreateRepositoryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_createRepositoryStatement } func (*CreateRepositoryStatementContext) IsCreateRepositoryStatementContext() {} @@ -93926,7 +93926,7 @@ func NewCreateRepositoryStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_createRepositoryStatement return p } @@ -93950,27 +93950,27 @@ func (s *CreateRepositoryStatementContext) SetBrokerName(v IIdentifierOrStringCo func (s *CreateRepositoryStatementContext) SetLocation(v IStringContext) { s.location = v } func (s *CreateRepositoryStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateRepositoryStatementContext) REPOSITORY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORY, 0) + return s.GetToken(StarRocksSQLParserREPOSITORY, 0) } func (s *CreateRepositoryStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *CreateRepositoryStatementContext) BROKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBROKER, 0) + return s.GetToken(StarRocksSQLParserBROKER, 0) } func (s *CreateRepositoryStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *CreateRepositoryStatementContext) LOCATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCATION, 0) + return s.GetToken(StarRocksSQLParserLOCATION, 0) } func (s *CreateRepositoryStatementContext) Identifier() IIdentifierContext { @@ -94006,15 +94006,15 @@ func (s *CreateRepositoryStatementContext) String_() IStringContext { } func (s *CreateRepositoryStatementContext) READ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREAD, 0) + return s.GetToken(StarRocksSQLParserREAD, 0) } func (s *CreateRepositoryStatementContext) ONLY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserONLY, 0) + return s.GetToken(StarRocksSQLParserONLY, 0) } func (s *CreateRepositoryStatementContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *CreateRepositoryStatementContext) PropertyList() IPropertyListContext { @@ -94058,20 +94058,20 @@ func (s *CreateRepositoryStatementContext) ToStringTree(ruleNames []string, reco } func (s *CreateRepositoryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateRepositoryStatement(s) } } func (s *CreateRepositoryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateRepositoryStatement(s) } } func (s *CreateRepositoryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateRepositoryStatement(s) default: @@ -94079,15 +94079,15 @@ func (s *CreateRepositoryStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepositoryStatementContext) { +func (p *StarRocksSQLParser) CreateRepositoryStatement() (localctx ICreateRepositoryStatementContext) { localctx = NewCreateRepositoryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 666, DorisSQLParserRULE_createRepositoryStatement) + p.EnterRule(localctx, 666, StarRocksSQLParserRULE_createRepositoryStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5612) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94100,10 +94100,10 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserREAD { + if _la == StarRocksSQLParserREAD { { p.SetState(5613) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94111,7 +94111,7 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } { p.SetState(5614) - p.Match(DorisSQLParserONLY) + p.Match(StarRocksSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94121,7 +94121,7 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } { p.SetState(5617) - p.Match(DorisSQLParserREPOSITORY) + p.Match(StarRocksSQLParserREPOSITORY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94136,7 +94136,7 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } { p.SetState(5619) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94144,7 +94144,7 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } { p.SetState(5620) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94169,7 +94169,7 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } { p.SetState(5624) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94177,7 +94177,7 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } { p.SetState(5625) - p.Match(DorisSQLParserLOCATION) + p.Match(StarRocksSQLParserLOCATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94197,10 +94197,10 @@ func (p *DorisSQLParser) CreateRepositoryStatement() (localctx ICreateRepository } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5627) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94250,13 +94250,13 @@ type DropRepositoryStatementContext struct { func NewEmptyDropRepositoryStatementContext() *DropRepositoryStatementContext { var p = new(DropRepositoryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_dropRepositoryStatement return p } func InitEmptyDropRepositoryStatementContext(p *DropRepositoryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_dropRepositoryStatement } func (*DropRepositoryStatementContext) IsDropRepositoryStatementContext() {} @@ -94267,7 +94267,7 @@ func NewDropRepositoryStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropRepositoryStatement + p.RuleIndex = StarRocksSQLParserRULE_dropRepositoryStatement return p } @@ -94275,11 +94275,11 @@ func NewDropRepositoryStatementContext(parser antlr.Parser, parent antlr.ParserR func (s *DropRepositoryStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropRepositoryStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropRepositoryStatementContext) REPOSITORY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORY, 0) + return s.GetToken(StarRocksSQLParserREPOSITORY, 0) } func (s *DropRepositoryStatementContext) Identifier() IIdentifierContext { @@ -94307,20 +94307,20 @@ func (s *DropRepositoryStatementContext) ToStringTree(ruleNames []string, recog } func (s *DropRepositoryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropRepositoryStatement(s) } } func (s *DropRepositoryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropRepositoryStatement(s) } } func (s *DropRepositoryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropRepositoryStatement(s) default: @@ -94328,13 +94328,13 @@ func (s *DropRepositoryStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) DropRepositoryStatement() (localctx IDropRepositoryStatementContext) { +func (p *StarRocksSQLParser) DropRepositoryStatement() (localctx IDropRepositoryStatementContext) { localctx = NewDropRepositoryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 668, DorisSQLParserRULE_dropRepositoryStatement) + p.EnterRule(localctx, 668, StarRocksSQLParserRULE_dropRepositoryStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5631) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94342,7 +94342,7 @@ func (p *DorisSQLParser) DropRepositoryStatement() (localctx IDropRepositoryStat } { p.SetState(5632) - p.Match(DorisSQLParserREPOSITORY) + p.Match(StarRocksSQLParserREPOSITORY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94390,13 +94390,13 @@ type AddSqlBlackListStatementContext struct { func NewEmptyAddSqlBlackListStatementContext() *AddSqlBlackListStatementContext { var p = new(AddSqlBlackListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_addSqlBlackListStatement return p } func InitEmptyAddSqlBlackListStatementContext(p *AddSqlBlackListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_addSqlBlackListStatement } func (*AddSqlBlackListStatementContext) IsAddSqlBlackListStatementContext() {} @@ -94407,7 +94407,7 @@ func NewAddSqlBlackListStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_addSqlBlackListStatement return p } @@ -94415,11 +94415,11 @@ func NewAddSqlBlackListStatementContext(parser antlr.Parser, parent antlr.Parser func (s *AddSqlBlackListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AddSqlBlackListStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddSqlBlackListStatementContext) SQLBLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSQLBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserSQLBLACKLIST, 0) } func (s *AddSqlBlackListStatementContext) String_() IStringContext { @@ -94447,20 +94447,20 @@ func (s *AddSqlBlackListStatementContext) ToStringTree(ruleNames []string, recog } func (s *AddSqlBlackListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddSqlBlackListStatement(s) } } func (s *AddSqlBlackListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddSqlBlackListStatement(s) } } func (s *AddSqlBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddSqlBlackListStatement(s) default: @@ -94468,13 +94468,13 @@ func (s *AddSqlBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AddSqlBlackListStatement() (localctx IAddSqlBlackListStatementContext) { +func (p *StarRocksSQLParser) AddSqlBlackListStatement() (localctx IAddSqlBlackListStatementContext) { localctx = NewAddSqlBlackListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 670, DorisSQLParserRULE_addSqlBlackListStatement) + p.EnterRule(localctx, 670, StarRocksSQLParserRULE_addSqlBlackListStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5635) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94482,7 +94482,7 @@ func (p *DorisSQLParser) AddSqlBlackListStatement() (localctx IAddSqlBlackListSt } { p.SetState(5636) - p.Match(DorisSQLParserSQLBLACKLIST) + p.Match(StarRocksSQLParserSQLBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94531,13 +94531,13 @@ type DelSqlBlackListStatementContext struct { func NewEmptyDelSqlBlackListStatementContext() *DelSqlBlackListStatementContext { var p = new(DelSqlBlackListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_delSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_delSqlBlackListStatement return p } func InitEmptyDelSqlBlackListStatementContext(p *DelSqlBlackListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_delSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_delSqlBlackListStatement } func (*DelSqlBlackListStatementContext) IsDelSqlBlackListStatementContext() {} @@ -94548,7 +94548,7 @@ func NewDelSqlBlackListStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_delSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_delSqlBlackListStatement return p } @@ -94556,19 +94556,19 @@ func NewDelSqlBlackListStatementContext(parser antlr.Parser, parent antlr.Parser func (s *DelSqlBlackListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DelSqlBlackListStatementContext) DELETE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDELETE, 0) + return s.GetToken(StarRocksSQLParserDELETE, 0) } func (s *DelSqlBlackListStatementContext) SQLBLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSQLBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserSQLBLACKLIST, 0) } func (s *DelSqlBlackListStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *DelSqlBlackListStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *DelSqlBlackListStatementContext) GetRuleContext() antlr.RuleContext { @@ -94580,20 +94580,20 @@ func (s *DelSqlBlackListStatementContext) ToStringTree(ruleNames []string, recog } func (s *DelSqlBlackListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDelSqlBlackListStatement(s) } } func (s *DelSqlBlackListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDelSqlBlackListStatement(s) } } func (s *DelSqlBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDelSqlBlackListStatement(s) default: @@ -94601,15 +94601,15 @@ func (s *DelSqlBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) DelSqlBlackListStatement() (localctx IDelSqlBlackListStatementContext) { +func (p *StarRocksSQLParser) DelSqlBlackListStatement() (localctx IDelSqlBlackListStatementContext) { localctx = NewDelSqlBlackListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 672, DorisSQLParserRULE_delSqlBlackListStatement) + p.EnterRule(localctx, 672, StarRocksSQLParserRULE_delSqlBlackListStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5639) - p.Match(DorisSQLParserDELETE) + p.Match(StarRocksSQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94617,7 +94617,7 @@ func (p *DorisSQLParser) DelSqlBlackListStatement() (localctx IDelSqlBlackListSt } { p.SetState(5640) - p.Match(DorisSQLParserSQLBLACKLIST) + p.Match(StarRocksSQLParserSQLBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94625,7 +94625,7 @@ func (p *DorisSQLParser) DelSqlBlackListStatement() (localctx IDelSqlBlackListSt } { p.SetState(5641) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94638,10 +94638,10 @@ func (p *DorisSQLParser) DelSqlBlackListStatement() (localctx IDelSqlBlackListSt } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5642) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94649,7 +94649,7 @@ func (p *DorisSQLParser) DelSqlBlackListStatement() (localctx IDelSqlBlackListSt } { p.SetState(5643) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94700,13 +94700,13 @@ type ShowSqlBlackListStatementContext struct { func NewEmptyShowSqlBlackListStatementContext() *ShowSqlBlackListStatementContext { var p = new(ShowSqlBlackListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_showSqlBlackListStatement return p } func InitEmptyShowSqlBlackListStatementContext(p *ShowSqlBlackListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_showSqlBlackListStatement } func (*ShowSqlBlackListStatementContext) IsShowSqlBlackListStatementContext() {} @@ -94717,7 +94717,7 @@ func NewShowSqlBlackListStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showSqlBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_showSqlBlackListStatement return p } @@ -94725,11 +94725,11 @@ func NewShowSqlBlackListStatementContext(parser antlr.Parser, parent antlr.Parse func (s *ShowSqlBlackListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowSqlBlackListStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowSqlBlackListStatementContext) SQLBLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSQLBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserSQLBLACKLIST, 0) } func (s *ShowSqlBlackListStatementContext) GetRuleContext() antlr.RuleContext { @@ -94741,20 +94741,20 @@ func (s *ShowSqlBlackListStatementContext) ToStringTree(ruleNames []string, reco } func (s *ShowSqlBlackListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowSqlBlackListStatement(s) } } func (s *ShowSqlBlackListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowSqlBlackListStatement(s) } } func (s *ShowSqlBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowSqlBlackListStatement(s) default: @@ -94762,13 +94762,13 @@ func (s *ShowSqlBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) ShowSqlBlackListStatement() (localctx IShowSqlBlackListStatementContext) { +func (p *StarRocksSQLParser) ShowSqlBlackListStatement() (localctx IShowSqlBlackListStatementContext) { localctx = NewShowSqlBlackListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 674, DorisSQLParserRULE_showSqlBlackListStatement) + p.EnterRule(localctx, 674, StarRocksSQLParserRULE_showSqlBlackListStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5649) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94776,7 +94776,7 @@ func (p *DorisSQLParser) ShowSqlBlackListStatement() (localctx IShowSqlBlackList } { p.SetState(5650) - p.Match(DorisSQLParserSQLBLACKLIST) + p.Match(StarRocksSQLParserSQLBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94819,13 +94819,13 @@ type ShowWhiteListStatementContext struct { func NewEmptyShowWhiteListStatementContext() *ShowWhiteListStatementContext { var p = new(ShowWhiteListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWhiteListStatement + p.RuleIndex = StarRocksSQLParserRULE_showWhiteListStatement return p } func InitEmptyShowWhiteListStatementContext(p *ShowWhiteListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWhiteListStatement + p.RuleIndex = StarRocksSQLParserRULE_showWhiteListStatement } func (*ShowWhiteListStatementContext) IsShowWhiteListStatementContext() {} @@ -94836,7 +94836,7 @@ func NewShowWhiteListStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showWhiteListStatement + p.RuleIndex = StarRocksSQLParserRULE_showWhiteListStatement return p } @@ -94844,11 +94844,11 @@ func NewShowWhiteListStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *ShowWhiteListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowWhiteListStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowWhiteListStatementContext) WHITELIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHITELIST, 0) + return s.GetToken(StarRocksSQLParserWHITELIST, 0) } func (s *ShowWhiteListStatementContext) GetRuleContext() antlr.RuleContext { @@ -94860,20 +94860,20 @@ func (s *ShowWhiteListStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ShowWhiteListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowWhiteListStatement(s) } } func (s *ShowWhiteListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowWhiteListStatement(s) } } func (s *ShowWhiteListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowWhiteListStatement(s) default: @@ -94881,13 +94881,13 @@ func (s *ShowWhiteListStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ShowWhiteListStatement() (localctx IShowWhiteListStatementContext) { +func (p *StarRocksSQLParser) ShowWhiteListStatement() (localctx IShowWhiteListStatementContext) { localctx = NewShowWhiteListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 676, DorisSQLParserRULE_showWhiteListStatement) + p.EnterRule(localctx, 676, StarRocksSQLParserRULE_showWhiteListStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5652) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94895,7 +94895,7 @@ func (p *DorisSQLParser) ShowWhiteListStatement() (localctx IShowWhiteListStatem } { p.SetState(5653) - p.Match(DorisSQLParserWHITELIST) + p.Match(StarRocksSQLParserWHITELIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -94941,13 +94941,13 @@ type AddBackendBlackListStatementContext struct { func NewEmptyAddBackendBlackListStatementContext() *AddBackendBlackListStatementContext { var p = new(AddBackendBlackListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_addBackendBlackListStatement return p } func InitEmptyAddBackendBlackListStatementContext(p *AddBackendBlackListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_addBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_addBackendBlackListStatement } func (*AddBackendBlackListStatementContext) IsAddBackendBlackListStatementContext() {} @@ -94958,7 +94958,7 @@ func NewAddBackendBlackListStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_addBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_addBackendBlackListStatement return p } @@ -94966,23 +94966,23 @@ func NewAddBackendBlackListStatementContext(parser antlr.Parser, parent antlr.Pa func (s *AddBackendBlackListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AddBackendBlackListStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AddBackendBlackListStatementContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *AddBackendBlackListStatementContext) BLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserBLACKLIST, 0) } func (s *AddBackendBlackListStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *AddBackendBlackListStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *AddBackendBlackListStatementContext) GetRuleContext() antlr.RuleContext { @@ -94994,20 +94994,20 @@ func (s *AddBackendBlackListStatementContext) ToStringTree(ruleNames []string, r } func (s *AddBackendBlackListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAddBackendBlackListStatement(s) } } func (s *AddBackendBlackListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAddBackendBlackListStatement(s) } } func (s *AddBackendBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAddBackendBlackListStatement(s) default: @@ -95015,15 +95015,15 @@ func (s *AddBackendBlackListStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBlackListStatementContext) { +func (p *StarRocksSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBlackListStatementContext) { localctx = NewAddBackendBlackListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 678, DorisSQLParserRULE_addBackendBlackListStatement) + p.EnterRule(localctx, 678, StarRocksSQLParserRULE_addBackendBlackListStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5655) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95031,7 +95031,7 @@ func (p *DorisSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBla } { p.SetState(5656) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95039,7 +95039,7 @@ func (p *DorisSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBla } { p.SetState(5657) - p.Match(DorisSQLParserBLACKLIST) + p.Match(StarRocksSQLParserBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95047,7 +95047,7 @@ func (p *DorisSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBla } { p.SetState(5658) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95060,10 +95060,10 @@ func (p *DorisSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBla } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5659) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95071,7 +95071,7 @@ func (p *DorisSQLParser) AddBackendBlackListStatement() (localctx IAddBackendBla } { p.SetState(5660) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95125,13 +95125,13 @@ type DelBackendBlackListStatementContext struct { func NewEmptyDelBackendBlackListStatementContext() *DelBackendBlackListStatementContext { var p = new(DelBackendBlackListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_delBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_delBackendBlackListStatement return p } func InitEmptyDelBackendBlackListStatementContext(p *DelBackendBlackListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_delBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_delBackendBlackListStatement } func (*DelBackendBlackListStatementContext) IsDelBackendBlackListStatementContext() {} @@ -95142,7 +95142,7 @@ func NewDelBackendBlackListStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_delBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_delBackendBlackListStatement return p } @@ -95150,23 +95150,23 @@ func NewDelBackendBlackListStatementContext(parser antlr.Parser, parent antlr.Pa func (s *DelBackendBlackListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DelBackendBlackListStatementContext) DELETE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDELETE, 0) + return s.GetToken(StarRocksSQLParserDELETE, 0) } func (s *DelBackendBlackListStatementContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *DelBackendBlackListStatementContext) BLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserBLACKLIST, 0) } func (s *DelBackendBlackListStatementContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *DelBackendBlackListStatementContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *DelBackendBlackListStatementContext) GetRuleContext() antlr.RuleContext { @@ -95178,20 +95178,20 @@ func (s *DelBackendBlackListStatementContext) ToStringTree(ruleNames []string, r } func (s *DelBackendBlackListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDelBackendBlackListStatement(s) } } func (s *DelBackendBlackListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDelBackendBlackListStatement(s) } } func (s *DelBackendBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDelBackendBlackListStatement(s) default: @@ -95199,15 +95199,15 @@ func (s *DelBackendBlackListStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBlackListStatementContext) { +func (p *StarRocksSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBlackListStatementContext) { localctx = NewDelBackendBlackListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 680, DorisSQLParserRULE_delBackendBlackListStatement) + p.EnterRule(localctx, 680, StarRocksSQLParserRULE_delBackendBlackListStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5666) - p.Match(DorisSQLParserDELETE) + p.Match(StarRocksSQLParserDELETE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95215,7 +95215,7 @@ func (p *DorisSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBla } { p.SetState(5667) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95223,7 +95223,7 @@ func (p *DorisSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBla } { p.SetState(5668) - p.Match(DorisSQLParserBLACKLIST) + p.Match(StarRocksSQLParserBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95231,7 +95231,7 @@ func (p *DorisSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBla } { p.SetState(5669) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95244,10 +95244,10 @@ func (p *DorisSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBla } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5670) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95255,7 +95255,7 @@ func (p *DorisSQLParser) DelBackendBlackListStatement() (localctx IDelBackendBla } { p.SetState(5671) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95307,13 +95307,13 @@ type ShowBackendBlackListStatementContext struct { func NewEmptyShowBackendBlackListStatementContext() *ShowBackendBlackListStatementContext { var p = new(ShowBackendBlackListStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackendBlackListStatement return p } func InitEmptyShowBackendBlackListStatementContext(p *ShowBackendBlackListStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackendBlackListStatement } func (*ShowBackendBlackListStatementContext) IsShowBackendBlackListStatementContext() {} @@ -95324,7 +95324,7 @@ func NewShowBackendBlackListStatementContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showBackendBlackListStatement + p.RuleIndex = StarRocksSQLParserRULE_showBackendBlackListStatement return p } @@ -95332,15 +95332,15 @@ func NewShowBackendBlackListStatementContext(parser antlr.Parser, parent antlr.P func (s *ShowBackendBlackListStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowBackendBlackListStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowBackendBlackListStatementContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *ShowBackendBlackListStatementContext) BLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserBLACKLIST, 0) } func (s *ShowBackendBlackListStatementContext) GetRuleContext() antlr.RuleContext { @@ -95352,20 +95352,20 @@ func (s *ShowBackendBlackListStatementContext) ToStringTree(ruleNames []string, } func (s *ShowBackendBlackListStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowBackendBlackListStatement(s) } } func (s *ShowBackendBlackListStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowBackendBlackListStatement(s) } } func (s *ShowBackendBlackListStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowBackendBlackListStatement(s) default: @@ -95373,13 +95373,13 @@ func (s *ShowBackendBlackListStatementContext) Accept(visitor antlr.ParseTreeVis } } -func (p *DorisSQLParser) ShowBackendBlackListStatement() (localctx IShowBackendBlackListStatementContext) { +func (p *StarRocksSQLParser) ShowBackendBlackListStatement() (localctx IShowBackendBlackListStatementContext) { localctx = NewShowBackendBlackListStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 682, DorisSQLParserRULE_showBackendBlackListStatement) + p.EnterRule(localctx, 682, StarRocksSQLParserRULE_showBackendBlackListStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5677) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95387,7 +95387,7 @@ func (p *DorisSQLParser) ShowBackendBlackListStatement() (localctx IShowBackendB } { p.SetState(5678) - p.Match(DorisSQLParserBACKEND) + p.Match(StarRocksSQLParserBACKEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95395,7 +95395,7 @@ func (p *DorisSQLParser) ShowBackendBlackListStatement() (localctx IShowBackendB } { p.SetState(5679) - p.Match(DorisSQLParserBLACKLIST) + p.Match(StarRocksSQLParserBLACKLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95438,13 +95438,13 @@ type DataCacheTargetContext struct { func NewEmptyDataCacheTargetContext() *DataCacheTargetContext { var p = new(DataCacheTargetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataCacheTarget + p.RuleIndex = StarRocksSQLParserRULE_dataCacheTarget return p } func InitEmptyDataCacheTargetContext(p *DataCacheTargetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataCacheTarget + p.RuleIndex = StarRocksSQLParserRULE_dataCacheTarget } func (*DataCacheTargetContext) IsDataCacheTargetContext() {} @@ -95455,7 +95455,7 @@ func NewDataCacheTargetContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dataCacheTarget + p.RuleIndex = StarRocksSQLParserRULE_dataCacheTarget return p } @@ -95512,20 +95512,20 @@ func (s *DataCacheTargetContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *DataCacheTargetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDataCacheTarget(s) } } func (s *DataCacheTargetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDataCacheTarget(s) } } func (s *DataCacheTargetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDataCacheTarget(s) default: @@ -95533,9 +95533,9 @@ func (s *DataCacheTargetContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) DataCacheTarget() (localctx IDataCacheTargetContext) { +func (p *StarRocksSQLParser) DataCacheTarget() (localctx IDataCacheTargetContext) { localctx = NewDataCacheTargetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 684, DorisSQLParserRULE_dataCacheTarget) + p.EnterRule(localctx, 684, StarRocksSQLParserRULE_dataCacheTarget) p.EnterOuterAlt(localctx, 1) { p.SetState(5681) @@ -95543,7 +95543,7 @@ func (p *DorisSQLParser) DataCacheTarget() (localctx IDataCacheTargetContext) { } { p.SetState(5682) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95555,7 +95555,7 @@ func (p *DorisSQLParser) DataCacheTarget() (localctx IDataCacheTargetContext) { } { p.SetState(5684) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95611,13 +95611,13 @@ type CreateDataCacheRuleStatementContext struct { func NewEmptyCreateDataCacheRuleStatementContext() *CreateDataCacheRuleStatementContext { var p = new(CreateDataCacheRuleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createDataCacheRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_createDataCacheRuleStatement return p } func InitEmptyCreateDataCacheRuleStatementContext(p *CreateDataCacheRuleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createDataCacheRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_createDataCacheRuleStatement } func (*CreateDataCacheRuleStatementContext) IsCreateDataCacheRuleStatementContext() {} @@ -95628,7 +95628,7 @@ func NewCreateDataCacheRuleStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createDataCacheRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_createDataCacheRuleStatement return p } @@ -95636,15 +95636,15 @@ func NewCreateDataCacheRuleStatementContext(parser antlr.Parser, parent antlr.Pa func (s *CreateDataCacheRuleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreateDataCacheRuleStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateDataCacheRuleStatementContext) DATACACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATACACHE, 0) + return s.GetToken(StarRocksSQLParserDATACACHE, 0) } func (s *CreateDataCacheRuleStatementContext) RULE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULE, 0) + return s.GetToken(StarRocksSQLParserRULE, 0) } func (s *CreateDataCacheRuleStatementContext) DataCacheTarget() IDataCacheTargetContext { @@ -95664,19 +95664,19 @@ func (s *CreateDataCacheRuleStatementContext) DataCacheTarget() IDataCacheTarget } func (s *CreateDataCacheRuleStatementContext) PRIORITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIORITY, 0) + return s.GetToken(StarRocksSQLParserPRIORITY, 0) } func (s *CreateDataCacheRuleStatementContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *CreateDataCacheRuleStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *CreateDataCacheRuleStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *CreateDataCacheRuleStatementContext) Expression() IExpressionContext { @@ -95696,7 +95696,7 @@ func (s *CreateDataCacheRuleStatementContext) Expression() IExpressionContext { } func (s *CreateDataCacheRuleStatementContext) MINUS_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUS_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserMINUS_SYMBOL, 0) } func (s *CreateDataCacheRuleStatementContext) Properties() IPropertiesContext { @@ -95724,20 +95724,20 @@ func (s *CreateDataCacheRuleStatementContext) ToStringTree(ruleNames []string, r } func (s *CreateDataCacheRuleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateDataCacheRuleStatement(s) } } func (s *CreateDataCacheRuleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateDataCacheRuleStatement(s) } } func (s *CreateDataCacheRuleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateDataCacheRuleStatement(s) default: @@ -95745,15 +95745,15 @@ func (s *CreateDataCacheRuleStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCacheRuleStatementContext) { +func (p *StarRocksSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCacheRuleStatementContext) { localctx = NewCreateDataCacheRuleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 686, DorisSQLParserRULE_createDataCacheRuleStatement) + p.EnterRule(localctx, 686, StarRocksSQLParserRULE_createDataCacheRuleStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5687) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95761,7 +95761,7 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } { p.SetState(5688) - p.Match(DorisSQLParserDATACACHE) + p.Match(StarRocksSQLParserDATACACHE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95769,7 +95769,7 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } { p.SetState(5689) - p.Match(DorisSQLParserRULE) + p.Match(StarRocksSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95786,10 +95786,10 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(5691) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95803,7 +95803,7 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } { p.SetState(5695) - p.Match(DorisSQLParserPRIORITY) + p.Match(StarRocksSQLParserPRIORITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95811,7 +95811,7 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } { p.SetState(5696) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95824,10 +95824,10 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserMINUS_SYMBOL { + if _la == StarRocksSQLParserMINUS_SYMBOL { { p.SetState(5697) - p.Match(DorisSQLParserMINUS_SYMBOL) + p.Match(StarRocksSQLParserMINUS_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95837,7 +95837,7 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } { p.SetState(5700) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95850,7 +95850,7 @@ func (p *DorisSQLParser) CreateDataCacheRuleStatement() (localctx ICreateDataCac } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5701) p.Properties() @@ -95895,13 +95895,13 @@ type ShowDataCacheRulesStatementContext struct { func NewEmptyShowDataCacheRulesStatementContext() *ShowDataCacheRulesStatementContext { var p = new(ShowDataCacheRulesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataCacheRulesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataCacheRulesStatement return p } func InitEmptyShowDataCacheRulesStatementContext(p *ShowDataCacheRulesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showDataCacheRulesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataCacheRulesStatement } func (*ShowDataCacheRulesStatementContext) IsShowDataCacheRulesStatementContext() {} @@ -95912,7 +95912,7 @@ func NewShowDataCacheRulesStatementContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showDataCacheRulesStatement + p.RuleIndex = StarRocksSQLParserRULE_showDataCacheRulesStatement return p } @@ -95920,15 +95920,15 @@ func NewShowDataCacheRulesStatementContext(parser antlr.Parser, parent antlr.Par func (s *ShowDataCacheRulesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowDataCacheRulesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowDataCacheRulesStatementContext) DATACACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATACACHE, 0) + return s.GetToken(StarRocksSQLParserDATACACHE, 0) } func (s *ShowDataCacheRulesStatementContext) RULES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULES, 0) + return s.GetToken(StarRocksSQLParserRULES, 0) } func (s *ShowDataCacheRulesStatementContext) GetRuleContext() antlr.RuleContext { @@ -95940,20 +95940,20 @@ func (s *ShowDataCacheRulesStatementContext) ToStringTree(ruleNames []string, re } func (s *ShowDataCacheRulesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowDataCacheRulesStatement(s) } } func (s *ShowDataCacheRulesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowDataCacheRulesStatement(s) } } func (s *ShowDataCacheRulesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowDataCacheRulesStatement(s) default: @@ -95961,13 +95961,13 @@ func (s *ShowDataCacheRulesStatementContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) ShowDataCacheRulesStatement() (localctx IShowDataCacheRulesStatementContext) { +func (p *StarRocksSQLParser) ShowDataCacheRulesStatement() (localctx IShowDataCacheRulesStatementContext) { localctx = NewShowDataCacheRulesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 688, DorisSQLParserRULE_showDataCacheRulesStatement) + p.EnterRule(localctx, 688, StarRocksSQLParserRULE_showDataCacheRulesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5704) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95975,7 +95975,7 @@ func (p *DorisSQLParser) ShowDataCacheRulesStatement() (localctx IShowDataCacheR } { p.SetState(5705) - p.Match(DorisSQLParserDATACACHE) + p.Match(StarRocksSQLParserDATACACHE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -95983,7 +95983,7 @@ func (p *DorisSQLParser) ShowDataCacheRulesStatement() (localctx IShowDataCacheR } { p.SetState(5706) - p.Match(DorisSQLParserRULES) + p.Match(StarRocksSQLParserRULES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96028,13 +96028,13 @@ type DropDataCacheRuleStatementContext struct { func NewEmptyDropDataCacheRuleStatementContext() *DropDataCacheRuleStatementContext { var p = new(DropDataCacheRuleStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropDataCacheRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDataCacheRuleStatement return p } func InitEmptyDropDataCacheRuleStatementContext(p *DropDataCacheRuleStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropDataCacheRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDataCacheRuleStatement } func (*DropDataCacheRuleStatementContext) IsDropDataCacheRuleStatementContext() {} @@ -96045,7 +96045,7 @@ func NewDropDataCacheRuleStatementContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropDataCacheRuleStatement + p.RuleIndex = StarRocksSQLParserRULE_dropDataCacheRuleStatement return p } @@ -96053,19 +96053,19 @@ func NewDropDataCacheRuleStatementContext(parser antlr.Parser, parent antlr.Pars func (s *DropDataCacheRuleStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropDataCacheRuleStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropDataCacheRuleStatementContext) DATACACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATACACHE, 0) + return s.GetToken(StarRocksSQLParserDATACACHE, 0) } func (s *DropDataCacheRuleStatementContext) RULE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULE, 0) + return s.GetToken(StarRocksSQLParserRULE, 0) } func (s *DropDataCacheRuleStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *DropDataCacheRuleStatementContext) GetRuleContext() antlr.RuleContext { @@ -96077,20 +96077,20 @@ func (s *DropDataCacheRuleStatementContext) ToStringTree(ruleNames []string, rec } func (s *DropDataCacheRuleStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropDataCacheRuleStatement(s) } } func (s *DropDataCacheRuleStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropDataCacheRuleStatement(s) } } func (s *DropDataCacheRuleStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropDataCacheRuleStatement(s) default: @@ -96098,13 +96098,13 @@ func (s *DropDataCacheRuleStatementContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) DropDataCacheRuleStatement() (localctx IDropDataCacheRuleStatementContext) { +func (p *StarRocksSQLParser) DropDataCacheRuleStatement() (localctx IDropDataCacheRuleStatementContext) { localctx = NewDropDataCacheRuleStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 690, DorisSQLParserRULE_dropDataCacheRuleStatement) + p.EnterRule(localctx, 690, StarRocksSQLParserRULE_dropDataCacheRuleStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5708) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96112,7 +96112,7 @@ func (p *DorisSQLParser) DropDataCacheRuleStatement() (localctx IDropDataCacheRu } { p.SetState(5709) - p.Match(DorisSQLParserDATACACHE) + p.Match(StarRocksSQLParserDATACACHE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96120,7 +96120,7 @@ func (p *DorisSQLParser) DropDataCacheRuleStatement() (localctx IDropDataCacheRu } { p.SetState(5710) - p.Match(DorisSQLParserRULE) + p.Match(StarRocksSQLParserRULE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96128,7 +96128,7 @@ func (p *DorisSQLParser) DropDataCacheRuleStatement() (localctx IDropDataCacheRu } { p.SetState(5711) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96172,13 +96172,13 @@ type ClearDataCacheRulesStatementContext struct { func NewEmptyClearDataCacheRulesStatementContext() *ClearDataCacheRulesStatementContext { var p = new(ClearDataCacheRulesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_clearDataCacheRulesStatement + p.RuleIndex = StarRocksSQLParserRULE_clearDataCacheRulesStatement return p } func InitEmptyClearDataCacheRulesStatementContext(p *ClearDataCacheRulesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_clearDataCacheRulesStatement + p.RuleIndex = StarRocksSQLParserRULE_clearDataCacheRulesStatement } func (*ClearDataCacheRulesStatementContext) IsClearDataCacheRulesStatementContext() {} @@ -96189,7 +96189,7 @@ func NewClearDataCacheRulesStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_clearDataCacheRulesStatement + p.RuleIndex = StarRocksSQLParserRULE_clearDataCacheRulesStatement return p } @@ -96197,15 +96197,15 @@ func NewClearDataCacheRulesStatementContext(parser antlr.Parser, parent antlr.Pa func (s *ClearDataCacheRulesStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ClearDataCacheRulesStatementContext) CLEAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLEAR, 0) + return s.GetToken(StarRocksSQLParserCLEAR, 0) } func (s *ClearDataCacheRulesStatementContext) DATACACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATACACHE, 0) + return s.GetToken(StarRocksSQLParserDATACACHE, 0) } func (s *ClearDataCacheRulesStatementContext) RULES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULES, 0) + return s.GetToken(StarRocksSQLParserRULES, 0) } func (s *ClearDataCacheRulesStatementContext) GetRuleContext() antlr.RuleContext { @@ -96217,20 +96217,20 @@ func (s *ClearDataCacheRulesStatementContext) ToStringTree(ruleNames []string, r } func (s *ClearDataCacheRulesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterClearDataCacheRulesStatement(s) } } func (s *ClearDataCacheRulesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitClearDataCacheRulesStatement(s) } } func (s *ClearDataCacheRulesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitClearDataCacheRulesStatement(s) default: @@ -96238,13 +96238,13 @@ func (s *ClearDataCacheRulesStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) ClearDataCacheRulesStatement() (localctx IClearDataCacheRulesStatementContext) { +func (p *StarRocksSQLParser) ClearDataCacheRulesStatement() (localctx IClearDataCacheRulesStatementContext) { localctx = NewClearDataCacheRulesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 692, DorisSQLParserRULE_clearDataCacheRulesStatement) + p.EnterRule(localctx, 692, StarRocksSQLParserRULE_clearDataCacheRulesStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5713) - p.Match(DorisSQLParserCLEAR) + p.Match(StarRocksSQLParserCLEAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96252,7 +96252,7 @@ func (p *DorisSQLParser) ClearDataCacheRulesStatement() (localctx IClearDataCach } { p.SetState(5714) - p.Match(DorisSQLParserDATACACHE) + p.Match(StarRocksSQLParserDATACACHE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96260,7 +96260,7 @@ func (p *DorisSQLParser) ClearDataCacheRulesStatement() (localctx IClearDataCach } { p.SetState(5715) - p.Match(DorisSQLParserRULES) + p.Match(StarRocksSQLParserRULES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96317,13 +96317,13 @@ type DataCacheSelectStatementContext struct { func NewEmptyDataCacheSelectStatementContext() *DataCacheSelectStatementContext { var p = new(DataCacheSelectStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataCacheSelectStatement + p.RuleIndex = StarRocksSQLParserRULE_dataCacheSelectStatement return p } func InitEmptyDataCacheSelectStatementContext(p *DataCacheSelectStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dataCacheSelectStatement + p.RuleIndex = StarRocksSQLParserRULE_dataCacheSelectStatement } func (*DataCacheSelectStatementContext) IsDataCacheSelectStatementContext() {} @@ -96334,7 +96334,7 @@ func NewDataCacheSelectStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dataCacheSelectStatement + p.RuleIndex = StarRocksSQLParserRULE_dataCacheSelectStatement return p } @@ -96346,11 +96346,11 @@ func (s *DataCacheSelectStatementContext) GetWhere() IExpressionContext { return func (s *DataCacheSelectStatementContext) SetWhere(v IExpressionContext) { s.where = v } func (s *DataCacheSelectStatementContext) CACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCACHE, 0) + return s.GetToken(StarRocksSQLParserCACHE, 0) } func (s *DataCacheSelectStatementContext) SELECT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSELECT, 0) + return s.GetToken(StarRocksSQLParserSELECT, 0) } func (s *DataCacheSelectStatementContext) AllSelectItem() []ISelectItemContext { @@ -96395,7 +96395,7 @@ func (s *DataCacheSelectStatementContext) SelectItem(i int) ISelectItemContext { } func (s *DataCacheSelectStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DataCacheSelectStatementContext) QualifiedName() IQualifiedNameContext { @@ -96415,7 +96415,7 @@ func (s *DataCacheSelectStatementContext) QualifiedName() IQualifiedNameContext } func (s *DataCacheSelectStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *DataCacheSelectStatementContext) Properties() IPropertiesContext { @@ -96459,20 +96459,20 @@ func (s *DataCacheSelectStatementContext) ToStringTree(ruleNames []string, recog } func (s *DataCacheSelectStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDataCacheSelectStatement(s) } } func (s *DataCacheSelectStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDataCacheSelectStatement(s) } } func (s *DataCacheSelectStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDataCacheSelectStatement(s) default: @@ -96480,15 +96480,15 @@ func (s *DataCacheSelectStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectStatementContext) { +func (p *StarRocksSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectStatementContext) { localctx = NewDataCacheSelectStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 694, DorisSQLParserRULE_dataCacheSelectStatement) + p.EnterRule(localctx, 694, StarRocksSQLParserRULE_dataCacheSelectStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5717) - p.Match(DorisSQLParserCACHE) + p.Match(StarRocksSQLParserCACHE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96496,7 +96496,7 @@ func (p *DorisSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectSt } { p.SetState(5718) - p.Match(DorisSQLParserSELECT) + p.Match(StarRocksSQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96513,10 +96513,10 @@ func (p *DorisSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectSt } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5720) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96536,7 +96536,7 @@ func (p *DorisSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectSt } { p.SetState(5727) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96553,10 +96553,10 @@ func (p *DorisSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWHERE { + if _la == StarRocksSQLParserWHERE { { p.SetState(5729) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96578,7 +96578,7 @@ func (p *DorisSQLParser) DataCacheSelectStatement() (localctx IDataCacheSelectSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5733) p.Properties() @@ -96632,13 +96632,13 @@ type ExportStatementContext struct { func NewEmptyExportStatementContext() *ExportStatementContext { var p = new(ExportStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_exportStatement + p.RuleIndex = StarRocksSQLParserRULE_exportStatement return p } func InitEmptyExportStatementContext(p *ExportStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_exportStatement + p.RuleIndex = StarRocksSQLParserRULE_exportStatement } func (*ExportStatementContext) IsExportStatementContext() {} @@ -96649,7 +96649,7 @@ func NewExportStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_exportStatement + p.RuleIndex = StarRocksSQLParserRULE_exportStatement return p } @@ -96657,11 +96657,11 @@ func NewExportStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *ExportStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ExportStatementContext) EXPORT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPORT, 0) + return s.GetToken(StarRocksSQLParserEXPORT, 0) } func (s *ExportStatementContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *ExportStatementContext) TableDesc() ITableDescContext { @@ -96681,7 +96681,7 @@ func (s *ExportStatementContext) TableDesc() ITableDescContext { } func (s *ExportStatementContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *ExportStatementContext) String_() IStringContext { @@ -96717,11 +96717,11 @@ func (s *ExportStatementContext) ColumnAliases() IColumnAliasesContext { } func (s *ExportStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *ExportStatementContext) MODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODE, 0) + return s.GetToken(StarRocksSQLParserMODE, 0) } func (s *ExportStatementContext) Properties() IPropertiesContext { @@ -96757,11 +96757,11 @@ func (s *ExportStatementContext) BrokerDesc() IBrokerDescContext { } func (s *ExportStatementContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *ExportStatementContext) ASYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASYNC, 0) + return s.GetToken(StarRocksSQLParserASYNC, 0) } func (s *ExportStatementContext) GetRuleContext() antlr.RuleContext { @@ -96773,20 +96773,20 @@ func (s *ExportStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *ExportStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExportStatement(s) } } func (s *ExportStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExportStatement(s) } } func (s *ExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExportStatement(s) default: @@ -96794,15 +96794,15 @@ func (s *ExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { +func (p *StarRocksSQLParser) ExportStatement() (localctx IExportStatementContext) { localctx = NewExportStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 696, DorisSQLParserRULE_exportStatement) + p.EnterRule(localctx, 696, StarRocksSQLParserRULE_exportStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5736) - p.Match(DorisSQLParserEXPORT) + p.Match(StarRocksSQLParserEXPORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96810,7 +96810,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { } { p.SetState(5737) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96827,7 +96827,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(5739) p.ColumnAliases() @@ -96836,7 +96836,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { } { p.SetState(5742) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96852,7 +96852,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) == 1 { { p.SetState(5744) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96862,7 +96862,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { p.SetState(5745) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserASYNC || _la == DorisSQLParserSYNC) { + if !(_la == StarRocksSQLParserASYNC || _la == StarRocksSQLParserSYNC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -96871,7 +96871,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { } { p.SetState(5746) - p.Match(DorisSQLParserMODE) + p.Match(StarRocksSQLParserMODE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -96888,7 +96888,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5749) p.Properties() @@ -96902,7 +96902,7 @@ func (p *DorisSQLParser) ExportStatement() (localctx IExportStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(5752) p.BrokerDesc() @@ -96967,13 +96967,13 @@ type CancelExportStatementContext struct { func NewEmptyCancelExportStatementContext() *CancelExportStatementContext { var p = new(CancelExportStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelExportStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelExportStatement return p } func InitEmptyCancelExportStatementContext(p *CancelExportStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_cancelExportStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelExportStatement } func (*CancelExportStatementContext) IsCancelExportStatementContext() {} @@ -96984,7 +96984,7 @@ func NewCancelExportStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_cancelExportStatement + p.RuleIndex = StarRocksSQLParserRULE_cancelExportStatement return p } @@ -97000,19 +97000,19 @@ func (s *CancelExportStatementContext) SetCatalog(v IQualifiedNameContext) { s.c func (s *CancelExportStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *CancelExportStatementContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *CancelExportStatementContext) EXPORT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPORT, 0) + return s.GetToken(StarRocksSQLParserEXPORT, 0) } func (s *CancelExportStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CancelExportStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *CancelExportStatementContext) QualifiedName() IQualifiedNameContext { @@ -97032,11 +97032,11 @@ func (s *CancelExportStatementContext) QualifiedName() IQualifiedNameContext { } func (s *CancelExportStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *CancelExportStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *CancelExportStatementContext) Expression() IExpressionContext { @@ -97080,20 +97080,20 @@ func (s *CancelExportStatementContext) ToStringTree(ruleNames []string, recog an } func (s *CancelExportStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCancelExportStatement(s) } } func (s *CancelExportStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCancelExportStatement(s) } } func (s *CancelExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCancelExportStatement(s) default: @@ -97101,15 +97101,15 @@ func (s *CancelExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) CancelExportStatement() (localctx ICancelExportStatementContext) { +func (p *StarRocksSQLParser) CancelExportStatement() (localctx ICancelExportStatementContext) { localctx = NewCancelExportStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 698, DorisSQLParserRULE_cancelExportStatement) + p.EnterRule(localctx, 698, StarRocksSQLParserRULE_cancelExportStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5755) - p.Match(DorisSQLParserCANCEL) + p.Match(StarRocksSQLParserCANCEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97117,7 +97117,7 @@ func (p *DorisSQLParser) CancelExportStatement() (localctx ICancelExportStatemen } { p.SetState(5756) - p.Match(DorisSQLParserEXPORT) + p.Match(StarRocksSQLParserEXPORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97130,12 +97130,12 @@ func (p *DorisSQLParser) CancelExportStatement() (localctx ICancelExportStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5757) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -97157,10 +97157,10 @@ func (p *DorisSQLParser) CancelExportStatement() (localctx ICancelExportStatemen goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(5761) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97174,10 +97174,10 @@ func (p *DorisSQLParser) CancelExportStatement() (localctx ICancelExportStatemen localctx.(*CancelExportStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(5763) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97188,7 +97188,7 @@ func (p *DorisSQLParser) CancelExportStatement() (localctx ICancelExportStatemen p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserSEMICOLON: default: } @@ -97255,13 +97255,13 @@ type ShowExportStatementContext struct { func NewEmptyShowExportStatementContext() *ShowExportStatementContext { var p = new(ShowExportStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showExportStatement + p.RuleIndex = StarRocksSQLParserRULE_showExportStatement return p } func InitEmptyShowExportStatementContext(p *ShowExportStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showExportStatement + p.RuleIndex = StarRocksSQLParserRULE_showExportStatement } func (*ShowExportStatementContext) IsShowExportStatementContext() {} @@ -97272,7 +97272,7 @@ func NewShowExportStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showExportStatement + p.RuleIndex = StarRocksSQLParserRULE_showExportStatement return p } @@ -97288,19 +97288,19 @@ func (s *ShowExportStatementContext) SetCatalog(v IQualifiedNameContext) { s.cat func (s *ShowExportStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowExportStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowExportStatementContext) EXPORT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPORT, 0) + return s.GetToken(StarRocksSQLParserEXPORT, 0) } func (s *ShowExportStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowExportStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowExportStatementContext) AllSortItem() []ISortItemContext { @@ -97361,11 +97361,11 @@ func (s *ShowExportStatementContext) LimitElement() ILimitElementContext { } func (s *ShowExportStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowExportStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowExportStatementContext) QualifiedName() IQualifiedNameContext { @@ -97385,11 +97385,11 @@ func (s *ShowExportStatementContext) QualifiedName() IQualifiedNameContext { } func (s *ShowExportStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowExportStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowExportStatementContext) Expression() IExpressionContext { @@ -97433,20 +97433,20 @@ func (s *ShowExportStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *ShowExportStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowExportStatement(s) } } func (s *ShowExportStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowExportStatement(s) } } func (s *ShowExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowExportStatement(s) default: @@ -97454,15 +97454,15 @@ func (s *ShowExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementContext) { +func (p *StarRocksSQLParser) ShowExportStatement() (localctx IShowExportStatementContext) { localctx = NewShowExportStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 700, DorisSQLParserRULE_showExportStatement) + p.EnterRule(localctx, 700, StarRocksSQLParserRULE_showExportStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5767) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97470,7 +97470,7 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon } { p.SetState(5768) - p.Match(DorisSQLParserEXPORT) + p.Match(StarRocksSQLParserEXPORT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97483,12 +97483,12 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5769) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -97510,10 +97510,10 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(5773) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97527,10 +97527,10 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon localctx.(*ShowExportStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(5775) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97541,7 +97541,7 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon p.expression(0) } - case DorisSQLParserEOF, DorisSQLParserLIMIT, DorisSQLParserORDER, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserLIMIT, StarRocksSQLParserORDER, StarRocksSQLParserSEMICOLON: default: } @@ -97552,10 +97552,10 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(5779) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97563,7 +97563,7 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon } { p.SetState(5780) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97580,10 +97580,10 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5782) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97610,7 +97610,7 @@ func (p *DorisSQLParser) ShowExportStatement() (localctx IShowExportStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(5791) p.LimitElement() @@ -97657,13 +97657,13 @@ type InstallPluginStatementContext struct { func NewEmptyInstallPluginStatementContext() *InstallPluginStatementContext { var p = new(InstallPluginStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_installPluginStatement + p.RuleIndex = StarRocksSQLParserRULE_installPluginStatement return p } func InitEmptyInstallPluginStatementContext(p *InstallPluginStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_installPluginStatement + p.RuleIndex = StarRocksSQLParserRULE_installPluginStatement } func (*InstallPluginStatementContext) IsInstallPluginStatementContext() {} @@ -97674,7 +97674,7 @@ func NewInstallPluginStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_installPluginStatement + p.RuleIndex = StarRocksSQLParserRULE_installPluginStatement return p } @@ -97682,15 +97682,15 @@ func NewInstallPluginStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *InstallPluginStatementContext) GetParser() antlr.Parser { return s.parser } func (s *InstallPluginStatementContext) INSTALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINSTALL, 0) + return s.GetToken(StarRocksSQLParserINSTALL, 0) } func (s *InstallPluginStatementContext) PLUGIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUGIN, 0) + return s.GetToken(StarRocksSQLParserPLUGIN, 0) } func (s *InstallPluginStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *InstallPluginStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -97734,20 +97734,20 @@ func (s *InstallPluginStatementContext) ToStringTree(ruleNames []string, recog a } func (s *InstallPluginStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInstallPluginStatement(s) } } func (s *InstallPluginStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInstallPluginStatement(s) } } func (s *InstallPluginStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInstallPluginStatement(s) default: @@ -97755,15 +97755,15 @@ func (s *InstallPluginStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) InstallPluginStatement() (localctx IInstallPluginStatementContext) { +func (p *StarRocksSQLParser) InstallPluginStatement() (localctx IInstallPluginStatementContext) { localctx = NewInstallPluginStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 702, DorisSQLParserRULE_installPluginStatement) + p.EnterRule(localctx, 702, StarRocksSQLParserRULE_installPluginStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5794) - p.Match(DorisSQLParserINSTALL) + p.Match(StarRocksSQLParserINSTALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97771,7 +97771,7 @@ func (p *DorisSQLParser) InstallPluginStatement() (localctx IInstallPluginStatem } { p.SetState(5795) - p.Match(DorisSQLParserPLUGIN) + p.Match(StarRocksSQLParserPLUGIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97779,7 +97779,7 @@ func (p *DorisSQLParser) InstallPluginStatement() (localctx IInstallPluginStatem } { p.SetState(5796) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97796,7 +97796,7 @@ func (p *DorisSQLParser) InstallPluginStatement() (localctx IInstallPluginStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5798) p.Properties() @@ -97841,13 +97841,13 @@ type UninstallPluginStatementContext struct { func NewEmptyUninstallPluginStatementContext() *UninstallPluginStatementContext { var p = new(UninstallPluginStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_uninstallPluginStatement + p.RuleIndex = StarRocksSQLParserRULE_uninstallPluginStatement return p } func InitEmptyUninstallPluginStatementContext(p *UninstallPluginStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_uninstallPluginStatement + p.RuleIndex = StarRocksSQLParserRULE_uninstallPluginStatement } func (*UninstallPluginStatementContext) IsUninstallPluginStatementContext() {} @@ -97858,7 +97858,7 @@ func NewUninstallPluginStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_uninstallPluginStatement + p.RuleIndex = StarRocksSQLParserRULE_uninstallPluginStatement return p } @@ -97866,11 +97866,11 @@ func NewUninstallPluginStatementContext(parser antlr.Parser, parent antlr.Parser func (s *UninstallPluginStatementContext) GetParser() antlr.Parser { return s.parser } func (s *UninstallPluginStatementContext) UNINSTALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNINSTALL, 0) + return s.GetToken(StarRocksSQLParserUNINSTALL, 0) } func (s *UninstallPluginStatementContext) PLUGIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUGIN, 0) + return s.GetToken(StarRocksSQLParserPLUGIN, 0) } func (s *UninstallPluginStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -97898,20 +97898,20 @@ func (s *UninstallPluginStatementContext) ToStringTree(ruleNames []string, recog } func (s *UninstallPluginStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUninstallPluginStatement(s) } } func (s *UninstallPluginStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUninstallPluginStatement(s) } } func (s *UninstallPluginStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUninstallPluginStatement(s) default: @@ -97919,13 +97919,13 @@ func (s *UninstallPluginStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) UninstallPluginStatement() (localctx IUninstallPluginStatementContext) { +func (p *StarRocksSQLParser) UninstallPluginStatement() (localctx IUninstallPluginStatementContext) { localctx = NewUninstallPluginStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 704, DorisSQLParserRULE_uninstallPluginStatement) + p.EnterRule(localctx, 704, StarRocksSQLParserRULE_uninstallPluginStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5801) - p.Match(DorisSQLParserUNINSTALL) + p.Match(StarRocksSQLParserUNINSTALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97933,7 +97933,7 @@ func (p *DorisSQLParser) UninstallPluginStatement() (localctx IUninstallPluginSt } { p.SetState(5802) - p.Match(DorisSQLParserPLUGIN) + p.Match(StarRocksSQLParserPLUGIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -97992,13 +97992,13 @@ type CreateFileStatementContext struct { func NewEmptyCreateFileStatementContext() *CreateFileStatementContext { var p = new(CreateFileStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createFileStatement + p.RuleIndex = StarRocksSQLParserRULE_createFileStatement return p } func InitEmptyCreateFileStatementContext(p *CreateFileStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createFileStatement + p.RuleIndex = StarRocksSQLParserRULE_createFileStatement } func (*CreateFileStatementContext) IsCreateFileStatementContext() {} @@ -98009,7 +98009,7 @@ func NewCreateFileStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createFileStatement + p.RuleIndex = StarRocksSQLParserRULE_createFileStatement return p } @@ -98021,11 +98021,11 @@ func (s *CreateFileStatementContext) GetCatalog() IQualifiedNameContext { return func (s *CreateFileStatementContext) SetCatalog(v IQualifiedNameContext) { s.catalog = v } func (s *CreateFileStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateFileStatementContext) FILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILE, 0) + return s.GetToken(StarRocksSQLParserFILE, 0) } func (s *CreateFileStatementContext) String_() IStringContext { @@ -98061,11 +98061,11 @@ func (s *CreateFileStatementContext) Properties() IPropertiesContext { } func (s *CreateFileStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *CreateFileStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *CreateFileStatementContext) QualifiedName() IQualifiedNameContext { @@ -98093,20 +98093,20 @@ func (s *CreateFileStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *CreateFileStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateFileStatement(s) } } func (s *CreateFileStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateFileStatement(s) } } func (s *CreateFileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateFileStatement(s) default: @@ -98114,15 +98114,15 @@ func (s *CreateFileStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) CreateFileStatement() (localctx ICreateFileStatementContext) { +func (p *StarRocksSQLParser) CreateFileStatement() (localctx ICreateFileStatementContext) { localctx = NewCreateFileStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 706, DorisSQLParserRULE_createFileStatement) + p.EnterRule(localctx, 706, StarRocksSQLParserRULE_createFileStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5805) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98130,7 +98130,7 @@ func (p *DorisSQLParser) CreateFileStatement() (localctx ICreateFileStatementCon } { p.SetState(5806) - p.Match(DorisSQLParserFILE) + p.Match(StarRocksSQLParserFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98147,12 +98147,12 @@ func (p *DorisSQLParser) CreateFileStatement() (localctx ICreateFileStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5808) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -98221,13 +98221,13 @@ type DropFileStatementContext struct { func NewEmptyDropFileStatementContext() *DropFileStatementContext { var p = new(DropFileStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFileStatement + p.RuleIndex = StarRocksSQLParserRULE_dropFileStatement return p } func InitEmptyDropFileStatementContext(p *DropFileStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropFileStatement + p.RuleIndex = StarRocksSQLParserRULE_dropFileStatement } func (*DropFileStatementContext) IsDropFileStatementContext() {} @@ -98238,7 +98238,7 @@ func NewDropFileStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropFileStatement + p.RuleIndex = StarRocksSQLParserRULE_dropFileStatement return p } @@ -98250,11 +98250,11 @@ func (s *DropFileStatementContext) GetCatalog() IQualifiedNameContext { return s func (s *DropFileStatementContext) SetCatalog(v IQualifiedNameContext) { s.catalog = v } func (s *DropFileStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropFileStatementContext) FILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILE, 0) + return s.GetToken(StarRocksSQLParserFILE, 0) } func (s *DropFileStatementContext) String_() IStringContext { @@ -98290,11 +98290,11 @@ func (s *DropFileStatementContext) Properties() IPropertiesContext { } func (s *DropFileStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DropFileStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *DropFileStatementContext) QualifiedName() IQualifiedNameContext { @@ -98322,20 +98322,20 @@ func (s *DropFileStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropFileStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropFileStatement(s) } } func (s *DropFileStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropFileStatement(s) } } func (s *DropFileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropFileStatement(s) default: @@ -98343,15 +98343,15 @@ func (s *DropFileStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropFileStatement() (localctx IDropFileStatementContext) { +func (p *StarRocksSQLParser) DropFileStatement() (localctx IDropFileStatementContext) { localctx = NewDropFileStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 708, DorisSQLParserRULE_dropFileStatement) + p.EnterRule(localctx, 708, StarRocksSQLParserRULE_dropFileStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5814) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98359,7 +98359,7 @@ func (p *DorisSQLParser) DropFileStatement() (localctx IDropFileStatementContext } { p.SetState(5815) - p.Match(DorisSQLParserFILE) + p.Match(StarRocksSQLParserFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98376,12 +98376,12 @@ func (p *DorisSQLParser) DropFileStatement() (localctx IDropFileStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5817) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -98448,13 +98448,13 @@ type ShowSmallFilesStatementContext struct { func NewEmptyShowSmallFilesStatementContext() *ShowSmallFilesStatementContext { var p = new(ShowSmallFilesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSmallFilesStatement + p.RuleIndex = StarRocksSQLParserRULE_showSmallFilesStatement return p } func InitEmptyShowSmallFilesStatementContext(p *ShowSmallFilesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showSmallFilesStatement + p.RuleIndex = StarRocksSQLParserRULE_showSmallFilesStatement } func (*ShowSmallFilesStatementContext) IsShowSmallFilesStatementContext() {} @@ -98465,7 +98465,7 @@ func NewShowSmallFilesStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showSmallFilesStatement + p.RuleIndex = StarRocksSQLParserRULE_showSmallFilesStatement return p } @@ -98477,19 +98477,19 @@ func (s *ShowSmallFilesStatementContext) GetCatalog() IQualifiedNameContext { re func (s *ShowSmallFilesStatementContext) SetCatalog(v IQualifiedNameContext) { s.catalog = v } func (s *ShowSmallFilesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowSmallFilesStatementContext) FILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILE, 0) + return s.GetToken(StarRocksSQLParserFILE, 0) } func (s *ShowSmallFilesStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowSmallFilesStatementContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *ShowSmallFilesStatementContext) QualifiedName() IQualifiedNameContext { @@ -98517,20 +98517,20 @@ func (s *ShowSmallFilesStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowSmallFilesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowSmallFilesStatement(s) } } func (s *ShowSmallFilesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowSmallFilesStatement(s) } } func (s *ShowSmallFilesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowSmallFilesStatement(s) default: @@ -98538,15 +98538,15 @@ func (s *ShowSmallFilesStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowSmallFilesStatement() (localctx IShowSmallFilesStatementContext) { +func (p *StarRocksSQLParser) ShowSmallFilesStatement() (localctx IShowSmallFilesStatementContext) { localctx = NewShowSmallFilesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 710, DorisSQLParserRULE_showSmallFilesStatement) + p.EnterRule(localctx, 710, StarRocksSQLParserRULE_showSmallFilesStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5823) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98554,7 +98554,7 @@ func (p *DorisSQLParser) ShowSmallFilesStatement() (localctx IShowSmallFilesStat } { p.SetState(5824) - p.Match(DorisSQLParserFILE) + p.Match(StarRocksSQLParserFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98567,12 +98567,12 @@ func (p *DorisSQLParser) ShowSmallFilesStatement() (localctx IShowSmallFilesStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFROM || _la == DorisSQLParserIN { + if _la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN { { p.SetState(5825) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFROM || _la == DorisSQLParserIN) { + if !(_la == StarRocksSQLParserFROM || _la == StarRocksSQLParserIN) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -98631,13 +98631,13 @@ type CreatePipeStatementContext struct { func NewEmptyCreatePipeStatementContext() *CreatePipeStatementContext { var p = new(CreatePipeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_createPipeStatement return p } func InitEmptyCreatePipeStatementContext(p *CreatePipeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_createPipeStatement } func (*CreatePipeStatementContext) IsCreatePipeStatementContext() {} @@ -98648,7 +98648,7 @@ func NewCreatePipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_createPipeStatement return p } @@ -98656,7 +98656,7 @@ func NewCreatePipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *CreatePipeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CreatePipeStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreatePipeStatementContext) OrReplace() IOrReplaceContext { @@ -98676,7 +98676,7 @@ func (s *CreatePipeStatementContext) OrReplace() IOrReplaceContext { } func (s *CreatePipeStatementContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *CreatePipeStatementContext) IfNotExists() IIfNotExistsContext { @@ -98712,7 +98712,7 @@ func (s *CreatePipeStatementContext) QualifiedName() IQualifiedNameContext { } func (s *CreatePipeStatementContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *CreatePipeStatementContext) InsertStatement() IInsertStatementContext { @@ -98756,20 +98756,20 @@ func (s *CreatePipeStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *CreatePipeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreatePipeStatement(s) } } func (s *CreatePipeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreatePipeStatement(s) } } func (s *CreatePipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreatePipeStatement(s) default: @@ -98777,15 +98777,15 @@ func (s *CreatePipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) CreatePipeStatement() (localctx ICreatePipeStatementContext) { +func (p *StarRocksSQLParser) CreatePipeStatement() (localctx ICreatePipeStatementContext) { localctx = NewCreatePipeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 712, DorisSQLParserRULE_createPipeStatement) + p.EnterRule(localctx, 712, StarRocksSQLParserRULE_createPipeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5829) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98797,7 +98797,7 @@ func (p *DorisSQLParser) CreatePipeStatement() (localctx ICreatePipeStatementCon } { p.SetState(5831) - p.Match(DorisSQLParserPIPE) + p.Match(StarRocksSQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98818,7 +98818,7 @@ func (p *DorisSQLParser) CreatePipeStatement() (localctx ICreatePipeStatementCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(5834) p.Properties() @@ -98827,7 +98827,7 @@ func (p *DorisSQLParser) CreatePipeStatement() (localctx ICreatePipeStatementCon } { p.SetState(5837) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98877,13 +98877,13 @@ type DropPipeStatementContext struct { func NewEmptyDropPipeStatementContext() *DropPipeStatementContext { var p = new(DropPipeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_dropPipeStatement return p } func InitEmptyDropPipeStatementContext(p *DropPipeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_dropPipeStatement } func (*DropPipeStatementContext) IsDropPipeStatementContext() {} @@ -98894,7 +98894,7 @@ func NewDropPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_dropPipeStatement return p } @@ -98902,11 +98902,11 @@ func NewDropPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DropPipeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DropPipeStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropPipeStatementContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *DropPipeStatementContext) QualifiedName() IQualifiedNameContext { @@ -98926,11 +98926,11 @@ func (s *DropPipeStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DropPipeStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropPipeStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropPipeStatementContext) GetRuleContext() antlr.RuleContext { @@ -98942,20 +98942,20 @@ func (s *DropPipeStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DropPipeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropPipeStatement(s) } } func (s *DropPipeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropPipeStatement(s) } } func (s *DropPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropPipeStatement(s) default: @@ -98963,15 +98963,15 @@ func (s *DropPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DropPipeStatement() (localctx IDropPipeStatementContext) { +func (p *StarRocksSQLParser) DropPipeStatement() (localctx IDropPipeStatementContext) { localctx = NewDropPipeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 714, DorisSQLParserRULE_dropPipeStatement) + p.EnterRule(localctx, 714, StarRocksSQLParserRULE_dropPipeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5840) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98979,7 +98979,7 @@ func (p *DorisSQLParser) DropPipeStatement() (localctx IDropPipeStatementContext } { p.SetState(5841) - p.Match(DorisSQLParserPIPE) + p.Match(StarRocksSQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -98992,10 +98992,10 @@ func (p *DorisSQLParser) DropPipeStatement() (localctx IDropPipeStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(5842) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99003,7 +99003,7 @@ func (p *DorisSQLParser) DropPipeStatement() (localctx IDropPipeStatementContext } { p.SetState(5843) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99065,13 +99065,13 @@ type AlterPipeClauseContext struct { func NewEmptyAlterPipeClauseContext() *AlterPipeClauseContext { var p = new(AlterPipeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPipeClause + p.RuleIndex = StarRocksSQLParserRULE_alterPipeClause return p } func InitEmptyAlterPipeClauseContext(p *AlterPipeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPipeClause + p.RuleIndex = StarRocksSQLParserRULE_alterPipeClause } func (*AlterPipeClauseContext) IsAlterPipeClauseContext() {} @@ -99082,7 +99082,7 @@ func NewAlterPipeClauseContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterPipeClause + p.RuleIndex = StarRocksSQLParserRULE_alterPipeClause return p } @@ -99094,23 +99094,23 @@ func (s *AlterPipeClauseContext) GetFileName() IStringContext { return s.fileNam func (s *AlterPipeClauseContext) SetFileName(v IStringContext) { s.fileName = v } func (s *AlterPipeClauseContext) SUSPEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUSPEND, 0) + return s.GetToken(StarRocksSQLParserSUSPEND, 0) } func (s *AlterPipeClauseContext) RESUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESUME, 0) + return s.GetToken(StarRocksSQLParserRESUME, 0) } func (s *AlterPipeClauseContext) RETRY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETRY, 0) + return s.GetToken(StarRocksSQLParserRETRY, 0) } func (s *AlterPipeClauseContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *AlterPipeClauseContext) FILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILE, 0) + return s.GetToken(StarRocksSQLParserFILE, 0) } func (s *AlterPipeClauseContext) String_() IStringContext { @@ -99130,7 +99130,7 @@ func (s *AlterPipeClauseContext) String_() IStringContext { } func (s *AlterPipeClauseContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *AlterPipeClauseContext) PropertyList() IPropertyListContext { @@ -99158,20 +99158,20 @@ func (s *AlterPipeClauseContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *AlterPipeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterPipeClause(s) } } func (s *AlterPipeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterPipeClause(s) } } func (s *AlterPipeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterPipeClause(s) default: @@ -99179,9 +99179,9 @@ func (s *AlterPipeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { +func (p *StarRocksSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { localctx = NewAlterPipeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 716, DorisSQLParserRULE_alterPipeClause) + p.EnterRule(localctx, 716, StarRocksSQLParserRULE_alterPipeClause) p.SetState(5857) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -99193,7 +99193,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(5848) - p.Match(DorisSQLParserSUSPEND) + p.Match(StarRocksSQLParserSUSPEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99204,7 +99204,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(5849) - p.Match(DorisSQLParserRESUME) + p.Match(StarRocksSQLParserRESUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99215,7 +99215,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(5850) - p.Match(DorisSQLParserRETRY) + p.Match(StarRocksSQLParserRETRY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99223,7 +99223,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { } { p.SetState(5851) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99234,7 +99234,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(5852) - p.Match(DorisSQLParserRETRY) + p.Match(StarRocksSQLParserRETRY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99242,7 +99242,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { } { p.SetState(5853) - p.Match(DorisSQLParserFILE) + p.Match(StarRocksSQLParserFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99260,7 +99260,7 @@ func (p *DorisSQLParser) AlterPipeClause() (localctx IAlterPipeClauseContext) { p.EnterOuterAlt(localctx, 5) { p.SetState(5855) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99313,13 +99313,13 @@ type AlterPipeStatementContext struct { func NewEmptyAlterPipeStatementContext() *AlterPipeStatementContext { var p = new(AlterPipeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPipeStatement return p } func InitEmptyAlterPipeStatementContext(p *AlterPipeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPipeStatement } func (*AlterPipeStatementContext) IsAlterPipeStatementContext() {} @@ -99330,7 +99330,7 @@ func NewAlterPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPipeStatement return p } @@ -99338,11 +99338,11 @@ func NewAlterPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *AlterPipeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterPipeStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterPipeStatementContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *AlterPipeStatementContext) QualifiedName() IQualifiedNameContext { @@ -99386,20 +99386,20 @@ func (s *AlterPipeStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *AlterPipeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterPipeStatement(s) } } func (s *AlterPipeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterPipeStatement(s) } } func (s *AlterPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterPipeStatement(s) default: @@ -99407,13 +99407,13 @@ func (s *AlterPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) AlterPipeStatement() (localctx IAlterPipeStatementContext) { +func (p *StarRocksSQLParser) AlterPipeStatement() (localctx IAlterPipeStatementContext) { localctx = NewAlterPipeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 718, DorisSQLParserRULE_alterPipeStatement) + p.EnterRule(localctx, 718, StarRocksSQLParserRULE_alterPipeStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(5859) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99421,7 +99421,7 @@ func (p *DorisSQLParser) AlterPipeStatement() (localctx IAlterPipeStatementConte } { p.SetState(5860) - p.Match(DorisSQLParserPIPE) + p.Match(StarRocksSQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99474,13 +99474,13 @@ type DescPipeStatementContext struct { func NewEmptyDescPipeStatementContext() *DescPipeStatementContext { var p = new(DescPipeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_descPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_descPipeStatement return p } func InitEmptyDescPipeStatementContext(p *DescPipeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_descPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_descPipeStatement } func (*DescPipeStatementContext) IsDescPipeStatementContext() {} @@ -99491,7 +99491,7 @@ func NewDescPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_descPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_descPipeStatement return p } @@ -99499,7 +99499,7 @@ func NewDescPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *DescPipeStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DescPipeStatementContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *DescPipeStatementContext) QualifiedName() IQualifiedNameContext { @@ -99519,11 +99519,11 @@ func (s *DescPipeStatementContext) QualifiedName() IQualifiedNameContext { } func (s *DescPipeStatementContext) DESC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESC, 0) + return s.GetToken(StarRocksSQLParserDESC, 0) } func (s *DescPipeStatementContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESCRIBE, 0) + return s.GetToken(StarRocksSQLParserDESCRIBE, 0) } func (s *DescPipeStatementContext) GetRuleContext() antlr.RuleContext { @@ -99535,20 +99535,20 @@ func (s *DescPipeStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *DescPipeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDescPipeStatement(s) } } func (s *DescPipeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDescPipeStatement(s) } } func (s *DescPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDescPipeStatement(s) default: @@ -99556,9 +99556,9 @@ func (s *DescPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) DescPipeStatement() (localctx IDescPipeStatementContext) { +func (p *StarRocksSQLParser) DescPipeStatement() (localctx IDescPipeStatementContext) { localctx = NewDescPipeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 720, DorisSQLParserRULE_descPipeStatement) + p.EnterRule(localctx, 720, StarRocksSQLParserRULE_descPipeStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -99566,7 +99566,7 @@ func (p *DorisSQLParser) DescPipeStatement() (localctx IDescPipeStatementContext p.SetState(5864) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDESC || _la == DorisSQLParserDESCRIBE) { + if !(_la == StarRocksSQLParserDESC || _la == StarRocksSQLParserDESCRIBE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -99575,7 +99575,7 @@ func (p *DorisSQLParser) DescPipeStatement() (localctx IDescPipeStatementContext } { p.SetState(5865) - p.Match(DorisSQLParserPIPE) + p.Match(StarRocksSQLParserPIPE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99640,13 +99640,13 @@ type ShowPipeStatementContext struct { func NewEmptyShowPipeStatementContext() *ShowPipeStatementContext { var p = new(ShowPipeStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_showPipeStatement return p } func InitEmptyShowPipeStatementContext(p *ShowPipeStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_showPipeStatement } func (*ShowPipeStatementContext) IsShowPipeStatementContext() {} @@ -99657,7 +99657,7 @@ func NewShowPipeStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPipeStatement + p.RuleIndex = StarRocksSQLParserRULE_showPipeStatement return p } @@ -99669,19 +99669,19 @@ func (s *ShowPipeStatementContext) GetPattern() IStringContext { return s.patter func (s *ShowPipeStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowPipeStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPipeStatementContext) PIPES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPES, 0) + return s.GetToken(StarRocksSQLParserPIPES, 0) } func (s *ShowPipeStatementContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *ShowPipeStatementContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *ShowPipeStatementContext) AllSortItem() []ISortItemContext { @@ -99742,11 +99742,11 @@ func (s *ShowPipeStatementContext) LimitElement() ILimitElementContext { } func (s *ShowPipeStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowPipeStatementContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *ShowPipeStatementContext) Expression() IExpressionContext { @@ -99766,7 +99766,7 @@ func (s *ShowPipeStatementContext) Expression() IExpressionContext { } func (s *ShowPipeStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowPipeStatementContext) QualifiedName() IQualifiedNameContext { @@ -99810,20 +99810,20 @@ func (s *ShowPipeStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *ShowPipeStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPipeStatement(s) } } func (s *ShowPipeStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPipeStatement(s) } } func (s *ShowPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPipeStatement(s) default: @@ -99831,15 +99831,15 @@ func (s *ShowPipeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext) { +func (p *StarRocksSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext) { localctx = NewShowPipeStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 722, DorisSQLParserRULE_showPipeStatement) + p.EnterRule(localctx, 722, StarRocksSQLParserRULE_showPipeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5868) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99847,7 +99847,7 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext } { p.SetState(5869) - p.Match(DorisSQLParserPIPES) + p.Match(StarRocksSQLParserPIPES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99859,10 +99859,10 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: { p.SetState(5870) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99876,10 +99876,10 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext localctx.(*ShowPipeStatementContext).pattern = _x } - case DorisSQLParserWHERE: + case StarRocksSQLParserWHERE: { p.SetState(5872) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99890,10 +99890,10 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext p.expression(0) } - case DorisSQLParserFROM: + case StarRocksSQLParserFROM: { p.SetState(5874) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99904,7 +99904,7 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext p.QualifiedName() } - case DorisSQLParserEOF, DorisSQLParserLIMIT, DorisSQLParserORDER, DorisSQLParserSEMICOLON: + case StarRocksSQLParserEOF, StarRocksSQLParserLIMIT, StarRocksSQLParserORDER, StarRocksSQLParserSEMICOLON: default: } @@ -99915,10 +99915,10 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(5878) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99926,7 +99926,7 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext } { p.SetState(5879) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99943,10 +99943,10 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5881) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -99973,7 +99973,7 @@ func (p *DorisSQLParser) ShowPipeStatement() (localctx IShowPipeStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(5890) p.LimitElement() @@ -100018,13 +100018,13 @@ type SetStatementContext struct { func NewEmptySetStatementContext() *SetStatementContext { var p = new(SetStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setStatement + p.RuleIndex = StarRocksSQLParserRULE_setStatement return p } func InitEmptySetStatementContext(p *SetStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setStatement + p.RuleIndex = StarRocksSQLParserRULE_setStatement } func (*SetStatementContext) IsSetStatementContext() {} @@ -100035,7 +100035,7 @@ func NewSetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setStatement + p.RuleIndex = StarRocksSQLParserRULE_setStatement return p } @@ -100043,7 +100043,7 @@ func NewSetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *SetStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetStatementContext) AllSetVar() []ISetVarContext { @@ -100096,20 +100096,20 @@ func (s *SetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *SetStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetStatement(s) } } func (s *SetStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetStatement(s) } } func (s *SetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetStatement(s) default: @@ -100117,15 +100117,15 @@ func (s *SetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) SetStatement() (localctx ISetStatementContext) { +func (p *StarRocksSQLParser) SetStatement() (localctx ISetStatementContext) { localctx = NewSetStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 724, DorisSQLParserRULE_setStatement) + p.EnterRule(localctx, 724, StarRocksSQLParserRULE_setStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(5893) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100142,10 +100142,10 @@ func (p *DorisSQLParser) SetStatement() (localctx ISetStatementContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(5895) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100195,13 +100195,13 @@ type SetVarContext struct { func NewEmptySetVarContext() *SetVarContext { var p = new(SetVarContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setVar + p.RuleIndex = StarRocksSQLParserRULE_setVar return p } func InitEmptySetVarContext(p *SetVarContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setVar + p.RuleIndex = StarRocksSQLParserRULE_setVar } func (*SetVarContext) IsSetVarContext() {} @@ -100212,7 +100212,7 @@ func NewSetVarContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setVar + p.RuleIndex = StarRocksSQLParserRULE_setVar return p } @@ -100250,7 +100250,7 @@ func (s *SetTransactionContext) GetRuleContext() antlr.RuleContext { } func (s *SetTransactionContext) TRANSACTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSACTION, 0) + return s.GetToken(StarRocksSQLParserTRANSACTION, 0) } func (s *SetTransactionContext) Transaction_characteristics() ITransaction_characteristicsContext { @@ -100286,20 +100286,20 @@ func (s *SetTransactionContext) VarType() IVarTypeContext { } func (s *SetTransactionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetTransaction(s) } } func (s *SetTransactionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetTransaction(s) } } func (s *SetTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetTransaction(s) default: @@ -100336,19 +100336,19 @@ func (s *SetNamesContext) GetRuleContext() antlr.RuleContext { } func (s *SetNamesContext) CHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAR, 0) + return s.GetToken(StarRocksSQLParserCHAR, 0) } func (s *SetNamesContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetNamesContext) CHARSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARSET, 0) + return s.GetToken(StarRocksSQLParserCHARSET, 0) } func (s *SetNamesContext) CHARACTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARACTER, 0) + return s.GetToken(StarRocksSQLParserCHARACTER, 0) } func (s *SetNamesContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -100393,36 +100393,36 @@ func (s *SetNamesContext) IdentifierOrString(i int) IIdentifierOrStringContext { } func (s *SetNamesContext) AllDEFAULT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserDEFAULT) + return s.GetTokens(StarRocksSQLParserDEFAULT) } func (s *SetNamesContext) DEFAULT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, i) + return s.GetToken(StarRocksSQLParserDEFAULT, i) } func (s *SetNamesContext) NAMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNAMES, 0) + return s.GetToken(StarRocksSQLParserNAMES, 0) } func (s *SetNamesContext) COLLATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLLATE, 0) + return s.GetToken(StarRocksSQLParserCOLLATE, 0) } func (s *SetNamesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetNames(s) } } func (s *SetNamesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetNames(s) } } func (s *SetNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetNames(s) default: @@ -100449,15 +100449,15 @@ func (s *SetPasswordContext) GetRuleContext() antlr.RuleContext { } func (s *SetPasswordContext) AllPASSWORD() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserPASSWORD) + return s.GetTokens(StarRocksSQLParserPASSWORD) } func (s *SetPasswordContext) PASSWORD(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserPASSWORD, i) + return s.GetToken(StarRocksSQLParserPASSWORD, i) } func (s *SetPasswordContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *SetPasswordContext) String_() IStringContext { @@ -100477,7 +100477,7 @@ func (s *SetPasswordContext) String_() IStringContext { } func (s *SetPasswordContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *SetPasswordContext) User() IUserContext { @@ -100497,20 +100497,20 @@ func (s *SetPasswordContext) User() IUserContext { } func (s *SetPasswordContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetPassword(s) } } func (s *SetPasswordContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetPassword(s) } } func (s *SetPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetPassword(s) default: @@ -100553,7 +100553,7 @@ func (s *SetUserVarContext) UserVariable() IUserVariableContext { } func (s *SetUserVarContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *SetUserVarContext) Expression() IExpressionContext { @@ -100573,20 +100573,20 @@ func (s *SetUserVarContext) Expression() IExpressionContext { } func (s *SetUserVarContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetUserVar(s) } } func (s *SetUserVarContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetUserVar(s) } } func (s *SetUserVarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetUserVar(s) default: @@ -100629,7 +100629,7 @@ func (s *SetSystemVarContext) Identifier() IIdentifierContext { } func (s *SetSystemVarContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *SetSystemVarContext) SetExprOrDefault() ISetExprOrDefaultContext { @@ -100681,20 +100681,20 @@ func (s *SetSystemVarContext) SystemVariable() ISystemVariableContext { } func (s *SetSystemVarContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetSystemVar(s) } } func (s *SetSystemVarContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetSystemVar(s) } } func (s *SetSystemVarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetSystemVar(s) default: @@ -100702,9 +100702,9 @@ func (s *SetSystemVarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { +func (p *StarRocksSQLParser) SetVar() (localctx ISetVarContext) { localctx = NewSetVarContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 726, DorisSQLParserRULE_setVar) + p.EnterRule(localctx, 726, StarRocksSQLParserRULE_setVar) var _la int p.SetState(5967) @@ -100724,10 +100724,10 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCHAR: + case StarRocksSQLParserCHAR: { p.SetState(5902) - p.Match(DorisSQLParserCHAR) + p.Match(StarRocksSQLParserCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100735,27 +100735,27 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5903) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCHARSET: + case StarRocksSQLParserCHARSET: { p.SetState(5904) - p.Match(DorisSQLParserCHARSET) + p.Match(StarRocksSQLParserCHARSET) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCHARACTER: + case StarRocksSQLParserCHARACTER: { p.SetState(5905) - p.Match(DorisSQLParserCHARACTER) + p.Match(StarRocksSQLParserCHARACTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100763,7 +100763,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5906) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100781,16 +100781,16 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(5909) p.IdentifierOrString() } - case DorisSQLParserDEFAULT: + case StarRocksSQLParserDEFAULT: { p.SetState(5910) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100807,7 +100807,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(5913) - p.Match(DorisSQLParserNAMES) + p.Match(StarRocksSQLParserNAMES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100820,7 +100820,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(5914) @@ -100829,10 +100829,10 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { localctx.(*SetNamesContext).charset = _x } - case DorisSQLParserDEFAULT: + case StarRocksSQLParserDEFAULT: { p.SetState(5915) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100850,10 +100850,10 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOLLATE { + if _la == StarRocksSQLParserCOLLATE { { p.SetState(5918) - p.Match(DorisSQLParserCOLLATE) + p.Match(StarRocksSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100866,7 +100866,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(5919) @@ -100875,10 +100875,10 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { localctx.(*SetNamesContext).collate = _x } - case DorisSQLParserDEFAULT: + case StarRocksSQLParserDEFAULT: { p.SetState(5920) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100897,7 +100897,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(5925) - p.Match(DorisSQLParserPASSWORD) + p.Match(StarRocksSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100905,7 +100905,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5926) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100918,16 +100918,16 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(5927) p.String_() } - case DorisSQLParserPASSWORD: + case StarRocksSQLParserPASSWORD: { p.SetState(5928) - p.Match(DorisSQLParserPASSWORD) + p.Match(StarRocksSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100935,7 +100935,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5929) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100947,7 +100947,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5931) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100964,7 +100964,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(5935) - p.Match(DorisSQLParserPASSWORD) + p.Match(StarRocksSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100972,7 +100972,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5936) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100984,7 +100984,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5938) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -100997,16 +100997,16 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(5939) p.String_() } - case DorisSQLParserPASSWORD: + case StarRocksSQLParserPASSWORD: { p.SetState(5940) - p.Match(DorisSQLParserPASSWORD) + p.Match(StarRocksSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101014,7 +101014,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5941) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101026,7 +101026,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5943) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101047,7 +101047,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5948) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101079,7 +101079,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5955) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101099,7 +101099,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5959) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101120,7 +101120,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserGLOBAL || _la == DorisSQLParserLOCAL || _la == DorisSQLParserSESSION || _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserGLOBAL || _la == StarRocksSQLParserLOCAL || _la == StarRocksSQLParserSESSION || _la == StarRocksSQLParserVERBOSE { { p.SetState(5962) p.VarType() @@ -101129,7 +101129,7 @@ func (p *DorisSQLParser) SetVar() (localctx ISetVarContext) { } { p.SetState(5965) - p.Match(DorisSQLParserTRANSACTION) + p.Match(StarRocksSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101180,13 +101180,13 @@ type Transaction_characteristicsContext struct { func NewEmptyTransaction_characteristicsContext() *Transaction_characteristicsContext { var p = new(Transaction_characteristicsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_transaction_characteristics + p.RuleIndex = StarRocksSQLParserRULE_transaction_characteristics return p } func InitEmptyTransaction_characteristicsContext(p *Transaction_characteristicsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_transaction_characteristics + p.RuleIndex = StarRocksSQLParserRULE_transaction_characteristics } func (*Transaction_characteristicsContext) IsTransaction_characteristicsContext() {} @@ -101197,7 +101197,7 @@ func NewTransaction_characteristicsContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_transaction_characteristics + p.RuleIndex = StarRocksSQLParserRULE_transaction_characteristics return p } @@ -101245,20 +101245,20 @@ func (s *Transaction_characteristicsContext) ToStringTree(ruleNames []string, re } func (s *Transaction_characteristicsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTransaction_characteristics(s) } } func (s *Transaction_characteristicsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTransaction_characteristics(s) } } func (s *Transaction_characteristicsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTransaction_characteristics(s) default: @@ -101266,9 +101266,9 @@ func (s *Transaction_characteristicsContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) Transaction_characteristics() (localctx ITransaction_characteristicsContext) { +func (p *StarRocksSQLParser) Transaction_characteristics() (localctx ITransaction_characteristicsContext) { localctx = NewTransaction_characteristicsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 728, DorisSQLParserRULE_transaction_characteristics) + p.EnterRule(localctx, 728, StarRocksSQLParserRULE_transaction_characteristics) p.SetState(5979) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -101298,7 +101298,7 @@ func (p *DorisSQLParser) Transaction_characteristics() (localctx ITransaction_ch } { p.SetState(5972) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101317,7 +101317,7 @@ func (p *DorisSQLParser) Transaction_characteristics() (localctx ITransaction_ch } { p.SetState(5976) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101369,13 +101369,13 @@ type Transaction_access_modeContext struct { func NewEmptyTransaction_access_modeContext() *Transaction_access_modeContext { var p = new(Transaction_access_modeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_transaction_access_mode + p.RuleIndex = StarRocksSQLParserRULE_transaction_access_mode return p } func InitEmptyTransaction_access_modeContext(p *Transaction_access_modeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_transaction_access_mode + p.RuleIndex = StarRocksSQLParserRULE_transaction_access_mode } func (*Transaction_access_modeContext) IsTransaction_access_modeContext() {} @@ -101386,7 +101386,7 @@ func NewTransaction_access_modeContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_transaction_access_mode + p.RuleIndex = StarRocksSQLParserRULE_transaction_access_mode return p } @@ -101394,15 +101394,15 @@ func NewTransaction_access_modeContext(parser antlr.Parser, parent antlr.ParserR func (s *Transaction_access_modeContext) GetParser() antlr.Parser { return s.parser } func (s *Transaction_access_modeContext) READ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREAD, 0) + return s.GetToken(StarRocksSQLParserREAD, 0) } func (s *Transaction_access_modeContext) ONLY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserONLY, 0) + return s.GetToken(StarRocksSQLParserONLY, 0) } func (s *Transaction_access_modeContext) WRITE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWRITE, 0) + return s.GetToken(StarRocksSQLParserWRITE, 0) } func (s *Transaction_access_modeContext) GetRuleContext() antlr.RuleContext { @@ -101414,20 +101414,20 @@ func (s *Transaction_access_modeContext) ToStringTree(ruleNames []string, recog } func (s *Transaction_access_modeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTransaction_access_mode(s) } } func (s *Transaction_access_modeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTransaction_access_mode(s) } } func (s *Transaction_access_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTransaction_access_mode(s) default: @@ -101435,9 +101435,9 @@ func (s *Transaction_access_modeContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) Transaction_access_mode() (localctx ITransaction_access_modeContext) { +func (p *StarRocksSQLParser) Transaction_access_mode() (localctx ITransaction_access_modeContext) { localctx = NewTransaction_access_modeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 730, DorisSQLParserRULE_transaction_access_mode) + p.EnterRule(localctx, 730, StarRocksSQLParserRULE_transaction_access_mode) p.SetState(5985) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -101449,7 +101449,7 @@ func (p *DorisSQLParser) Transaction_access_mode() (localctx ITransaction_access p.EnterOuterAlt(localctx, 1) { p.SetState(5981) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101457,7 +101457,7 @@ func (p *DorisSQLParser) Transaction_access_mode() (localctx ITransaction_access } { p.SetState(5982) - p.Match(DorisSQLParserONLY) + p.Match(StarRocksSQLParserONLY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101468,7 +101468,7 @@ func (p *DorisSQLParser) Transaction_access_mode() (localctx ITransaction_access p.EnterOuterAlt(localctx, 2) { p.SetState(5983) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101476,7 +101476,7 @@ func (p *DorisSQLParser) Transaction_access_mode() (localctx ITransaction_access } { p.SetState(5984) - p.Match(DorisSQLParserWRITE) + p.Match(StarRocksSQLParserWRITE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101524,13 +101524,13 @@ type Isolation_levelContext struct { func NewEmptyIsolation_levelContext() *Isolation_levelContext { var p = new(Isolation_levelContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_isolation_level + p.RuleIndex = StarRocksSQLParserRULE_isolation_level return p } func InitEmptyIsolation_levelContext(p *Isolation_levelContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_isolation_level + p.RuleIndex = StarRocksSQLParserRULE_isolation_level } func (*Isolation_levelContext) IsIsolation_levelContext() {} @@ -101541,7 +101541,7 @@ func NewIsolation_levelContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_isolation_level + p.RuleIndex = StarRocksSQLParserRULE_isolation_level return p } @@ -101549,11 +101549,11 @@ func NewIsolation_levelContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Isolation_levelContext) GetParser() antlr.Parser { return s.parser } func (s *Isolation_levelContext) ISOLATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserISOLATION, 0) + return s.GetToken(StarRocksSQLParserISOLATION, 0) } func (s *Isolation_levelContext) LEVEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLEVEL, 0) + return s.GetToken(StarRocksSQLParserLEVEL, 0) } func (s *Isolation_levelContext) Isolation_types() IIsolation_typesContext { @@ -101581,20 +101581,20 @@ func (s *Isolation_levelContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *Isolation_levelContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIsolation_level(s) } } func (s *Isolation_levelContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIsolation_level(s) } } func (s *Isolation_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIsolation_level(s) default: @@ -101602,13 +101602,13 @@ func (s *Isolation_levelContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) Isolation_level() (localctx IIsolation_levelContext) { +func (p *StarRocksSQLParser) Isolation_level() (localctx IIsolation_levelContext) { localctx = NewIsolation_levelContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 732, DorisSQLParserRULE_isolation_level) + p.EnterRule(localctx, 732, StarRocksSQLParserRULE_isolation_level) p.EnterOuterAlt(localctx, 1) { p.SetState(5987) - p.Match(DorisSQLParserISOLATION) + p.Match(StarRocksSQLParserISOLATION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101616,7 +101616,7 @@ func (p *DorisSQLParser) Isolation_level() (localctx IIsolation_levelContext) { } { p.SetState(5988) - p.Match(DorisSQLParserLEVEL) + p.Match(StarRocksSQLParserLEVEL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101666,13 +101666,13 @@ type Isolation_typesContext struct { func NewEmptyIsolation_typesContext() *Isolation_typesContext { var p = new(Isolation_typesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_isolation_types + p.RuleIndex = StarRocksSQLParserRULE_isolation_types return p } func InitEmptyIsolation_typesContext(p *Isolation_typesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_isolation_types + p.RuleIndex = StarRocksSQLParserRULE_isolation_types } func (*Isolation_typesContext) IsIsolation_typesContext() {} @@ -101683,7 +101683,7 @@ func NewIsolation_typesContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_isolation_types + p.RuleIndex = StarRocksSQLParserRULE_isolation_types return p } @@ -101691,23 +101691,23 @@ func NewIsolation_typesContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *Isolation_typesContext) GetParser() antlr.Parser { return s.parser } func (s *Isolation_typesContext) READ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREAD, 0) + return s.GetToken(StarRocksSQLParserREAD, 0) } func (s *Isolation_typesContext) UNCOMMITTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNCOMMITTED, 0) + return s.GetToken(StarRocksSQLParserUNCOMMITTED, 0) } func (s *Isolation_typesContext) COMMITTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMITTED, 0) + return s.GetToken(StarRocksSQLParserCOMMITTED, 0) } func (s *Isolation_typesContext) REPEATABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPEATABLE, 0) + return s.GetToken(StarRocksSQLParserREPEATABLE, 0) } func (s *Isolation_typesContext) SERIALIZABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSERIALIZABLE, 0) + return s.GetToken(StarRocksSQLParserSERIALIZABLE, 0) } func (s *Isolation_typesContext) GetRuleContext() antlr.RuleContext { @@ -101719,20 +101719,20 @@ func (s *Isolation_typesContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *Isolation_typesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIsolation_types(s) } } func (s *Isolation_typesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIsolation_types(s) } } func (s *Isolation_typesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIsolation_types(s) default: @@ -101740,9 +101740,9 @@ func (s *Isolation_typesContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { +func (p *StarRocksSQLParser) Isolation_types() (localctx IIsolation_typesContext) { localctx = NewIsolation_typesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 734, DorisSQLParserRULE_isolation_types) + p.EnterRule(localctx, 734, StarRocksSQLParserRULE_isolation_types) p.SetState(5998) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -101754,7 +101754,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(5991) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101762,7 +101762,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { } { p.SetState(5992) - p.Match(DorisSQLParserUNCOMMITTED) + p.Match(StarRocksSQLParserUNCOMMITTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101773,7 +101773,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(5993) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101781,7 +101781,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { } { p.SetState(5994) - p.Match(DorisSQLParserCOMMITTED) + p.Match(StarRocksSQLParserCOMMITTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101792,7 +101792,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(5995) - p.Match(DorisSQLParserREPEATABLE) + p.Match(StarRocksSQLParserREPEATABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101800,7 +101800,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { } { p.SetState(5996) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101811,7 +101811,7 @@ func (p *DorisSQLParser) Isolation_types() (localctx IIsolation_typesContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(5997) - p.Match(DorisSQLParserSERIALIZABLE) + p.Match(StarRocksSQLParserSERIALIZABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -101860,13 +101860,13 @@ type SetExprOrDefaultContext struct { func NewEmptySetExprOrDefaultContext() *SetExprOrDefaultContext { var p = new(SetExprOrDefaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setExprOrDefault + p.RuleIndex = StarRocksSQLParserRULE_setExprOrDefault return p } func InitEmptySetExprOrDefaultContext(p *SetExprOrDefaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setExprOrDefault + p.RuleIndex = StarRocksSQLParserRULE_setExprOrDefault } func (*SetExprOrDefaultContext) IsSetExprOrDefaultContext() {} @@ -101877,7 +101877,7 @@ func NewSetExprOrDefaultContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setExprOrDefault + p.RuleIndex = StarRocksSQLParserRULE_setExprOrDefault return p } @@ -101885,15 +101885,15 @@ func NewSetExprOrDefaultContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *SetExprOrDefaultContext) GetParser() antlr.Parser { return s.parser } func (s *SetExprOrDefaultContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *SetExprOrDefaultContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *SetExprOrDefaultContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *SetExprOrDefaultContext) Expression() IExpressionContext { @@ -101921,20 +101921,20 @@ func (s *SetExprOrDefaultContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *SetExprOrDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetExprOrDefault(s) } } func (s *SetExprOrDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetExprOrDefault(s) } } func (s *SetExprOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetExprOrDefault(s) default: @@ -101942,9 +101942,9 @@ func (s *SetExprOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) SetExprOrDefault() (localctx ISetExprOrDefaultContext) { +func (p *StarRocksSQLParser) SetExprOrDefault() (localctx ISetExprOrDefaultContext) { localctx = NewSetExprOrDefaultContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 736, DorisSQLParserRULE_setExprOrDefault) + p.EnterRule(localctx, 736, StarRocksSQLParserRULE_setExprOrDefault) p.SetState(6004) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -101952,40 +101952,40 @@ func (p *DorisSQLParser) SetExprOrDefault() (localctx ISetExprOrDefaultContext) } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDEFAULT: + case StarRocksSQLParserDEFAULT: p.EnterOuterAlt(localctx, 1) { p.SetState(6000) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserON: + case StarRocksSQLParserON: p.EnterOuterAlt(localctx, 2) { p.SetState(6001) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserALL: + case StarRocksSQLParserALL: p.EnterOuterAlt(localctx, 3) { p.SetState(6002) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserT__1, DorisSQLParserT__5, DorisSQLParserT__8, DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCASE, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHAR, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCONVERT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserCURRENT_DATE, DorisSQLParserCURRENT_GROUP, DorisSQLParserCURRENT_ROLE, DorisSQLParserCURRENT_TIME, DorisSQLParserCURRENT_TIMESTAMP, DorisSQLParserCURRENT_USER, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATABASE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDENSE_RANK, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserNTILE, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXISTS, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFALSE, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFIRST_VALUE, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUPING, DorisSQLParserGROUPING_ID, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIF, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAG, DorisSQLParserLAST, DorisSQLParserLAST_VALUE, DorisSQLParserLEAD, DorisSQLParserLEFT, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIKE, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCALTIME, DorisSQLParserLOCALTIMESTAMP, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMOD, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNOT, DorisSQLParserNULL, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARAMETER, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREGEXP, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserRIGHT, DorisSQLParserRLIKE, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserROW_NUMBER, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSCHEMA, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserPLUS_SYMBOL, DorisSQLParserMINUS_SYMBOL, DorisSQLParserLOGICAL_NOT, DorisSQLParserBITNOT, DorisSQLParserAT, DorisSQLParserINTEGER_VALUE, DorisSQLParserDECIMAL_VALUE, DorisSQLParserDOUBLE_VALUE, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserBINARY_SINGLE_QUOTED_TEXT, DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserT__1, StarRocksSQLParserT__5, StarRocksSQLParserT__8, StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCASE, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHAR, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCONVERT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserCURRENT_DATE, StarRocksSQLParserCURRENT_GROUP, StarRocksSQLParserCURRENT_ROLE, StarRocksSQLParserCURRENT_TIME, StarRocksSQLParserCURRENT_TIMESTAMP, StarRocksSQLParserCURRENT_USER, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATABASE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDENSE_RANK, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserNTILE, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXISTS, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFALSE, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFIRST_VALUE, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUPING, StarRocksSQLParserGROUPING_ID, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIF, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAG, StarRocksSQLParserLAST, StarRocksSQLParserLAST_VALUE, StarRocksSQLParserLEAD, StarRocksSQLParserLEFT, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIKE, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCALTIME, StarRocksSQLParserLOCALTIMESTAMP, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMOD, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNOT, StarRocksSQLParserNULL, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARAMETER, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREGEXP, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserRIGHT, StarRocksSQLParserRLIKE, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserROW_NUMBER, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSCHEMA, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserPLUS_SYMBOL, StarRocksSQLParserMINUS_SYMBOL, StarRocksSQLParserLOGICAL_NOT, StarRocksSQLParserBITNOT, StarRocksSQLParserAT, StarRocksSQLParserINTEGER_VALUE, StarRocksSQLParserDECIMAL_VALUE, StarRocksSQLParserDOUBLE_VALUE, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT, StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: p.EnterOuterAlt(localctx, 4) { p.SetState(6003) @@ -102036,13 +102036,13 @@ type SetUserPropertyStatementContext struct { func NewEmptySetUserPropertyStatementContext() *SetUserPropertyStatementContext { var p = new(SetUserPropertyStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setUserPropertyStatement + p.RuleIndex = StarRocksSQLParserRULE_setUserPropertyStatement return p } func InitEmptySetUserPropertyStatementContext(p *SetUserPropertyStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setUserPropertyStatement + p.RuleIndex = StarRocksSQLParserRULE_setUserPropertyStatement } func (*SetUserPropertyStatementContext) IsSetUserPropertyStatementContext() {} @@ -102053,7 +102053,7 @@ func NewSetUserPropertyStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setUserPropertyStatement + p.RuleIndex = StarRocksSQLParserRULE_setUserPropertyStatement return p } @@ -102061,11 +102061,11 @@ func NewSetUserPropertyStatementContext(parser antlr.Parser, parent antlr.Parser func (s *SetUserPropertyStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetUserPropertyStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetUserPropertyStatementContext) PROPERTY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTY, 0) + return s.GetToken(StarRocksSQLParserPROPERTY, 0) } func (s *SetUserPropertyStatementContext) UserPropertyList() IUserPropertyListContext { @@ -102085,7 +102085,7 @@ func (s *SetUserPropertyStatementContext) UserPropertyList() IUserPropertyListCo } func (s *SetUserPropertyStatementContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *SetUserPropertyStatementContext) String_() IStringContext { @@ -102113,20 +102113,20 @@ func (s *SetUserPropertyStatementContext) ToStringTree(ruleNames []string, recog } func (s *SetUserPropertyStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetUserPropertyStatement(s) } } func (s *SetUserPropertyStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetUserPropertyStatement(s) } } func (s *SetUserPropertyStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetUserPropertyStatement(s) default: @@ -102134,15 +102134,15 @@ func (s *SetUserPropertyStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) SetUserPropertyStatement() (localctx ISetUserPropertyStatementContext) { +func (p *StarRocksSQLParser) SetUserPropertyStatement() (localctx ISetUserPropertyStatementContext) { localctx = NewSetUserPropertyStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 738, DorisSQLParserRULE_setUserPropertyStatement) + p.EnterRule(localctx, 738, StarRocksSQLParserRULE_setUserPropertyStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6006) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102150,7 +102150,7 @@ func (p *DorisSQLParser) SetUserPropertyStatement() (localctx ISetUserPropertySt } { p.SetState(6007) - p.Match(DorisSQLParserPROPERTY) + p.Match(StarRocksSQLParserPROPERTY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102163,10 +102163,10 @@ func (p *DorisSQLParser) SetUserPropertyStatement() (localctx ISetUserPropertySt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(6008) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102219,13 +102219,13 @@ type RoleListContext struct { func NewEmptyRoleListContext() *RoleListContext { var p = new(RoleListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_roleList + p.RuleIndex = StarRocksSQLParserRULE_roleList return p } func InitEmptyRoleListContext(p *RoleListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_roleList + p.RuleIndex = StarRocksSQLParserRULE_roleList } func (*RoleListContext) IsRoleListContext() {} @@ -102236,7 +102236,7 @@ func NewRoleListContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_roleList + p.RuleIndex = StarRocksSQLParserRULE_roleList return p } @@ -102293,20 +102293,20 @@ func (s *RoleListContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *RoleListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRoleList(s) } } func (s *RoleListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRoleList(s) } } func (s *RoleListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRoleList(s) default: @@ -102314,9 +102314,9 @@ func (s *RoleListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) RoleList() (localctx IRoleListContext) { +func (p *StarRocksSQLParser) RoleList() (localctx IRoleListContext) { localctx = NewRoleListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 740, DorisSQLParserRULE_roleList) + p.EnterRule(localctx, 740, StarRocksSQLParserRULE_roleList) var _la int p.EnterOuterAlt(localctx, 1) @@ -102331,10 +102331,10 @@ func (p *DorisSQLParser) RoleList() (localctx IRoleListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6015) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102393,13 +102393,13 @@ type ExecuteScriptStatementContext struct { func NewEmptyExecuteScriptStatementContext() *ExecuteScriptStatementContext { var p = new(ExecuteScriptStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_executeScriptStatement + p.RuleIndex = StarRocksSQLParserRULE_executeScriptStatement return p } func InitEmptyExecuteScriptStatementContext(p *ExecuteScriptStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_executeScriptStatement + p.RuleIndex = StarRocksSQLParserRULE_executeScriptStatement } func (*ExecuteScriptStatementContext) IsExecuteScriptStatementContext() {} @@ -102410,7 +102410,7 @@ func NewExecuteScriptStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_executeScriptStatement + p.RuleIndex = StarRocksSQLParserRULE_executeScriptStatement return p } @@ -102418,15 +102418,15 @@ func NewExecuteScriptStatementContext(parser antlr.Parser, parent antlr.ParserRu func (s *ExecuteScriptStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ExecuteScriptStatementContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *ExecuteScriptStatementContext) EXECUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXECUTE, 0) + return s.GetToken(StarRocksSQLParserEXECUTE, 0) } func (s *ExecuteScriptStatementContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *ExecuteScriptStatementContext) String_() IStringContext { @@ -102446,11 +102446,11 @@ func (s *ExecuteScriptStatementContext) String_() IStringContext { } func (s *ExecuteScriptStatementContext) FRONTEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTEND, 0) + return s.GetToken(StarRocksSQLParserFRONTEND, 0) } func (s *ExecuteScriptStatementContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *ExecuteScriptStatementContext) GetRuleContext() antlr.RuleContext { @@ -102462,20 +102462,20 @@ func (s *ExecuteScriptStatementContext) ToStringTree(ruleNames []string, recog a } func (s *ExecuteScriptStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExecuteScriptStatement(s) } } func (s *ExecuteScriptStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExecuteScriptStatement(s) } } func (s *ExecuteScriptStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExecuteScriptStatement(s) default: @@ -102483,15 +102483,15 @@ func (s *ExecuteScriptStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatementContext) { +func (p *StarRocksSQLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatementContext) { localctx = NewExecuteScriptStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 742, DorisSQLParserRULE_executeScriptStatement) + p.EnterRule(localctx, 742, StarRocksSQLParserRULE_executeScriptStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6022) - p.Match(DorisSQLParserADMIN) + p.Match(StarRocksSQLParserADMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102499,7 +102499,7 @@ func (p *DorisSQLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatem } { p.SetState(6023) - p.Match(DorisSQLParserEXECUTE) + p.Match(StarRocksSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102507,7 +102507,7 @@ func (p *DorisSQLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatem } { p.SetState(6024) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102517,7 +102517,7 @@ func (p *DorisSQLParser) ExecuteScriptStatement() (localctx IExecuteScriptStatem p.SetState(6025) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFRONTEND || _la == DorisSQLParserINTEGER_VALUE) { + if !(_la == StarRocksSQLParserFRONTEND || _la == StarRocksSQLParserINTEGER_VALUE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -102568,13 +102568,13 @@ type UnsupportedStatementContext struct { func NewEmptyUnsupportedStatementContext() *UnsupportedStatementContext { var p = new(UnsupportedStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_unsupportedStatement + p.RuleIndex = StarRocksSQLParserRULE_unsupportedStatement return p } func InitEmptyUnsupportedStatementContext(p *UnsupportedStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_unsupportedStatement + p.RuleIndex = StarRocksSQLParserRULE_unsupportedStatement } func (*UnsupportedStatementContext) IsUnsupportedStatementContext() {} @@ -102585,7 +102585,7 @@ func NewUnsupportedStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_unsupportedStatement + p.RuleIndex = StarRocksSQLParserRULE_unsupportedStatement return p } @@ -102593,11 +102593,11 @@ func NewUnsupportedStatementContext(parser antlr.Parser, parent antlr.ParserRule func (s *UnsupportedStatementContext) GetParser() antlr.Parser { return s.parser } func (s *UnsupportedStatementContext) LOCK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCK, 0) + return s.GetToken(StarRocksSQLParserLOCK, 0) } func (s *UnsupportedStatementContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *UnsupportedStatementContext) AllLock_item() []ILock_itemContext { @@ -102642,7 +102642,7 @@ func (s *UnsupportedStatementContext) Lock_item(i int) ILock_itemContext { } func (s *UnsupportedStatementContext) UNLOCK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNLOCK, 0) + return s.GetToken(StarRocksSQLParserUNLOCK, 0) } func (s *UnsupportedStatementContext) GetRuleContext() antlr.RuleContext { @@ -102654,20 +102654,20 @@ func (s *UnsupportedStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *UnsupportedStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUnsupportedStatement(s) } } func (s *UnsupportedStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUnsupportedStatement(s) } } func (s *UnsupportedStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUnsupportedStatement(s) default: @@ -102675,9 +102675,9 @@ func (s *UnsupportedStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementContext) { +func (p *StarRocksSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementContext) { localctx = NewUnsupportedStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 744, DorisSQLParserRULE_unsupportedStatement) + p.EnterRule(localctx, 744, StarRocksSQLParserRULE_unsupportedStatement) var _la int p.SetState(6040) @@ -102687,11 +102687,11 @@ func (p *DorisSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLOCK: + case StarRocksSQLParserLOCK: p.EnterOuterAlt(localctx, 1) { p.SetState(6028) - p.Match(DorisSQLParserLOCK) + p.Match(StarRocksSQLParserLOCK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102699,7 +102699,7 @@ func (p *DorisSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementC } { p.SetState(6029) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102716,10 +102716,10 @@ func (p *DorisSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementC } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6031) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102738,11 +102738,11 @@ func (p *DorisSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementC _la = p.GetTokenStream().LA(1) } - case DorisSQLParserUNLOCK: + case StarRocksSQLParserUNLOCK: p.EnterOuterAlt(localctx, 2) { p.SetState(6038) - p.Match(DorisSQLParserUNLOCK) + p.Match(StarRocksSQLParserUNLOCK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102750,7 +102750,7 @@ func (p *DorisSQLParser) UnsupportedStatement() (localctx IUnsupportedStatementC } { p.SetState(6039) - p.Match(DorisSQLParserTABLES) + p.Match(StarRocksSQLParserTABLES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -102807,13 +102807,13 @@ type Lock_itemContext struct { func NewEmptyLock_itemContext() *Lock_itemContext { var p = new(Lock_itemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_lock_item + p.RuleIndex = StarRocksSQLParserRULE_lock_item return p } func InitEmptyLock_itemContext(p *Lock_itemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_lock_item + p.RuleIndex = StarRocksSQLParserRULE_lock_item } func (*Lock_itemContext) IsLock_itemContext() {} @@ -102824,7 +102824,7 @@ func NewLock_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_lock_item + p.RuleIndex = StarRocksSQLParserRULE_lock_item return p } @@ -102893,7 +102893,7 @@ func (s *Lock_itemContext) Lock_type() ILock_typeContext { } func (s *Lock_itemContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *Lock_itemContext) GetRuleContext() antlr.RuleContext { @@ -102905,20 +102905,20 @@ func (s *Lock_itemContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *Lock_itemContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLock_item(s) } } func (s *Lock_itemContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLock_item(s) } } func (s *Lock_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLock_item(s) default: @@ -102926,9 +102926,9 @@ func (s *Lock_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Lock_item() (localctx ILock_itemContext) { +func (p *StarRocksSQLParser) Lock_item() (localctx ILock_itemContext) { localctx = NewLock_itemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 746, DorisSQLParserRULE_lock_item) + p.EnterRule(localctx, 746, StarRocksSQLParserRULE_lock_item) var _la int p.EnterOuterAlt(localctx, 1) @@ -102947,10 +102947,10 @@ func (p *DorisSQLParser) Lock_item() (localctx ILock_itemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6043) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103012,13 +103012,13 @@ type Lock_typeContext struct { func NewEmptyLock_typeContext() *Lock_typeContext { var p = new(Lock_typeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_lock_type + p.RuleIndex = StarRocksSQLParserRULE_lock_type return p } func InitEmptyLock_typeContext(p *Lock_typeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_lock_type + p.RuleIndex = StarRocksSQLParserRULE_lock_type } func (*Lock_typeContext) IsLock_typeContext() {} @@ -103029,7 +103029,7 @@ func NewLock_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_lock_type + p.RuleIndex = StarRocksSQLParserRULE_lock_type return p } @@ -103037,19 +103037,19 @@ func NewLock_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *Lock_typeContext) GetParser() antlr.Parser { return s.parser } func (s *Lock_typeContext) READ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREAD, 0) + return s.GetToken(StarRocksSQLParserREAD, 0) } func (s *Lock_typeContext) LOCAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCAL, 0) + return s.GetToken(StarRocksSQLParserLOCAL, 0) } func (s *Lock_typeContext) WRITE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWRITE, 0) + return s.GetToken(StarRocksSQLParserWRITE, 0) } func (s *Lock_typeContext) LOW_PRIORITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOW_PRIORITY, 0) + return s.GetToken(StarRocksSQLParserLOW_PRIORITY, 0) } func (s *Lock_typeContext) GetRuleContext() antlr.RuleContext { @@ -103061,20 +103061,20 @@ func (s *Lock_typeContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *Lock_typeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLock_type(s) } } func (s *Lock_typeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLock_type(s) } } func (s *Lock_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLock_type(s) default: @@ -103082,9 +103082,9 @@ func (s *Lock_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Lock_type() (localctx ILock_typeContext) { +func (p *StarRocksSQLParser) Lock_type() (localctx ILock_typeContext) { localctx = NewLock_typeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 748, DorisSQLParserRULE_lock_type) + p.EnterRule(localctx, 748, StarRocksSQLParserRULE_lock_type) var _la int p.SetState(6059) @@ -103094,11 +103094,11 @@ func (p *DorisSQLParser) Lock_type() (localctx ILock_typeContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserREAD: + case StarRocksSQLParserREAD: p.EnterOuterAlt(localctx, 1) { p.SetState(6051) - p.Match(DorisSQLParserREAD) + p.Match(StarRocksSQLParserREAD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103111,10 +103111,10 @@ func (p *DorisSQLParser) Lock_type() (localctx ILock_typeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLOCAL { + if _la == StarRocksSQLParserLOCAL { { p.SetState(6052) - p.Match(DorisSQLParserLOCAL) + p.Match(StarRocksSQLParserLOCAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103123,7 +103123,7 @@ func (p *DorisSQLParser) Lock_type() (localctx ILock_typeContext) { } - case DorisSQLParserWRITE, DorisSQLParserLOW_PRIORITY: + case StarRocksSQLParserWRITE, StarRocksSQLParserLOW_PRIORITY: p.EnterOuterAlt(localctx, 2) p.SetState(6056) p.GetErrorHandler().Sync(p) @@ -103132,10 +103132,10 @@ func (p *DorisSQLParser) Lock_type() (localctx ILock_typeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLOW_PRIORITY { + if _la == StarRocksSQLParserLOW_PRIORITY { { p.SetState(6055) - p.Match(DorisSQLParserLOW_PRIORITY) + p.Match(StarRocksSQLParserLOW_PRIORITY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103145,7 +103145,7 @@ func (p *DorisSQLParser) Lock_type() (localctx ILock_typeContext) { } { p.SetState(6058) - p.Match(DorisSQLParserWRITE) + p.Match(StarRocksSQLParserWRITE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103196,13 +103196,13 @@ type AlterPlanAdvisorAddStatementContext struct { func NewEmptyAlterPlanAdvisorAddStatementContext() *AlterPlanAdvisorAddStatementContext { var p = new(AlterPlanAdvisorAddStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPlanAdvisorAddStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPlanAdvisorAddStatement return p } func InitEmptyAlterPlanAdvisorAddStatementContext(p *AlterPlanAdvisorAddStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPlanAdvisorAddStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPlanAdvisorAddStatement } func (*AlterPlanAdvisorAddStatementContext) IsAlterPlanAdvisorAddStatementContext() {} @@ -103213,7 +103213,7 @@ func NewAlterPlanAdvisorAddStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterPlanAdvisorAddStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPlanAdvisorAddStatement return p } @@ -103221,19 +103221,19 @@ func NewAlterPlanAdvisorAddStatementContext(parser antlr.Parser, parent antlr.Pa func (s *AlterPlanAdvisorAddStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterPlanAdvisorAddStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterPlanAdvisorAddStatementContext) PLAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLAN, 0) + return s.GetToken(StarRocksSQLParserPLAN, 0) } func (s *AlterPlanAdvisorAddStatementContext) ADVISOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADVISOR, 0) + return s.GetToken(StarRocksSQLParserADVISOR, 0) } func (s *AlterPlanAdvisorAddStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *AlterPlanAdvisorAddStatementContext) QueryStatement() IQueryStatementContext { @@ -103261,20 +103261,20 @@ func (s *AlterPlanAdvisorAddStatementContext) ToStringTree(ruleNames []string, r } func (s *AlterPlanAdvisorAddStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterPlanAdvisorAddStatement(s) } } func (s *AlterPlanAdvisorAddStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterPlanAdvisorAddStatement(s) } } func (s *AlterPlanAdvisorAddStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterPlanAdvisorAddStatement(s) default: @@ -103282,13 +103282,13 @@ func (s *AlterPlanAdvisorAddStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) AlterPlanAdvisorAddStatement() (localctx IAlterPlanAdvisorAddStatementContext) { +func (p *StarRocksSQLParser) AlterPlanAdvisorAddStatement() (localctx IAlterPlanAdvisorAddStatementContext) { localctx = NewAlterPlanAdvisorAddStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 750, DorisSQLParserRULE_alterPlanAdvisorAddStatement) + p.EnterRule(localctx, 750, StarRocksSQLParserRULE_alterPlanAdvisorAddStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6061) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103296,7 +103296,7 @@ func (p *DorisSQLParser) AlterPlanAdvisorAddStatement() (localctx IAlterPlanAdvi } { p.SetState(6062) - p.Match(DorisSQLParserPLAN) + p.Match(StarRocksSQLParserPLAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103304,7 +103304,7 @@ func (p *DorisSQLParser) AlterPlanAdvisorAddStatement() (localctx IAlterPlanAdvi } { p.SetState(6063) - p.Match(DorisSQLParserADVISOR) + p.Match(StarRocksSQLParserADVISOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103312,7 +103312,7 @@ func (p *DorisSQLParser) AlterPlanAdvisorAddStatement() (localctx IAlterPlanAdvi } { p.SetState(6064) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103360,13 +103360,13 @@ type TruncatePlanAdvisorStatementContext struct { func NewEmptyTruncatePlanAdvisorStatementContext() *TruncatePlanAdvisorStatementContext { var p = new(TruncatePlanAdvisorStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_truncatePlanAdvisorStatement + p.RuleIndex = StarRocksSQLParserRULE_truncatePlanAdvisorStatement return p } func InitEmptyTruncatePlanAdvisorStatementContext(p *TruncatePlanAdvisorStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_truncatePlanAdvisorStatement + p.RuleIndex = StarRocksSQLParserRULE_truncatePlanAdvisorStatement } func (*TruncatePlanAdvisorStatementContext) IsTruncatePlanAdvisorStatementContext() {} @@ -103377,7 +103377,7 @@ func NewTruncatePlanAdvisorStatementContext(parser antlr.Parser, parent antlr.Pa antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_truncatePlanAdvisorStatement + p.RuleIndex = StarRocksSQLParserRULE_truncatePlanAdvisorStatement return p } @@ -103385,15 +103385,15 @@ func NewTruncatePlanAdvisorStatementContext(parser antlr.Parser, parent antlr.Pa func (s *TruncatePlanAdvisorStatementContext) GetParser() antlr.Parser { return s.parser } func (s *TruncatePlanAdvisorStatementContext) TRUNCATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRUNCATE, 0) + return s.GetToken(StarRocksSQLParserTRUNCATE, 0) } func (s *TruncatePlanAdvisorStatementContext) PLAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLAN, 0) + return s.GetToken(StarRocksSQLParserPLAN, 0) } func (s *TruncatePlanAdvisorStatementContext) ADVISOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADVISOR, 0) + return s.GetToken(StarRocksSQLParserADVISOR, 0) } func (s *TruncatePlanAdvisorStatementContext) GetRuleContext() antlr.RuleContext { @@ -103405,20 +103405,20 @@ func (s *TruncatePlanAdvisorStatementContext) ToStringTree(ruleNames []string, r } func (s *TruncatePlanAdvisorStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTruncatePlanAdvisorStatement(s) } } func (s *TruncatePlanAdvisorStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTruncatePlanAdvisorStatement(s) } } func (s *TruncatePlanAdvisorStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTruncatePlanAdvisorStatement(s) default: @@ -103426,13 +103426,13 @@ func (s *TruncatePlanAdvisorStatementContext) Accept(visitor antlr.ParseTreeVisi } } -func (p *DorisSQLParser) TruncatePlanAdvisorStatement() (localctx ITruncatePlanAdvisorStatementContext) { +func (p *StarRocksSQLParser) TruncatePlanAdvisorStatement() (localctx ITruncatePlanAdvisorStatementContext) { localctx = NewTruncatePlanAdvisorStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 752, DorisSQLParserRULE_truncatePlanAdvisorStatement) + p.EnterRule(localctx, 752, StarRocksSQLParserRULE_truncatePlanAdvisorStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6067) - p.Match(DorisSQLParserTRUNCATE) + p.Match(StarRocksSQLParserTRUNCATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103440,7 +103440,7 @@ func (p *DorisSQLParser) TruncatePlanAdvisorStatement() (localctx ITruncatePlanA } { p.SetState(6068) - p.Match(DorisSQLParserPLAN) + p.Match(StarRocksSQLParserPLAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103448,7 +103448,7 @@ func (p *DorisSQLParser) TruncatePlanAdvisorStatement() (localctx ITruncatePlanA } { p.SetState(6069) - p.Match(DorisSQLParserADVISOR) + p.Match(StarRocksSQLParserADVISOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103494,13 +103494,13 @@ type AlterPlanAdvisorDropStatementContext struct { func NewEmptyAlterPlanAdvisorDropStatementContext() *AlterPlanAdvisorDropStatementContext { var p = new(AlterPlanAdvisorDropStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPlanAdvisorDropStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPlanAdvisorDropStatement return p } func InitEmptyAlterPlanAdvisorDropStatementContext(p *AlterPlanAdvisorDropStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterPlanAdvisorDropStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPlanAdvisorDropStatement } func (*AlterPlanAdvisorDropStatementContext) IsAlterPlanAdvisorDropStatementContext() {} @@ -103511,7 +103511,7 @@ func NewAlterPlanAdvisorDropStatementContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterPlanAdvisorDropStatement + p.RuleIndex = StarRocksSQLParserRULE_alterPlanAdvisorDropStatement return p } @@ -103519,19 +103519,19 @@ func NewAlterPlanAdvisorDropStatementContext(parser antlr.Parser, parent antlr.P func (s *AlterPlanAdvisorDropStatementContext) GetParser() antlr.Parser { return s.parser } func (s *AlterPlanAdvisorDropStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterPlanAdvisorDropStatementContext) PLAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLAN, 0) + return s.GetToken(StarRocksSQLParserPLAN, 0) } func (s *AlterPlanAdvisorDropStatementContext) ADVISOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADVISOR, 0) + return s.GetToken(StarRocksSQLParserADVISOR, 0) } func (s *AlterPlanAdvisorDropStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *AlterPlanAdvisorDropStatementContext) String_() IStringContext { @@ -103559,20 +103559,20 @@ func (s *AlterPlanAdvisorDropStatementContext) ToStringTree(ruleNames []string, } func (s *AlterPlanAdvisorDropStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterPlanAdvisorDropStatement(s) } } func (s *AlterPlanAdvisorDropStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterPlanAdvisorDropStatement(s) } } func (s *AlterPlanAdvisorDropStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterPlanAdvisorDropStatement(s) default: @@ -103580,13 +103580,13 @@ func (s *AlterPlanAdvisorDropStatementContext) Accept(visitor antlr.ParseTreeVis } } -func (p *DorisSQLParser) AlterPlanAdvisorDropStatement() (localctx IAlterPlanAdvisorDropStatementContext) { +func (p *StarRocksSQLParser) AlterPlanAdvisorDropStatement() (localctx IAlterPlanAdvisorDropStatementContext) { localctx = NewAlterPlanAdvisorDropStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 754, DorisSQLParserRULE_alterPlanAdvisorDropStatement) + p.EnterRule(localctx, 754, StarRocksSQLParserRULE_alterPlanAdvisorDropStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6071) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103594,7 +103594,7 @@ func (p *DorisSQLParser) AlterPlanAdvisorDropStatement() (localctx IAlterPlanAdv } { p.SetState(6072) - p.Match(DorisSQLParserPLAN) + p.Match(StarRocksSQLParserPLAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103602,7 +103602,7 @@ func (p *DorisSQLParser) AlterPlanAdvisorDropStatement() (localctx IAlterPlanAdv } { p.SetState(6073) - p.Match(DorisSQLParserADVISOR) + p.Match(StarRocksSQLParserADVISOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103610,7 +103610,7 @@ func (p *DorisSQLParser) AlterPlanAdvisorDropStatement() (localctx IAlterPlanAdv } { p.SetState(6074) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103658,13 +103658,13 @@ type ShowPlanAdvisorStatementContext struct { func NewEmptyShowPlanAdvisorStatementContext() *ShowPlanAdvisorStatementContext { var p = new(ShowPlanAdvisorStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPlanAdvisorStatement + p.RuleIndex = StarRocksSQLParserRULE_showPlanAdvisorStatement return p } func InitEmptyShowPlanAdvisorStatementContext(p *ShowPlanAdvisorStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showPlanAdvisorStatement + p.RuleIndex = StarRocksSQLParserRULE_showPlanAdvisorStatement } func (*ShowPlanAdvisorStatementContext) IsShowPlanAdvisorStatementContext() {} @@ -103675,7 +103675,7 @@ func NewShowPlanAdvisorStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showPlanAdvisorStatement + p.RuleIndex = StarRocksSQLParserRULE_showPlanAdvisorStatement return p } @@ -103683,15 +103683,15 @@ func NewShowPlanAdvisorStatementContext(parser antlr.Parser, parent antlr.Parser func (s *ShowPlanAdvisorStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowPlanAdvisorStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowPlanAdvisorStatementContext) PLAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLAN, 0) + return s.GetToken(StarRocksSQLParserPLAN, 0) } func (s *ShowPlanAdvisorStatementContext) ADVISOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADVISOR, 0) + return s.GetToken(StarRocksSQLParserADVISOR, 0) } func (s *ShowPlanAdvisorStatementContext) GetRuleContext() antlr.RuleContext { @@ -103703,20 +103703,20 @@ func (s *ShowPlanAdvisorStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowPlanAdvisorStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowPlanAdvisorStatement(s) } } func (s *ShowPlanAdvisorStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowPlanAdvisorStatement(s) } } func (s *ShowPlanAdvisorStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowPlanAdvisorStatement(s) default: @@ -103724,13 +103724,13 @@ func (s *ShowPlanAdvisorStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowPlanAdvisorStatement() (localctx IShowPlanAdvisorStatementContext) { +func (p *StarRocksSQLParser) ShowPlanAdvisorStatement() (localctx IShowPlanAdvisorStatementContext) { localctx = NewShowPlanAdvisorStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 756, DorisSQLParserRULE_showPlanAdvisorStatement) + p.EnterRule(localctx, 756, StarRocksSQLParserRULE_showPlanAdvisorStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6077) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103738,7 +103738,7 @@ func (p *DorisSQLParser) ShowPlanAdvisorStatement() (localctx IShowPlanAdvisorSt } { p.SetState(6078) - p.Match(DorisSQLParserPLAN) + p.Match(StarRocksSQLParserPLAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103746,7 +103746,7 @@ func (p *DorisSQLParser) ShowPlanAdvisorStatement() (localctx IShowPlanAdvisorSt } { p.SetState(6079) - p.Match(DorisSQLParserADVISOR) + p.Match(StarRocksSQLParserADVISOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103802,13 +103802,13 @@ type CreateWarehouseStatementContext struct { func NewEmptyCreateWarehouseStatementContext() *CreateWarehouseStatementContext { var p = new(CreateWarehouseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_createWarehouseStatement return p } func InitEmptyCreateWarehouseStatementContext(p *CreateWarehouseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_createWarehouseStatement } func (*CreateWarehouseStatementContext) IsCreateWarehouseStatementContext() {} @@ -103819,7 +103819,7 @@ func NewCreateWarehouseStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_createWarehouseStatement return p } @@ -103835,7 +103835,7 @@ func (s *CreateWarehouseStatementContext) SetWarehouseName(v IIdentifierOrString } func (s *CreateWarehouseStatementContext) CREATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCREATE, 0) + return s.GetToken(StarRocksSQLParserCREATE, 0) } func (s *CreateWarehouseStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -103855,19 +103855,19 @@ func (s *CreateWarehouseStatementContext) IdentifierOrString() IIdentifierOrStri } func (s *CreateWarehouseStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *CreateWarehouseStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateWarehouseStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateWarehouseStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateWarehouseStatementContext) Comment() ICommentContext { @@ -103911,20 +103911,20 @@ func (s *CreateWarehouseStatementContext) ToStringTree(ruleNames []string, recog } func (s *CreateWarehouseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateWarehouseStatement(s) } } func (s *CreateWarehouseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateWarehouseStatement(s) } } func (s *CreateWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateWarehouseStatement(s) default: @@ -103932,15 +103932,15 @@ func (s *CreateWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseStatementContext) { +func (p *StarRocksSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseStatementContext) { localctx = NewCreateWarehouseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 758, DorisSQLParserRULE_createWarehouseStatement) + p.EnterRule(localctx, 758, StarRocksSQLParserRULE_createWarehouseStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6081) - p.Match(DorisSQLParserCREATE) + p.Match(StarRocksSQLParserCREATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103949,7 +103949,7 @@ func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseSt { p.SetState(6082) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103963,10 +103963,10 @@ func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(6083) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103974,7 +103974,7 @@ func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseSt } { p.SetState(6084) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -103982,7 +103982,7 @@ func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseSt } { p.SetState(6085) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104004,7 +104004,7 @@ func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(6089) p.Comment() @@ -104018,7 +104018,7 @@ func (p *DorisSQLParser) CreateWarehouseStatement() (localctx ICreateWarehouseSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(6092) p.Properties() @@ -104072,13 +104072,13 @@ type DropWarehouseStatementContext struct { func NewEmptyDropWarehouseStatementContext() *DropWarehouseStatementContext { var p = new(DropWarehouseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_dropWarehouseStatement return p } func InitEmptyDropWarehouseStatementContext(p *DropWarehouseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_dropWarehouseStatement } func (*DropWarehouseStatementContext) IsDropWarehouseStatementContext() {} @@ -104089,7 +104089,7 @@ func NewDropWarehouseStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_dropWarehouseStatement return p } @@ -104105,11 +104105,11 @@ func (s *DropWarehouseStatementContext) SetWarehouseName(v IIdentifierOrStringCo } func (s *DropWarehouseStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropWarehouseStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *DropWarehouseStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -104129,11 +104129,11 @@ func (s *DropWarehouseStatementContext) IdentifierOrString() IIdentifierOrString } func (s *DropWarehouseStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropWarehouseStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropWarehouseStatementContext) GetRuleContext() antlr.RuleContext { @@ -104145,20 +104145,20 @@ func (s *DropWarehouseStatementContext) ToStringTree(ruleNames []string, recog a } func (s *DropWarehouseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropWarehouseStatement(s) } } func (s *DropWarehouseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropWarehouseStatement(s) } } func (s *DropWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropWarehouseStatement(s) default: @@ -104166,15 +104166,15 @@ func (s *DropWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) DropWarehouseStatement() (localctx IDropWarehouseStatementContext) { +func (p *StarRocksSQLParser) DropWarehouseStatement() (localctx IDropWarehouseStatementContext) { localctx = NewDropWarehouseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 760, DorisSQLParserRULE_dropWarehouseStatement) + p.EnterRule(localctx, 760, StarRocksSQLParserRULE_dropWarehouseStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6095) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104182,7 +104182,7 @@ func (p *DorisSQLParser) DropWarehouseStatement() (localctx IDropWarehouseStatem } { p.SetState(6096) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104195,10 +104195,10 @@ func (p *DorisSQLParser) DropWarehouseStatement() (localctx IDropWarehouseStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(6097) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104206,7 +104206,7 @@ func (p *DorisSQLParser) DropWarehouseStatement() (localctx IDropWarehouseStatem } { p.SetState(6098) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104261,13 +104261,13 @@ type SuspendWarehouseStatementContext struct { func NewEmptySuspendWarehouseStatementContext() *SuspendWarehouseStatementContext { var p = new(SuspendWarehouseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_suspendWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_suspendWarehouseStatement return p } func InitEmptySuspendWarehouseStatementContext(p *SuspendWarehouseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_suspendWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_suspendWarehouseStatement } func (*SuspendWarehouseStatementContext) IsSuspendWarehouseStatementContext() {} @@ -104278,7 +104278,7 @@ func NewSuspendWarehouseStatementContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_suspendWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_suspendWarehouseStatement return p } @@ -104286,11 +104286,11 @@ func NewSuspendWarehouseStatementContext(parser antlr.Parser, parent antlr.Parse func (s *SuspendWarehouseStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SuspendWarehouseStatementContext) SUSPEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUSPEND, 0) + return s.GetToken(StarRocksSQLParserSUSPEND, 0) } func (s *SuspendWarehouseStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *SuspendWarehouseStatementContext) Identifier() IIdentifierContext { @@ -104310,11 +104310,11 @@ func (s *SuspendWarehouseStatementContext) Identifier() IIdentifierContext { } func (s *SuspendWarehouseStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *SuspendWarehouseStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *SuspendWarehouseStatementContext) GetRuleContext() antlr.RuleContext { @@ -104326,20 +104326,20 @@ func (s *SuspendWarehouseStatementContext) ToStringTree(ruleNames []string, reco } func (s *SuspendWarehouseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSuspendWarehouseStatement(s) } } func (s *SuspendWarehouseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSuspendWarehouseStatement(s) } } func (s *SuspendWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSuspendWarehouseStatement(s) default: @@ -104347,15 +104347,15 @@ func (s *SuspendWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) SuspendWarehouseStatement() (localctx ISuspendWarehouseStatementContext) { +func (p *StarRocksSQLParser) SuspendWarehouseStatement() (localctx ISuspendWarehouseStatementContext) { localctx = NewSuspendWarehouseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 762, DorisSQLParserRULE_suspendWarehouseStatement) + p.EnterRule(localctx, 762, StarRocksSQLParserRULE_suspendWarehouseStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6103) - p.Match(DorisSQLParserSUSPEND) + p.Match(StarRocksSQLParserSUSPEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104363,7 +104363,7 @@ func (p *DorisSQLParser) SuspendWarehouseStatement() (localctx ISuspendWarehouse } { p.SetState(6104) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104376,10 +104376,10 @@ func (p *DorisSQLParser) SuspendWarehouseStatement() (localctx ISuspendWarehouse } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(6105) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104387,7 +104387,7 @@ func (p *DorisSQLParser) SuspendWarehouseStatement() (localctx ISuspendWarehouse } { p.SetState(6106) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104439,13 +104439,13 @@ type ResumeWarehouseStatementContext struct { func NewEmptyResumeWarehouseStatementContext() *ResumeWarehouseStatementContext { var p = new(ResumeWarehouseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_resumeWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_resumeWarehouseStatement return p } func InitEmptyResumeWarehouseStatementContext(p *ResumeWarehouseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_resumeWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_resumeWarehouseStatement } func (*ResumeWarehouseStatementContext) IsResumeWarehouseStatementContext() {} @@ -104456,7 +104456,7 @@ func NewResumeWarehouseStatementContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_resumeWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_resumeWarehouseStatement return p } @@ -104464,11 +104464,11 @@ func NewResumeWarehouseStatementContext(parser antlr.Parser, parent antlr.Parser func (s *ResumeWarehouseStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ResumeWarehouseStatementContext) RESUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESUME, 0) + return s.GetToken(StarRocksSQLParserRESUME, 0) } func (s *ResumeWarehouseStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *ResumeWarehouseStatementContext) Identifier() IIdentifierContext { @@ -104488,11 +104488,11 @@ func (s *ResumeWarehouseStatementContext) Identifier() IIdentifierContext { } func (s *ResumeWarehouseStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *ResumeWarehouseStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *ResumeWarehouseStatementContext) GetRuleContext() antlr.RuleContext { @@ -104504,20 +104504,20 @@ func (s *ResumeWarehouseStatementContext) ToStringTree(ruleNames []string, recog } func (s *ResumeWarehouseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterResumeWarehouseStatement(s) } } func (s *ResumeWarehouseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitResumeWarehouseStatement(s) } } func (s *ResumeWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitResumeWarehouseStatement(s) default: @@ -104525,15 +104525,15 @@ func (s *ResumeWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ResumeWarehouseStatement() (localctx IResumeWarehouseStatementContext) { +func (p *StarRocksSQLParser) ResumeWarehouseStatement() (localctx IResumeWarehouseStatementContext) { localctx = NewResumeWarehouseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 764, DorisSQLParserRULE_resumeWarehouseStatement) + p.EnterRule(localctx, 764, StarRocksSQLParserRULE_resumeWarehouseStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6111) - p.Match(DorisSQLParserRESUME) + p.Match(StarRocksSQLParserRESUME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104541,7 +104541,7 @@ func (p *DorisSQLParser) ResumeWarehouseStatement() (localctx IResumeWarehouseSt } { p.SetState(6112) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104554,10 +104554,10 @@ func (p *DorisSQLParser) ResumeWarehouseStatement() (localctx IResumeWarehouseSt } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(6113) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104565,7 +104565,7 @@ func (p *DorisSQLParser) ResumeWarehouseStatement() (localctx IResumeWarehouseSt } { p.SetState(6114) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104617,13 +104617,13 @@ type SetWarehouseStatementContext struct { func NewEmptySetWarehouseStatementContext() *SetWarehouseStatementContext { var p = new(SetWarehouseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_setWarehouseStatement return p } func InitEmptySetWarehouseStatementContext(p *SetWarehouseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_setWarehouseStatement } func (*SetWarehouseStatementContext) IsSetWarehouseStatementContext() {} @@ -104634,7 +104634,7 @@ func NewSetWarehouseStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_setWarehouseStatement return p } @@ -104642,11 +104642,11 @@ func NewSetWarehouseStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *SetWarehouseStatementContext) GetParser() antlr.Parser { return s.parser } func (s *SetWarehouseStatementContext) SET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSET, 0) + return s.GetToken(StarRocksSQLParserSET, 0) } func (s *SetWarehouseStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *SetWarehouseStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -104666,11 +104666,11 @@ func (s *SetWarehouseStatementContext) IdentifierOrString() IIdentifierOrStringC } func (s *SetWarehouseStatementContext) SESSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSESSION, 0) + return s.GetToken(StarRocksSQLParserSESSION, 0) } func (s *SetWarehouseStatementContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *SetWarehouseStatementContext) GetRuleContext() antlr.RuleContext { @@ -104682,20 +104682,20 @@ func (s *SetWarehouseStatementContext) ToStringTree(ruleNames []string, recog an } func (s *SetWarehouseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetWarehouseStatement(s) } } func (s *SetWarehouseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetWarehouseStatement(s) } } func (s *SetWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetWarehouseStatement(s) default: @@ -104703,15 +104703,15 @@ func (s *SetWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) SetWarehouseStatement() (localctx ISetWarehouseStatementContext) { +func (p *StarRocksSQLParser) SetWarehouseStatement() (localctx ISetWarehouseStatementContext) { localctx = NewSetWarehouseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 766, DorisSQLParserRULE_setWarehouseStatement) + p.EnterRule(localctx, 766, StarRocksSQLParserRULE_setWarehouseStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6119) - p.Match(DorisSQLParserSET) + p.Match(StarRocksSQLParserSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104724,10 +104724,10 @@ func (p *DorisSQLParser) SetWarehouseStatement() (localctx ISetWarehouseStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSESSION { + if _la == StarRocksSQLParserSESSION { { p.SetState(6120) - p.Match(DorisSQLParserSESSION) + p.Match(StarRocksSQLParserSESSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104737,7 +104737,7 @@ func (p *DorisSQLParser) SetWarehouseStatement() (localctx ISetWarehouseStatemen } { p.SetState(6123) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104750,10 +104750,10 @@ func (p *DorisSQLParser) SetWarehouseStatement() (localctx ISetWarehouseStatemen } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserEQ { + if _la == StarRocksSQLParserEQ { { p.SetState(6124) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104811,13 +104811,13 @@ type ShowWarehousesStatementContext struct { func NewEmptyShowWarehousesStatementContext() *ShowWarehousesStatementContext { var p = new(ShowWarehousesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWarehousesStatement + p.RuleIndex = StarRocksSQLParserRULE_showWarehousesStatement return p } func InitEmptyShowWarehousesStatementContext(p *ShowWarehousesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showWarehousesStatement + p.RuleIndex = StarRocksSQLParserRULE_showWarehousesStatement } func (*ShowWarehousesStatementContext) IsShowWarehousesStatementContext() {} @@ -104828,7 +104828,7 @@ func NewShowWarehousesStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showWarehousesStatement + p.RuleIndex = StarRocksSQLParserRULE_showWarehousesStatement return p } @@ -104840,15 +104840,15 @@ func (s *ShowWarehousesStatementContext) GetPattern() IStringContext { return s. func (s *ShowWarehousesStatementContext) SetPattern(v IStringContext) { s.pattern = v } func (s *ShowWarehousesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowWarehousesStatementContext) WAREHOUSES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSES, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSES, 0) } func (s *ShowWarehousesStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowWarehousesStatementContext) String_() IStringContext { @@ -104876,20 +104876,20 @@ func (s *ShowWarehousesStatementContext) ToStringTree(ruleNames []string, recog } func (s *ShowWarehousesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowWarehousesStatement(s) } } func (s *ShowWarehousesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowWarehousesStatement(s) } } func (s *ShowWarehousesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowWarehousesStatement(s) default: @@ -104897,15 +104897,15 @@ func (s *ShowWarehousesStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) ShowWarehousesStatement() (localctx IShowWarehousesStatementContext) { +func (p *StarRocksSQLParser) ShowWarehousesStatement() (localctx IShowWarehousesStatementContext) { localctx = NewShowWarehousesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 768, DorisSQLParserRULE_showWarehousesStatement) + p.EnterRule(localctx, 768, StarRocksSQLParserRULE_showWarehousesStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6129) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104913,7 +104913,7 @@ func (p *DorisSQLParser) ShowWarehousesStatement() (localctx IShowWarehousesStat } { p.SetState(6130) - p.Match(DorisSQLParserWAREHOUSES) + p.Match(StarRocksSQLParserWAREHOUSES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104926,10 +104926,10 @@ func (p *DorisSQLParser) ShowWarehousesStatement() (localctx IShowWarehousesStat } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(6131) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -104985,13 +104985,13 @@ type ShowClustersStatementContext struct { func NewEmptyShowClustersStatementContext() *ShowClustersStatementContext { var p = new(ShowClustersStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showClustersStatement + p.RuleIndex = StarRocksSQLParserRULE_showClustersStatement return p } func InitEmptyShowClustersStatementContext(p *ShowClustersStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showClustersStatement + p.RuleIndex = StarRocksSQLParserRULE_showClustersStatement } func (*ShowClustersStatementContext) IsShowClustersStatementContext() {} @@ -105002,7 +105002,7 @@ func NewShowClustersStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showClustersStatement + p.RuleIndex = StarRocksSQLParserRULE_showClustersStatement return p } @@ -105010,15 +105010,15 @@ func NewShowClustersStatementContext(parser antlr.Parser, parent antlr.ParserRul func (s *ShowClustersStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ShowClustersStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowClustersStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowClustersStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *ShowClustersStatementContext) Identifier() IIdentifierContext { @@ -105038,11 +105038,11 @@ func (s *ShowClustersStatementContext) Identifier() IIdentifierContext { } func (s *ShowClustersStatementContext) CLUSTERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLUSTERS, 0) + return s.GetToken(StarRocksSQLParserCLUSTERS, 0) } func (s *ShowClustersStatementContext) CNGROUPS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUPS, 0) + return s.GetToken(StarRocksSQLParserCNGROUPS, 0) } func (s *ShowClustersStatementContext) GetRuleContext() antlr.RuleContext { @@ -105054,20 +105054,20 @@ func (s *ShowClustersStatementContext) ToStringTree(ruleNames []string, recog an } func (s *ShowClustersStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowClustersStatement(s) } } func (s *ShowClustersStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowClustersStatement(s) } } func (s *ShowClustersStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowClustersStatement(s) default: @@ -105075,15 +105075,15 @@ func (s *ShowClustersStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) ShowClustersStatement() (localctx IShowClustersStatementContext) { +func (p *StarRocksSQLParser) ShowClustersStatement() (localctx IShowClustersStatementContext) { localctx = NewShowClustersStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 770, DorisSQLParserRULE_showClustersStatement) + p.EnterRule(localctx, 770, StarRocksSQLParserRULE_showClustersStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6135) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105093,7 +105093,7 @@ func (p *DorisSQLParser) ShowClustersStatement() (localctx IShowClustersStatemen p.SetState(6136) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCLUSTERS || _la == DorisSQLParserCNGROUPS) { + if !(_la == StarRocksSQLParserCLUSTERS || _la == StarRocksSQLParserCNGROUPS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -105102,7 +105102,7 @@ func (p *DorisSQLParser) ShowClustersStatement() (localctx IShowClustersStatemen } { p.SetState(6137) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105110,7 +105110,7 @@ func (p *DorisSQLParser) ShowClustersStatement() (localctx IShowClustersStatemen } { p.SetState(6138) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105179,13 +105179,13 @@ type ShowNodesStatementContext struct { func NewEmptyShowNodesStatementContext() *ShowNodesStatementContext { var p = new(ShowNodesStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showNodesStatement + p.RuleIndex = StarRocksSQLParserRULE_showNodesStatement return p } func InitEmptyShowNodesStatementContext(p *ShowNodesStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_showNodesStatement + p.RuleIndex = StarRocksSQLParserRULE_showNodesStatement } func (*ShowNodesStatementContext) IsShowNodesStatementContext() {} @@ -105196,7 +105196,7 @@ func NewShowNodesStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_showNodesStatement + p.RuleIndex = StarRocksSQLParserRULE_showNodesStatement return p } @@ -105212,23 +105212,23 @@ func (s *ShowNodesStatementContext) SetPattern(v IStringContext) { s.pattern = v func (s *ShowNodesStatementContext) SetCngroupName(v IIdentifierOrStringContext) { s.cngroupName = v } func (s *ShowNodesStatementContext) SHOW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSHOW, 0) + return s.GetToken(StarRocksSQLParserSHOW, 0) } func (s *ShowNodesStatementContext) NODES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODES, 0) + return s.GetToken(StarRocksSQLParserNODES, 0) } func (s *ShowNodesStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ShowNodesStatementContext) WAREHOUSES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSES, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSES, 0) } func (s *ShowNodesStatementContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *ShowNodesStatementContext) String_() IStringContext { @@ -105248,7 +105248,7 @@ func (s *ShowNodesStatementContext) String_() IStringContext { } func (s *ShowNodesStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *ShowNodesStatementContext) Identifier() IIdentifierContext { @@ -105268,7 +105268,7 @@ func (s *ShowNodesStatementContext) Identifier() IIdentifierContext { } func (s *ShowNodesStatementContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *ShowNodesStatementContext) IdentifierOrString() IIdentifierOrStringContext { @@ -105296,20 +105296,20 @@ func (s *ShowNodesStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *ShowNodesStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterShowNodesStatement(s) } } func (s *ShowNodesStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitShowNodesStatement(s) } } func (s *ShowNodesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitShowNodesStatement(s) default: @@ -105317,9 +105317,9 @@ func (s *ShowNodesStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementContext) { +func (p *StarRocksSQLParser) ShowNodesStatement() (localctx IShowNodesStatementContext) { localctx = NewShowNodesStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 772, DorisSQLParserRULE_showNodesStatement) + p.EnterRule(localctx, 772, StarRocksSQLParserRULE_showNodesStatement) var _la int p.SetState(6158) @@ -105333,7 +105333,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte p.EnterOuterAlt(localctx, 1) { p.SetState(6141) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105341,7 +105341,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } { p.SetState(6142) - p.Match(DorisSQLParserNODES) + p.Match(StarRocksSQLParserNODES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105349,7 +105349,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } { p.SetState(6143) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105357,7 +105357,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } { p.SetState(6144) - p.Match(DorisSQLParserWAREHOUSES) + p.Match(StarRocksSQLParserWAREHOUSES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105370,10 +105370,10 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIKE { + if _la == StarRocksSQLParserLIKE { { p.SetState(6145) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105393,7 +105393,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte p.EnterOuterAlt(localctx, 2) { p.SetState(6149) - p.Match(DorisSQLParserSHOW) + p.Match(StarRocksSQLParserSHOW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105401,7 +105401,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } { p.SetState(6150) - p.Match(DorisSQLParserNODES) + p.Match(StarRocksSQLParserNODES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105409,7 +105409,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } { p.SetState(6151) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105417,7 +105417,7 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } { p.SetState(6152) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105434,10 +105434,10 @@ func (p *DorisSQLParser) ShowNodesStatement() (localctx IShowNodesStatementConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCNGROUP { + if _la == StarRocksSQLParserCNGROUP { { p.SetState(6154) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105502,13 +105502,13 @@ type AlterWarehouseStatementContext struct { func NewEmptyAlterWarehouseStatementContext() *AlterWarehouseStatementContext { var p = new(AlterWarehouseStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_alterWarehouseStatement return p } func InitEmptyAlterWarehouseStatementContext(p *AlterWarehouseStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_alterWarehouseStatement } func (*AlterWarehouseStatementContext) IsAlterWarehouseStatementContext() {} @@ -105519,7 +105519,7 @@ func NewAlterWarehouseStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterWarehouseStatement + p.RuleIndex = StarRocksSQLParserRULE_alterWarehouseStatement return p } @@ -105535,11 +105535,11 @@ func (s *AlterWarehouseStatementContext) SetWarehouseName(v IIdentifierOrStringC } func (s *AlterWarehouseStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterWarehouseStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *AlterWarehouseStatementContext) ModifyPropertiesClause() IModifyPropertiesClauseContext { @@ -105583,20 +105583,20 @@ func (s *AlterWarehouseStatementContext) ToStringTree(ruleNames []string, recog } func (s *AlterWarehouseStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterWarehouseStatement(s) } } func (s *AlterWarehouseStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterWarehouseStatement(s) } } func (s *AlterWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterWarehouseStatement(s) default: @@ -105604,13 +105604,13 @@ func (s *AlterWarehouseStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) AlterWarehouseStatement() (localctx IAlterWarehouseStatementContext) { +func (p *StarRocksSQLParser) AlterWarehouseStatement() (localctx IAlterWarehouseStatementContext) { localctx = NewAlterWarehouseStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 774, DorisSQLParserRULE_alterWarehouseStatement) + p.EnterRule(localctx, 774, StarRocksSQLParserRULE_alterWarehouseStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6160) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105618,7 +105618,7 @@ func (p *DorisSQLParser) AlterWarehouseStatement() (localctx IAlterWarehouseStat } { p.SetState(6161) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105695,13 +105695,13 @@ type CreateCNGroupStatementContext struct { func NewEmptyCreateCNGroupStatementContext() *CreateCNGroupStatementContext { var p = new(CreateCNGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_createCNGroupStatement return p } func InitEmptyCreateCNGroupStatementContext(p *CreateCNGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_createCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_createCNGroupStatement } func (*CreateCNGroupStatementContext) IsCreateCNGroupStatementContext() {} @@ -105712,7 +105712,7 @@ func NewCreateCNGroupStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_createCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_createCNGroupStatement return p } @@ -105736,19 +105736,19 @@ func (s *CreateCNGroupStatementContext) SetCngroupName(v IIdentifierOrStringCont } func (s *CreateCNGroupStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *CreateCNGroupStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *CreateCNGroupStatementContext) ADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADD, 0) + return s.GetToken(StarRocksSQLParserADD, 0) } func (s *CreateCNGroupStatementContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *CreateCNGroupStatementContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -105793,15 +105793,15 @@ func (s *CreateCNGroupStatementContext) IdentifierOrString(i int) IIdentifierOrS } func (s *CreateCNGroupStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *CreateCNGroupStatementContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *CreateCNGroupStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *CreateCNGroupStatementContext) Comment() ICommentContext { @@ -105845,20 +105845,20 @@ func (s *CreateCNGroupStatementContext) ToStringTree(ruleNames []string, recog a } func (s *CreateCNGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCreateCNGroupStatement(s) } } func (s *CreateCNGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCreateCNGroupStatement(s) } } func (s *CreateCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCreateCNGroupStatement(s) default: @@ -105866,15 +105866,15 @@ func (s *CreateCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatementContext) { +func (p *StarRocksSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatementContext) { localctx = NewCreateCNGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 776, DorisSQLParserRULE_createCNGroupStatement) + p.EnterRule(localctx, 776, StarRocksSQLParserRULE_createCNGroupStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6165) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105882,7 +105882,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } { p.SetState(6166) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105897,7 +105897,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } { p.SetState(6168) - p.Match(DorisSQLParserADD) + p.Match(StarRocksSQLParserADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105905,7 +105905,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } { p.SetState(6169) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105918,10 +105918,10 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(6170) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105929,7 +105929,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } { p.SetState(6171) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105937,7 +105937,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } { p.SetState(6172) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -105959,7 +105959,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserCOMMENT { + if _la == StarRocksSQLParserCOMMENT { { p.SetState(6176) p.Comment() @@ -105973,7 +105973,7 @@ func (p *DorisSQLParser) CreateCNGroupStatement() (localctx ICreateCNGroupStatem } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(6179) p.Properties() @@ -106038,13 +106038,13 @@ type DropCNGroupStatementContext struct { func NewEmptyDropCNGroupStatementContext() *DropCNGroupStatementContext { var p = new(DropCNGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_dropCNGroupStatement return p } func InitEmptyDropCNGroupStatementContext(p *DropCNGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dropCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_dropCNGroupStatement } func (*DropCNGroupStatementContext) IsDropCNGroupStatementContext() {} @@ -106055,7 +106055,7 @@ func NewDropCNGroupStatementContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dropCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_dropCNGroupStatement return p } @@ -106077,19 +106077,19 @@ func (s *DropCNGroupStatementContext) SetWarehouseName(v IIdentifierOrStringCont func (s *DropCNGroupStatementContext) SetCngroupName(v IIdentifierOrStringContext) { s.cngroupName = v } func (s *DropCNGroupStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *DropCNGroupStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *DropCNGroupStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DropCNGroupStatementContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *DropCNGroupStatementContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -106134,15 +106134,15 @@ func (s *DropCNGroupStatementContext) IdentifierOrString(i int) IIdentifierOrStr } func (s *DropCNGroupStatementContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *DropCNGroupStatementContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *DropCNGroupStatementContext) FORCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORCE, 0) + return s.GetToken(StarRocksSQLParserFORCE, 0) } func (s *DropCNGroupStatementContext) GetRuleContext() antlr.RuleContext { @@ -106154,20 +106154,20 @@ func (s *DropCNGroupStatementContext) ToStringTree(ruleNames []string, recog ant } func (s *DropCNGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDropCNGroupStatement(s) } } func (s *DropCNGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDropCNGroupStatement(s) } } func (s *DropCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDropCNGroupStatement(s) default: @@ -106175,15 +106175,15 @@ func (s *DropCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementContext) { +func (p *StarRocksSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementContext) { localctx = NewDropCNGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 778, DorisSQLParserRULE_dropCNGroupStatement) + p.EnterRule(localctx, 778, StarRocksSQLParserRULE_dropCNGroupStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6182) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106191,7 +106191,7 @@ func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementC } { p.SetState(6183) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106206,7 +106206,7 @@ func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementC } { p.SetState(6185) - p.Match(DorisSQLParserDROP) + p.Match(StarRocksSQLParserDROP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106214,7 +106214,7 @@ func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementC } { p.SetState(6186) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106227,10 +106227,10 @@ func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(6187) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106238,7 +106238,7 @@ func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementC } { p.SetState(6188) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106260,10 +106260,10 @@ func (p *DorisSQLParser) DropCNGroupStatement() (localctx IDropCNGroupStatementC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORCE { + if _la == StarRocksSQLParserFORCE { { p.SetState(6192) - p.Match(DorisSQLParserFORCE) + p.Match(StarRocksSQLParserFORCE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106326,13 +106326,13 @@ type EnableCNGroupStatementContext struct { func NewEmptyEnableCNGroupStatementContext() *EnableCNGroupStatementContext { var p = new(EnableCNGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_enableCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_enableCNGroupStatement return p } func InitEmptyEnableCNGroupStatementContext(p *EnableCNGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_enableCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_enableCNGroupStatement } func (*EnableCNGroupStatementContext) IsEnableCNGroupStatementContext() {} @@ -106343,7 +106343,7 @@ func NewEnableCNGroupStatementContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_enableCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_enableCNGroupStatement return p } @@ -106367,19 +106367,19 @@ func (s *EnableCNGroupStatementContext) SetCngroupName(v IIdentifierOrStringCont } func (s *EnableCNGroupStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *EnableCNGroupStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *EnableCNGroupStatementContext) ENABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENABLE, 0) + return s.GetToken(StarRocksSQLParserENABLE, 0) } func (s *EnableCNGroupStatementContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *EnableCNGroupStatementContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -106432,20 +106432,20 @@ func (s *EnableCNGroupStatementContext) ToStringTree(ruleNames []string, recog a } func (s *EnableCNGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterEnableCNGroupStatement(s) } } func (s *EnableCNGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitEnableCNGroupStatement(s) } } func (s *EnableCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitEnableCNGroupStatement(s) default: @@ -106453,13 +106453,13 @@ func (s *EnableCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) EnableCNGroupStatement() (localctx IEnableCNGroupStatementContext) { +func (p *StarRocksSQLParser) EnableCNGroupStatement() (localctx IEnableCNGroupStatementContext) { localctx = NewEnableCNGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 780, DorisSQLParserRULE_enableCNGroupStatement) + p.EnterRule(localctx, 780, StarRocksSQLParserRULE_enableCNGroupStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6195) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106467,7 +106467,7 @@ func (p *DorisSQLParser) EnableCNGroupStatement() (localctx IEnableCNGroupStatem } { p.SetState(6196) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106482,7 +106482,7 @@ func (p *DorisSQLParser) EnableCNGroupStatement() (localctx IEnableCNGroupStatem } { p.SetState(6198) - p.Match(DorisSQLParserENABLE) + p.Match(StarRocksSQLParserENABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106490,7 +106490,7 @@ func (p *DorisSQLParser) EnableCNGroupStatement() (localctx IEnableCNGroupStatem } { p.SetState(6199) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106558,13 +106558,13 @@ type DisableCNGroupStatementContext struct { func NewEmptyDisableCNGroupStatementContext() *DisableCNGroupStatementContext { var p = new(DisableCNGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_disableCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_disableCNGroupStatement return p } func InitEmptyDisableCNGroupStatementContext(p *DisableCNGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_disableCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_disableCNGroupStatement } func (*DisableCNGroupStatementContext) IsDisableCNGroupStatementContext() {} @@ -106575,7 +106575,7 @@ func NewDisableCNGroupStatementContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_disableCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_disableCNGroupStatement return p } @@ -106599,19 +106599,19 @@ func (s *DisableCNGroupStatementContext) SetCngroupName(v IIdentifierOrStringCon } func (s *DisableCNGroupStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *DisableCNGroupStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *DisableCNGroupStatementContext) DISABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISABLE, 0) + return s.GetToken(StarRocksSQLParserDISABLE, 0) } func (s *DisableCNGroupStatementContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *DisableCNGroupStatementContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -106664,20 +106664,20 @@ func (s *DisableCNGroupStatementContext) ToStringTree(ruleNames []string, recog } func (s *DisableCNGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDisableCNGroupStatement(s) } } func (s *DisableCNGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDisableCNGroupStatement(s) } } func (s *DisableCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDisableCNGroupStatement(s) default: @@ -106685,13 +106685,13 @@ func (s *DisableCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) DisableCNGroupStatement() (localctx IDisableCNGroupStatementContext) { +func (p *StarRocksSQLParser) DisableCNGroupStatement() (localctx IDisableCNGroupStatementContext) { localctx = NewDisableCNGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 782, DorisSQLParserRULE_disableCNGroupStatement) + p.EnterRule(localctx, 782, StarRocksSQLParserRULE_disableCNGroupStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6202) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106699,7 +106699,7 @@ func (p *DorisSQLParser) DisableCNGroupStatement() (localctx IDisableCNGroupStat } { p.SetState(6203) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106714,7 +106714,7 @@ func (p *DorisSQLParser) DisableCNGroupStatement() (localctx IDisableCNGroupStat } { p.SetState(6205) - p.Match(DorisSQLParserDISABLE) + p.Match(StarRocksSQLParserDISABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106722,7 +106722,7 @@ func (p *DorisSQLParser) DisableCNGroupStatement() (localctx IDisableCNGroupStat } { p.SetState(6206) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106791,13 +106791,13 @@ type AlterCNGroupStatementContext struct { func NewEmptyAlterCNGroupStatementContext() *AlterCNGroupStatementContext { var p = new(AlterCNGroupStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_alterCNGroupStatement return p } func InitEmptyAlterCNGroupStatementContext(p *AlterCNGroupStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_alterCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_alterCNGroupStatement } func (*AlterCNGroupStatementContext) IsAlterCNGroupStatementContext() {} @@ -106808,7 +106808,7 @@ func NewAlterCNGroupStatementContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_alterCNGroupStatement + p.RuleIndex = StarRocksSQLParserRULE_alterCNGroupStatement return p } @@ -106832,19 +106832,19 @@ func (s *AlterCNGroupStatementContext) SetCngroupName(v IIdentifierOrStringConte } func (s *AlterCNGroupStatementContext) ALTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALTER, 0) + return s.GetToken(StarRocksSQLParserALTER, 0) } func (s *AlterCNGroupStatementContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *AlterCNGroupStatementContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *AlterCNGroupStatementContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *AlterCNGroupStatementContext) ModifyPropertiesClause() IModifyPropertiesClauseContext { @@ -106913,20 +106913,20 @@ func (s *AlterCNGroupStatementContext) ToStringTree(ruleNames []string, recog an } func (s *AlterCNGroupStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAlterCNGroupStatement(s) } } func (s *AlterCNGroupStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAlterCNGroupStatement(s) } } func (s *AlterCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAlterCNGroupStatement(s) default: @@ -106934,13 +106934,13 @@ func (s *AlterCNGroupStatementContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) AlterCNGroupStatement() (localctx IAlterCNGroupStatementContext) { +func (p *StarRocksSQLParser) AlterCNGroupStatement() (localctx IAlterCNGroupStatementContext) { localctx = NewAlterCNGroupStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 784, DorisSQLParserRULE_alterCNGroupStatement) + p.EnterRule(localctx, 784, StarRocksSQLParserRULE_alterCNGroupStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6209) - p.Match(DorisSQLParserALTER) + p.Match(StarRocksSQLParserALTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106948,7 +106948,7 @@ func (p *DorisSQLParser) AlterCNGroupStatement() (localctx IAlterCNGroupStatemen } { p.SetState(6210) - p.Match(DorisSQLParserWAREHOUSE) + p.Match(StarRocksSQLParserWAREHOUSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106963,7 +106963,7 @@ func (p *DorisSQLParser) AlterCNGroupStatement() (localctx IAlterCNGroupStatemen } { p.SetState(6212) - p.Match(DorisSQLParserMODIFY) + p.Match(StarRocksSQLParserMODIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -106971,7 +106971,7 @@ func (p *DorisSQLParser) AlterCNGroupStatement() (localctx IAlterCNGroupStatemen } { p.SetState(6213) - p.Match(DorisSQLParserCNGROUP) + p.Match(StarRocksSQLParserCNGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107030,13 +107030,13 @@ type BeginStatementContext struct { func NewEmptyBeginStatementContext() *BeginStatementContext { var p = new(BeginStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_beginStatement + p.RuleIndex = StarRocksSQLParserRULE_beginStatement return p } func InitEmptyBeginStatementContext(p *BeginStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_beginStatement + p.RuleIndex = StarRocksSQLParserRULE_beginStatement } func (*BeginStatementContext) IsBeginStatementContext() {} @@ -107047,7 +107047,7 @@ func NewBeginStatementContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_beginStatement + p.RuleIndex = StarRocksSQLParserRULE_beginStatement return p } @@ -107055,31 +107055,31 @@ func NewBeginStatementContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *BeginStatementContext) GetParser() antlr.Parser { return s.parser } func (s *BeginStatementContext) START() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTART, 0) + return s.GetToken(StarRocksSQLParserSTART, 0) } func (s *BeginStatementContext) TRANSACTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSACTION, 0) + return s.GetToken(StarRocksSQLParserTRANSACTION, 0) } func (s *BeginStatementContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *BeginStatementContext) CONSISTENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONSISTENT, 0) + return s.GetToken(StarRocksSQLParserCONSISTENT, 0) } func (s *BeginStatementContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *BeginStatementContext) BEGIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBEGIN, 0) + return s.GetToken(StarRocksSQLParserBEGIN, 0) } func (s *BeginStatementContext) WORK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWORK, 0) + return s.GetToken(StarRocksSQLParserWORK, 0) } func (s *BeginStatementContext) GetRuleContext() antlr.RuleContext { @@ -107091,20 +107091,20 @@ func (s *BeginStatementContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *BeginStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBeginStatement(s) } } func (s *BeginStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBeginStatement(s) } } func (s *BeginStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBeginStatement(s) default: @@ -107112,9 +107112,9 @@ func (s *BeginStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { +func (p *StarRocksSQLParser) BeginStatement() (localctx IBeginStatementContext) { localctx = NewBeginStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 786, DorisSQLParserRULE_beginStatement) + p.EnterRule(localctx, 786, StarRocksSQLParserRULE_beginStatement) var _la int p.SetState(6228) @@ -107124,11 +107124,11 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserSTART: + case StarRocksSQLParserSTART: p.EnterOuterAlt(localctx, 1) { p.SetState(6217) - p.Match(DorisSQLParserSTART) + p.Match(StarRocksSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107136,7 +107136,7 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } { p.SetState(6218) - p.Match(DorisSQLParserTRANSACTION) + p.Match(StarRocksSQLParserTRANSACTION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107149,10 +107149,10 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(6219) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107160,7 +107160,7 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } { p.SetState(6220) - p.Match(DorisSQLParserCONSISTENT) + p.Match(StarRocksSQLParserCONSISTENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107168,7 +107168,7 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } { p.SetState(6221) - p.Match(DorisSQLParserSNAPSHOT) + p.Match(StarRocksSQLParserSNAPSHOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107177,11 +107177,11 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } - case DorisSQLParserBEGIN: + case StarRocksSQLParserBEGIN: p.EnterOuterAlt(localctx, 2) { p.SetState(6224) - p.Match(DorisSQLParserBEGIN) + p.Match(StarRocksSQLParserBEGIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107194,10 +107194,10 @@ func (p *DorisSQLParser) BeginStatement() (localctx IBeginStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWORK { + if _la == StarRocksSQLParserWORK { { p.SetState(6225) - p.Match(DorisSQLParserWORK) + p.Match(StarRocksSQLParserWORK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107252,13 +107252,13 @@ type CommitStatementContext struct { func NewEmptyCommitStatementContext() *CommitStatementContext { var p = new(CommitStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_commitStatement + p.RuleIndex = StarRocksSQLParserRULE_commitStatement return p } func InitEmptyCommitStatementContext(p *CommitStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_commitStatement + p.RuleIndex = StarRocksSQLParserRULE_commitStatement } func (*CommitStatementContext) IsCommitStatementContext() {} @@ -107269,7 +107269,7 @@ func NewCommitStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_commitStatement + p.RuleIndex = StarRocksSQLParserRULE_commitStatement return p } @@ -107277,31 +107277,31 @@ func NewCommitStatementContext(parser antlr.Parser, parent antlr.ParserRuleConte func (s *CommitStatementContext) GetParser() antlr.Parser { return s.parser } func (s *CommitStatementContext) COMMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMIT, 0) + return s.GetToken(StarRocksSQLParserCOMMIT, 0) } func (s *CommitStatementContext) WORK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWORK, 0) + return s.GetToken(StarRocksSQLParserWORK, 0) } func (s *CommitStatementContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *CommitStatementContext) CHAIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAIN, 0) + return s.GetToken(StarRocksSQLParserCHAIN, 0) } func (s *CommitStatementContext) RELEASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRELEASE, 0) + return s.GetToken(StarRocksSQLParserRELEASE, 0) } func (s *CommitStatementContext) AllNO() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserNO) + return s.GetTokens(StarRocksSQLParserNO) } func (s *CommitStatementContext) NO(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserNO, i) + return s.GetToken(StarRocksSQLParserNO, i) } func (s *CommitStatementContext) GetRuleContext() antlr.RuleContext { @@ -107313,20 +107313,20 @@ func (s *CommitStatementContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *CommitStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCommitStatement(s) } } func (s *CommitStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCommitStatement(s) } } func (s *CommitStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCommitStatement(s) default: @@ -107334,15 +107334,15 @@ func (s *CommitStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { +func (p *StarRocksSQLParser) CommitStatement() (localctx ICommitStatementContext) { localctx = NewCommitStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 788, DorisSQLParserRULE_commitStatement) + p.EnterRule(localctx, 788, StarRocksSQLParserRULE_commitStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6230) - p.Match(DorisSQLParserCOMMIT) + p.Match(StarRocksSQLParserCOMMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107355,10 +107355,10 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWORK { + if _la == StarRocksSQLParserWORK { { p.SetState(6231) - p.Match(DorisSQLParserWORK) + p.Match(StarRocksSQLParserWORK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107373,10 +107373,10 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAND { + if _la == StarRocksSQLParserAND { { p.SetState(6234) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107389,10 +107389,10 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNO { + if _la == StarRocksSQLParserNO { { p.SetState(6235) - p.Match(DorisSQLParserNO) + p.Match(StarRocksSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107402,7 +107402,7 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } { p.SetState(6238) - p.Match(DorisSQLParserCHAIN) + p.Match(StarRocksSQLParserCHAIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107417,7 +107417,7 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNO || _la == DorisSQLParserRELEASE { + if _la == StarRocksSQLParserNO || _la == StarRocksSQLParserRELEASE { p.SetState(6242) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -107425,10 +107425,10 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNO { + if _la == StarRocksSQLParserNO { { p.SetState(6241) - p.Match(DorisSQLParserNO) + p.Match(StarRocksSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107438,7 +107438,7 @@ func (p *DorisSQLParser) CommitStatement() (localctx ICommitStatementContext) { } { p.SetState(6244) - p.Match(DorisSQLParserRELEASE) + p.Match(StarRocksSQLParserRELEASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107488,13 +107488,13 @@ type RollbackStatementContext struct { func NewEmptyRollbackStatementContext() *RollbackStatementContext { var p = new(RollbackStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollbackStatement + p.RuleIndex = StarRocksSQLParserRULE_rollbackStatement return p } func InitEmptyRollbackStatementContext(p *RollbackStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rollbackStatement + p.RuleIndex = StarRocksSQLParserRULE_rollbackStatement } func (*RollbackStatementContext) IsRollbackStatementContext() {} @@ -107505,7 +107505,7 @@ func NewRollbackStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rollbackStatement + p.RuleIndex = StarRocksSQLParserRULE_rollbackStatement return p } @@ -107513,31 +107513,31 @@ func NewRollbackStatementContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *RollbackStatementContext) GetParser() antlr.Parser { return s.parser } func (s *RollbackStatementContext) ROLLBACK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLBACK, 0) + return s.GetToken(StarRocksSQLParserROLLBACK, 0) } func (s *RollbackStatementContext) WORK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWORK, 0) + return s.GetToken(StarRocksSQLParserWORK, 0) } func (s *RollbackStatementContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *RollbackStatementContext) CHAIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAIN, 0) + return s.GetToken(StarRocksSQLParserCHAIN, 0) } func (s *RollbackStatementContext) RELEASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRELEASE, 0) + return s.GetToken(StarRocksSQLParserRELEASE, 0) } func (s *RollbackStatementContext) AllNO() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserNO) + return s.GetTokens(StarRocksSQLParserNO) } func (s *RollbackStatementContext) NO(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserNO, i) + return s.GetToken(StarRocksSQLParserNO, i) } func (s *RollbackStatementContext) GetRuleContext() antlr.RuleContext { @@ -107549,20 +107549,20 @@ func (s *RollbackStatementContext) ToStringTree(ruleNames []string, recog antlr. } func (s *RollbackStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRollbackStatement(s) } } func (s *RollbackStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRollbackStatement(s) } } func (s *RollbackStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRollbackStatement(s) default: @@ -107570,15 +107570,15 @@ func (s *RollbackStatementContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext) { +func (p *StarRocksSQLParser) RollbackStatement() (localctx IRollbackStatementContext) { localctx = NewRollbackStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 790, DorisSQLParserRULE_rollbackStatement) + p.EnterRule(localctx, 790, StarRocksSQLParserRULE_rollbackStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6247) - p.Match(DorisSQLParserROLLBACK) + p.Match(StarRocksSQLParserROLLBACK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107591,10 +107591,10 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWORK { + if _la == StarRocksSQLParserWORK { { p.SetState(6248) - p.Match(DorisSQLParserWORK) + p.Match(StarRocksSQLParserWORK) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107609,10 +107609,10 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAND { + if _la == StarRocksSQLParserAND { { p.SetState(6251) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107625,10 +107625,10 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNO { + if _la == StarRocksSQLParserNO { { p.SetState(6252) - p.Match(DorisSQLParserNO) + p.Match(StarRocksSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107638,7 +107638,7 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } { p.SetState(6255) - p.Match(DorisSQLParserCHAIN) + p.Match(StarRocksSQLParserCHAIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107653,7 +107653,7 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNO || _la == DorisSQLParserRELEASE { + if _la == StarRocksSQLParserNO || _la == StarRocksSQLParserRELEASE { p.SetState(6259) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -107661,10 +107661,10 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNO { + if _la == StarRocksSQLParserNO { { p.SetState(6258) - p.Match(DorisSQLParserNO) + p.Match(StarRocksSQLParserNO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107674,7 +107674,7 @@ func (p *DorisSQLParser) RollbackStatement() (localctx IRollbackStatementContext } { p.SetState(6261) - p.Match(DorisSQLParserRELEASE) + p.Match(StarRocksSQLParserRELEASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107720,13 +107720,13 @@ type TranslateStatementContext struct { func NewEmptyTranslateStatementContext() *TranslateStatementContext { var p = new(TranslateStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_translateStatement + p.RuleIndex = StarRocksSQLParserRULE_translateStatement return p } func InitEmptyTranslateStatementContext(p *TranslateStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_translateStatement + p.RuleIndex = StarRocksSQLParserRULE_translateStatement } func (*TranslateStatementContext) IsTranslateStatementContext() {} @@ -107737,7 +107737,7 @@ func NewTranslateStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_translateStatement + p.RuleIndex = StarRocksSQLParserRULE_translateStatement return p } @@ -107745,7 +107745,7 @@ func NewTranslateStatementContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *TranslateStatementContext) GetParser() antlr.Parser { return s.parser } func (s *TranslateStatementContext) TRANSLATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSLATE, 0) + return s.GetToken(StarRocksSQLParserTRANSLATE, 0) } func (s *TranslateStatementContext) Dialect() IDialectContext { @@ -107789,20 +107789,20 @@ func (s *TranslateStatementContext) ToStringTree(ruleNames []string, recog antlr } func (s *TranslateStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTranslateStatement(s) } } func (s *TranslateStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTranslateStatement(s) } } func (s *TranslateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTranslateStatement(s) default: @@ -107810,13 +107810,13 @@ func (s *TranslateStatementContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) TranslateStatement() (localctx ITranslateStatementContext) { +func (p *StarRocksSQLParser) TranslateStatement() (localctx ITranslateStatementContext) { localctx = NewTranslateStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 792, DorisSQLParserRULE_translateStatement) + p.EnterRule(localctx, 792, StarRocksSQLParserRULE_translateStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6264) - p.Match(DorisSQLParserTRANSLATE) + p.Match(StarRocksSQLParserTRANSLATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -107866,13 +107866,13 @@ type DialectContext struct { func NewEmptyDialectContext() *DialectContext { var p = new(DialectContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dialect + p.RuleIndex = StarRocksSQLParserRULE_dialect return p } func InitEmptyDialectContext(p *DialectContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_dialect + p.RuleIndex = StarRocksSQLParserRULE_dialect } func (*DialectContext) IsDialectContext() {} @@ -107883,7 +107883,7 @@ func NewDialectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_dialect + p.RuleIndex = StarRocksSQLParserRULE_dialect return p } @@ -107915,20 +107915,20 @@ func (s *DialectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *DialectContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDialect(s) } } func (s *DialectContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDialect(s) } } func (s *DialectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDialect(s) default: @@ -107936,9 +107936,9 @@ func (s *DialectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Dialect() (localctx IDialectContext) { +func (p *StarRocksSQLParser) Dialect() (localctx IDialectContext) { localctx = NewDialectContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 794, DorisSQLParserRULE_dialect) + p.EnterRule(localctx, 794, StarRocksSQLParserRULE_dialect) p.EnterOuterAlt(localctx, 1) { p.SetState(6268) @@ -107976,13 +107976,13 @@ type TranslateSQLContext struct { func NewEmptyTranslateSQLContext() *TranslateSQLContext { var p = new(TranslateSQLContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_translateSQL + p.RuleIndex = StarRocksSQLParserRULE_translateSQL return p } func InitEmptyTranslateSQLContext(p *TranslateSQLContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_translateSQL + p.RuleIndex = StarRocksSQLParserRULE_translateSQL } func (*TranslateSQLContext) IsTranslateSQLContext() {} @@ -107993,7 +107993,7 @@ func NewTranslateSQLContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_translateSQL + p.RuleIndex = StarRocksSQLParserRULE_translateSQL return p } @@ -108008,20 +108008,20 @@ func (s *TranslateSQLContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *TranslateSQLContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTranslateSQL(s) } } func (s *TranslateSQLContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTranslateSQL(s) } } func (s *TranslateSQLContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTranslateSQL(s) default: @@ -108029,9 +108029,9 @@ func (s *TranslateSQLContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) TranslateSQL() (localctx ITranslateSQLContext) { +func (p *StarRocksSQLParser) TranslateSQL() (localctx ITranslateSQLContext) { localctx = NewTranslateSQLContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 796, DorisSQLParserRULE_translateSQL) + p.EnterRule(localctx, 796, StarRocksSQLParserRULE_translateSQL) var _alt int p.EnterOuterAlt(localctx, 1) @@ -108098,13 +108098,13 @@ type QueryStatementContext struct { func NewEmptyQueryStatementContext() *QueryStatementContext { var p = new(QueryStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryStatement + p.RuleIndex = StarRocksSQLParserRULE_queryStatement return p } func InitEmptyQueryStatementContext(p *QueryStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryStatement + p.RuleIndex = StarRocksSQLParserRULE_queryStatement } func (*QueryStatementContext) IsQueryStatementContext() {} @@ -108115,7 +108115,7 @@ func NewQueryStatementContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_queryStatement + p.RuleIndex = StarRocksSQLParserRULE_queryStatement return p } @@ -108195,20 +108195,20 @@ func (s *QueryStatementContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *QueryStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQueryStatement(s) } } func (s *QueryStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQueryStatement(s) } } func (s *QueryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQueryStatement(s) default: @@ -108216,9 +108216,9 @@ func (s *QueryStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) QueryStatement() (localctx IQueryStatementContext) { +func (p *StarRocksSQLParser) QueryStatement() (localctx IQueryStatementContext) { localctx = NewQueryStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 798, DorisSQLParserRULE_queryStatement) + p.EnterRule(localctx, 798, StarRocksSQLParserRULE_queryStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -108228,19 +108228,19 @@ func (p *DorisSQLParser) QueryStatement() (localctx IQueryStatementContext) { goto errorExit } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDESC, DorisSQLParserDESCRIBE, DorisSQLParserEXPLAIN: + case StarRocksSQLParserDESC, StarRocksSQLParserDESCRIBE, StarRocksSQLParserEXPLAIN: { p.SetState(6275) p.ExplainDesc() } - case DorisSQLParserTRACE: + case StarRocksSQLParserTRACE: { p.SetState(6276) p.OptimizerTrace() } - case DorisSQLParserT__1, DorisSQLParserSELECT, DorisSQLParserWITH: + case StarRocksSQLParserT__1, StarRocksSQLParserSELECT, StarRocksSQLParserWITH: default: } @@ -108255,7 +108255,7 @@ func (p *DorisSQLParser) QueryStatement() (localctx IQueryStatementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTO { + if _la == StarRocksSQLParserINTO { { p.SetState(6280) p.Outfile() @@ -108299,13 +108299,13 @@ type QueryRelationContext struct { func NewEmptyQueryRelationContext() *QueryRelationContext { var p = new(QueryRelationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryRelation + p.RuleIndex = StarRocksSQLParserRULE_queryRelation return p } func InitEmptyQueryRelationContext(p *QueryRelationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryRelation + p.RuleIndex = StarRocksSQLParserRULE_queryRelation } func (*QueryRelationContext) IsQueryRelationContext() {} @@ -108316,7 +108316,7 @@ func NewQueryRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_queryRelation + p.RuleIndex = StarRocksSQLParserRULE_queryRelation return p } @@ -108364,20 +108364,20 @@ func (s *QueryRelationContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *QueryRelationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQueryRelation(s) } } func (s *QueryRelationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQueryRelation(s) } } func (s *QueryRelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQueryRelation(s) default: @@ -108385,9 +108385,9 @@ func (s *QueryRelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) QueryRelation() (localctx IQueryRelationContext) { +func (p *StarRocksSQLParser) QueryRelation() (localctx IQueryRelationContext) { localctx = NewQueryRelationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 800, DorisSQLParserRULE_queryRelation) + p.EnterRule(localctx, 800, StarRocksSQLParserRULE_queryRelation) var _la int p.EnterOuterAlt(localctx, 1) @@ -108398,7 +108398,7 @@ func (p *DorisSQLParser) QueryRelation() (localctx IQueryRelationContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserWITH { + if _la == StarRocksSQLParserWITH { { p.SetState(6283) p.WithClause() @@ -108447,13 +108447,13 @@ type WithClauseContext struct { func NewEmptyWithClauseContext() *WithClauseContext { var p = new(WithClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_withClause + p.RuleIndex = StarRocksSQLParserRULE_withClause return p } func InitEmptyWithClauseContext(p *WithClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_withClause + p.RuleIndex = StarRocksSQLParserRULE_withClause } func (*WithClauseContext) IsWithClauseContext() {} @@ -108464,7 +108464,7 @@ func NewWithClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_withClause + p.RuleIndex = StarRocksSQLParserRULE_withClause return p } @@ -108472,7 +108472,7 @@ func NewWithClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *WithClauseContext) GetParser() antlr.Parser { return s.parser } func (s *WithClauseContext) WITH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWITH, 0) + return s.GetToken(StarRocksSQLParserWITH, 0) } func (s *WithClauseContext) AllCommonTableExpression() []ICommonTableExpressionContext { @@ -108525,20 +108525,20 @@ func (s *WithClauseContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *WithClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterWithClause(s) } } func (s *WithClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitWithClause(s) } } func (s *WithClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitWithClause(s) default: @@ -108546,15 +108546,15 @@ func (s *WithClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) WithClause() (localctx IWithClauseContext) { +func (p *StarRocksSQLParser) WithClause() (localctx IWithClauseContext) { localctx = NewWithClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 802, DorisSQLParserRULE_withClause) + p.EnterRule(localctx, 802, StarRocksSQLParserRULE_withClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6288) - p.Match(DorisSQLParserWITH) + p.Match(StarRocksSQLParserWITH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -108571,10 +108571,10 @@ func (p *DorisSQLParser) WithClause() (localctx IWithClauseContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6290) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -108633,13 +108633,13 @@ type QueryNoWithContext struct { func NewEmptyQueryNoWithContext() *QueryNoWithContext { var p = new(QueryNoWithContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryNoWith + p.RuleIndex = StarRocksSQLParserRULE_queryNoWith return p } func InitEmptyQueryNoWithContext(p *QueryNoWithContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryNoWith + p.RuleIndex = StarRocksSQLParserRULE_queryNoWith } func (*QueryNoWithContext) IsQueryNoWithContext() {} @@ -108650,7 +108650,7 @@ func NewQueryNoWithContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_queryNoWith + p.RuleIndex = StarRocksSQLParserRULE_queryNoWith return p } @@ -108674,11 +108674,11 @@ func (s *QueryNoWithContext) QueryPrimary() IQueryPrimaryContext { } func (s *QueryNoWithContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *QueryNoWithContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *QueryNoWithContext) AllSortItem() []ISortItemContext { @@ -108747,20 +108747,20 @@ func (s *QueryNoWithContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *QueryNoWithContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQueryNoWith(s) } } func (s *QueryNoWithContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQueryNoWith(s) } } func (s *QueryNoWithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQueryNoWith(s) default: @@ -108768,9 +108768,9 @@ func (s *QueryNoWithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) QueryNoWith() (localctx IQueryNoWithContext) { +func (p *StarRocksSQLParser) QueryNoWith() (localctx IQueryNoWithContext) { localctx = NewQueryNoWithContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 804, DorisSQLParserRULE_queryNoWith) + p.EnterRule(localctx, 804, StarRocksSQLParserRULE_queryNoWith) var _la int p.EnterOuterAlt(localctx, 1) @@ -108785,10 +108785,10 @@ func (p *DorisSQLParser) QueryNoWith() (localctx IQueryNoWithContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(6298) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -108796,7 +108796,7 @@ func (p *DorisSQLParser) QueryNoWith() (localctx IQueryNoWithContext) { } { p.SetState(6299) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -108813,10 +108813,10 @@ func (p *DorisSQLParser) QueryNoWith() (localctx IQueryNoWithContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6301) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -108843,7 +108843,7 @@ func (p *DorisSQLParser) QueryNoWith() (localctx IQueryNoWithContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIMIT { + if _la == StarRocksSQLParserLIMIT { { p.SetState(6310) p.LimitElement() @@ -108903,13 +108903,13 @@ type QueryPeriodContext struct { func NewEmptyQueryPeriodContext() *QueryPeriodContext { var p = new(QueryPeriodContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryPeriod + p.RuleIndex = StarRocksSQLParserRULE_queryPeriod return p } func InitEmptyQueryPeriodContext(p *QueryPeriodContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryPeriod + p.RuleIndex = StarRocksSQLParserRULE_queryPeriod } func (*QueryPeriodContext) IsQueryPeriodContext() {} @@ -108920,7 +108920,7 @@ func NewQueryPeriodContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_queryPeriod + p.RuleIndex = StarRocksSQLParserRULE_queryPeriod return p } @@ -108948,7 +108948,7 @@ func (s *QueryPeriodContext) PeriodType() IPeriodTypeContext { } func (s *QueryPeriodContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBETWEEN, 0) + return s.GetToken(StarRocksSQLParserBETWEEN, 0) } func (s *QueryPeriodContext) AllExpression() []IExpressionContext { @@ -108993,31 +108993,31 @@ func (s *QueryPeriodContext) Expression(i int) IExpressionContext { } func (s *QueryPeriodContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *QueryPeriodContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *QueryPeriodContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *QueryPeriodContext) TO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTO, 0) + return s.GetToken(StarRocksSQLParserTO, 0) } func (s *QueryPeriodContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *QueryPeriodContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *QueryPeriodContext) OF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOF, 0) + return s.GetToken(StarRocksSQLParserOF, 0) } func (s *QueryPeriodContext) GetRuleContext() antlr.RuleContext { @@ -109029,20 +109029,20 @@ func (s *QueryPeriodContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *QueryPeriodContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQueryPeriod(s) } } func (s *QueryPeriodContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQueryPeriod(s) } } func (s *QueryPeriodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQueryPeriod(s) default: @@ -109050,9 +109050,9 @@ func (s *QueryPeriodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { +func (p *StarRocksSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { localctx = NewQueryPeriodContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 806, DorisSQLParserRULE_queryPeriod) + p.EnterRule(localctx, 806, StarRocksSQLParserRULE_queryPeriod) var _la int p.SetState(6345) @@ -109071,10 +109071,10 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(6313) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109088,7 +109088,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6317) - p.Match(DorisSQLParserBETWEEN) + p.Match(StarRocksSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109100,7 +109100,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6319) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109120,10 +109120,10 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(6322) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109137,7 +109137,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6326) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109149,7 +109149,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6328) - p.Match(DorisSQLParserTO) + p.Match(StarRocksSQLParserTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109169,10 +109169,10 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(6331) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109186,7 +109186,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6335) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109202,10 +109202,10 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(6337) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109219,7 +109219,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6341) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109227,7 +109227,7 @@ func (p *DorisSQLParser) QueryPeriod() (localctx IQueryPeriodContext) { } { p.SetState(6342) - p.Match(DorisSQLParserOF) + p.Match(StarRocksSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109282,13 +109282,13 @@ type PeriodTypeContext struct { func NewEmptyPeriodTypeContext() *PeriodTypeContext { var p = new(PeriodTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_periodType + p.RuleIndex = StarRocksSQLParserRULE_periodType return p } func InitEmptyPeriodTypeContext(p *PeriodTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_periodType + p.RuleIndex = StarRocksSQLParserRULE_periodType } func (*PeriodTypeContext) IsPeriodTypeContext() {} @@ -109299,7 +109299,7 @@ func NewPeriodTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_periodType + p.RuleIndex = StarRocksSQLParserRULE_periodType return p } @@ -109307,15 +109307,15 @@ func NewPeriodTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *PeriodTypeContext) GetParser() antlr.Parser { return s.parser } func (s *PeriodTypeContext) SYSTEM_TIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYSTEM_TIME, 0) + return s.GetToken(StarRocksSQLParserSYSTEM_TIME, 0) } func (s *PeriodTypeContext) TIMESTAMP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMESTAMP, 0) + return s.GetToken(StarRocksSQLParserTIMESTAMP, 0) } func (s *PeriodTypeContext) VERSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERSION, 0) + return s.GetToken(StarRocksSQLParserVERSION, 0) } func (s *PeriodTypeContext) GetRuleContext() antlr.RuleContext { @@ -109327,20 +109327,20 @@ func (s *PeriodTypeContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *PeriodTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPeriodType(s) } } func (s *PeriodTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPeriodType(s) } } func (s *PeriodTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPeriodType(s) default: @@ -109348,9 +109348,9 @@ func (s *PeriodTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) PeriodType() (localctx IPeriodTypeContext) { +func (p *StarRocksSQLParser) PeriodType() (localctx IPeriodTypeContext) { localctx = NewPeriodTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 808, DorisSQLParserRULE_periodType) + p.EnterRule(localctx, 808, StarRocksSQLParserRULE_periodType) var _la int p.EnterOuterAlt(localctx, 1) @@ -109397,13 +109397,13 @@ type QueryPrimaryContext struct { func NewEmptyQueryPrimaryContext() *QueryPrimaryContext { var p = new(QueryPrimaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryPrimary + p.RuleIndex = StarRocksSQLParserRULE_queryPrimary return p } func InitEmptyQueryPrimaryContext(p *QueryPrimaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_queryPrimary + p.RuleIndex = StarRocksSQLParserRULE_queryPrimary } func (*QueryPrimaryContext) IsQueryPrimaryContext() {} @@ -109414,7 +109414,7 @@ func NewQueryPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_queryPrimary + p.RuleIndex = StarRocksSQLParserRULE_queryPrimary return p } @@ -109468,20 +109468,20 @@ func (s *QueryWithParenthesesContext) Subquery() ISubqueryContext { } func (s *QueryWithParenthesesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQueryWithParentheses(s) } } func (s *QueryWithParenthesesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQueryWithParentheses(s) } } func (s *QueryWithParenthesesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQueryWithParentheses(s) default: @@ -109564,7 +109564,7 @@ func (s *SetOperationContext) QueryPrimary(i int) IQueryPrimaryContext { } func (s *SetOperationContext) INTERSECT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTERSECT, 0) + return s.GetToken(StarRocksSQLParserINTERSECT, 0) } func (s *SetOperationContext) SetQuantifier() ISetQuantifierContext { @@ -109584,32 +109584,32 @@ func (s *SetOperationContext) SetQuantifier() ISetQuantifierContext { } func (s *SetOperationContext) UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNION, 0) + return s.GetToken(StarRocksSQLParserUNION, 0) } func (s *SetOperationContext) EXCEPT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXCEPT, 0) + return s.GetToken(StarRocksSQLParserEXCEPT, 0) } func (s *SetOperationContext) MINUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUS, 0) + return s.GetToken(StarRocksSQLParserMINUS, 0) } func (s *SetOperationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetOperation(s) } } func (s *SetOperationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetOperation(s) } } func (s *SetOperationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetOperation(s) default: @@ -109652,20 +109652,20 @@ func (s *QueryPrimaryDefaultContext) QuerySpecification() IQuerySpecificationCon } func (s *QueryPrimaryDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQueryPrimaryDefault(s) } } func (s *QueryPrimaryDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQueryPrimaryDefault(s) } } func (s *QueryPrimaryDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQueryPrimaryDefault(s) default: @@ -109673,11 +109673,11 @@ func (s *QueryPrimaryDefaultContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) QueryPrimary() (localctx IQueryPrimaryContext) { +func (p *StarRocksSQLParser) QueryPrimary() (localctx IQueryPrimaryContext) { return p.queryPrimary(0) } -func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { +func (p *StarRocksSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() @@ -109685,7 +109685,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { var _prevctx IQueryPrimaryContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 810 - p.EnterRecursionRule(localctx, 810, DorisSQLParserRULE_queryPrimary, _p) + p.EnterRecursionRule(localctx, 810, StarRocksSQLParserRULE_queryPrimary, _p) var _la int var _alt int @@ -109698,7 +109698,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserSELECT: + case StarRocksSQLParserSELECT: localctx = NewQueryPrimaryDefaultContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx @@ -109708,7 +109708,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { p.QuerySpecification() } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: localctx = NewQueryWithParenthesesContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx @@ -109748,7 +109748,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { localctx = NewSetOperationContext(p, NewQueryPrimaryContext(p, _parentctx, _parentState)) localctx.(*SetOperationContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_queryPrimary) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_queryPrimary) p.SetState(6354) if !(p.Precpred(p.GetParserRuleContext(), 2)) { @@ -109758,7 +109758,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { { p.SetState(6355) - var _m = p.Match(DorisSQLParserINTERSECT) + var _m = p.Match(StarRocksSQLParserINTERSECT) localctx.(*SetOperationContext).operator = _m if p.HasError() { @@ -109773,7 +109773,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(6356) p.SetQuantifier() @@ -109792,7 +109792,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { localctx = NewSetOperationContext(p, NewQueryPrimaryContext(p, _parentctx, _parentState)) localctx.(*SetOperationContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_queryPrimary) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_queryPrimary) p.SetState(6360) if !(p.Precpred(p.GetParserRuleContext(), 1)) { @@ -109808,7 +109808,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserEXCEPT || _la == DorisSQLParserMINUS || _la == DorisSQLParserUNION) { + if !(_la == StarRocksSQLParserEXCEPT || _la == StarRocksSQLParserMINUS || _la == StarRocksSQLParserUNION) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*SetOperationContext).operator = _ri @@ -109824,7 +109824,7 @@ func (p *DorisSQLParser) queryPrimary(_p int) (localctx IQueryPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(6362) p.SetQuantifier() @@ -109890,13 +109890,13 @@ type SubqueryContext struct { func NewEmptySubqueryContext() *SubqueryContext { var p = new(SubqueryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subquery + p.RuleIndex = StarRocksSQLParserRULE_subquery return p } func InitEmptySubqueryContext(p *SubqueryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subquery + p.RuleIndex = StarRocksSQLParserRULE_subquery } func (*SubqueryContext) IsSubqueryContext() {} @@ -109907,7 +109907,7 @@ func NewSubqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_subquery + p.RuleIndex = StarRocksSQLParserRULE_subquery return p } @@ -109939,20 +109939,20 @@ func (s *SubqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *SubqueryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubquery(s) } } func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubquery(s) } } func (s *SubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubquery(s) default: @@ -109960,13 +109960,13 @@ func (s *SubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Subquery() (localctx ISubqueryContext) { +func (p *StarRocksSQLParser) Subquery() (localctx ISubqueryContext) { localctx = NewSubqueryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 812, DorisSQLParserRULE_subquery) + p.EnterRule(localctx, 812, StarRocksSQLParserRULE_subquery) p.EnterOuterAlt(localctx, 1) { p.SetState(6371) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -109978,7 +109978,7 @@ func (p *DorisSQLParser) Subquery() (localctx ISubqueryContext) { } { p.SetState(6373) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110020,13 +110020,13 @@ type RowConstructorContext struct { func NewEmptyRowConstructorContext() *RowConstructorContext { var p = new(RowConstructorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rowConstructor + p.RuleIndex = StarRocksSQLParserRULE_rowConstructor return p } func InitEmptyRowConstructorContext(p *RowConstructorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rowConstructor + p.RuleIndex = StarRocksSQLParserRULE_rowConstructor } func (*RowConstructorContext) IsRowConstructorContext() {} @@ -110037,7 +110037,7 @@ func NewRowConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rowConstructor + p.RuleIndex = StarRocksSQLParserRULE_rowConstructor return p } @@ -110069,20 +110069,20 @@ func (s *RowConstructorContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *RowConstructorContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRowConstructor(s) } } func (s *RowConstructorContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRowConstructor(s) } } func (s *RowConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRowConstructor(s) default: @@ -110090,13 +110090,13 @@ func (s *RowConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) RowConstructor() (localctx IRowConstructorContext) { +func (p *StarRocksSQLParser) RowConstructor() (localctx IRowConstructorContext) { localctx = NewRowConstructorContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 814, DorisSQLParserRULE_rowConstructor) + p.EnterRule(localctx, 814, StarRocksSQLParserRULE_rowConstructor) p.EnterOuterAlt(localctx, 1) { p.SetState(6375) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110108,7 +110108,7 @@ func (p *DorisSQLParser) RowConstructor() (localctx IRowConstructorContext) { } { p.SetState(6377) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110169,13 +110169,13 @@ type SortItemContext struct { func NewEmptySortItemContext() *SortItemContext { var p = new(SortItemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_sortItem + p.RuleIndex = StarRocksSQLParserRULE_sortItem return p } func InitEmptySortItemContext(p *SortItemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_sortItem + p.RuleIndex = StarRocksSQLParserRULE_sortItem } func (*SortItemContext) IsSortItemContext() {} @@ -110186,7 +110186,7 @@ func NewSortItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_sortItem + p.RuleIndex = StarRocksSQLParserRULE_sortItem return p } @@ -110218,23 +110218,23 @@ func (s *SortItemContext) Expression() IExpressionContext { } func (s *SortItemContext) NULLS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULLS, 0) + return s.GetToken(StarRocksSQLParserNULLS, 0) } func (s *SortItemContext) ASC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASC, 0) + return s.GetToken(StarRocksSQLParserASC, 0) } func (s *SortItemContext) DESC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESC, 0) + return s.GetToken(StarRocksSQLParserDESC, 0) } func (s *SortItemContext) FIRST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIRST, 0) + return s.GetToken(StarRocksSQLParserFIRST, 0) } func (s *SortItemContext) LAST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLAST, 0) + return s.GetToken(StarRocksSQLParserLAST, 0) } func (s *SortItemContext) GetRuleContext() antlr.RuleContext { @@ -110246,20 +110246,20 @@ func (s *SortItemContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *SortItemContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSortItem(s) } } func (s *SortItemContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSortItem(s) } } func (s *SortItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSortItem(s) default: @@ -110267,9 +110267,9 @@ func (s *SortItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) SortItem() (localctx ISortItemContext) { +func (p *StarRocksSQLParser) SortItem() (localctx ISortItemContext) { localctx = NewSortItemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 816, DorisSQLParserRULE_sortItem) + p.EnterRule(localctx, 816, StarRocksSQLParserRULE_sortItem) var _la int p.EnterOuterAlt(localctx, 1) @@ -110284,7 +110284,7 @@ func (p *DorisSQLParser) SortItem() (localctx ISortItemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserASC || _la == DorisSQLParserDESC { + if _la == StarRocksSQLParserASC || _la == StarRocksSQLParserDESC { { p.SetState(6380) @@ -110294,7 +110294,7 @@ func (p *DorisSQLParser) SortItem() (localctx ISortItemContext) { _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserASC || _la == DorisSQLParserDESC) { + if !(_la == StarRocksSQLParserASC || _la == StarRocksSQLParserDESC) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*SortItemContext).ordering = _ri @@ -110312,10 +110312,10 @@ func (p *DorisSQLParser) SortItem() (localctx ISortItemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNULLS { + if _la == StarRocksSQLParserNULLS { { p.SetState(6383) - p.Match(DorisSQLParserNULLS) + p.Match(StarRocksSQLParserNULLS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110330,7 +110330,7 @@ func (p *DorisSQLParser) SortItem() (localctx ISortItemContext) { _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFIRST || _la == DorisSQLParserLAST) { + if !(_la == StarRocksSQLParserFIRST || _la == StarRocksSQLParserLAST) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*SortItemContext).nullOrdering = _ri @@ -110379,13 +110379,13 @@ type LimitConstExprContext struct { func NewEmptyLimitConstExprContext() *LimitConstExprContext { var p = new(LimitConstExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_limitConstExpr + p.RuleIndex = StarRocksSQLParserRULE_limitConstExpr return p } func InitEmptyLimitConstExprContext(p *LimitConstExprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_limitConstExpr + p.RuleIndex = StarRocksSQLParserRULE_limitConstExpr } func (*LimitConstExprContext) IsLimitConstExprContext() {} @@ -110396,7 +110396,7 @@ func NewLimitConstExprContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_limitConstExpr + p.RuleIndex = StarRocksSQLParserRULE_limitConstExpr return p } @@ -110404,11 +110404,11 @@ func NewLimitConstExprContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *LimitConstExprContext) GetParser() antlr.Parser { return s.parser } func (s *LimitConstExprContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *LimitConstExprContext) PARAMETER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARAMETER, 0) + return s.GetToken(StarRocksSQLParserPARAMETER, 0) } func (s *LimitConstExprContext) UserVariable() IUserVariableContext { @@ -110436,20 +110436,20 @@ func (s *LimitConstExprContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *LimitConstExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLimitConstExpr(s) } } func (s *LimitConstExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLimitConstExpr(s) } } func (s *LimitConstExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLimitConstExpr(s) default: @@ -110457,9 +110457,9 @@ func (s *LimitConstExprContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) LimitConstExpr() (localctx ILimitConstExprContext) { +func (p *StarRocksSQLParser) LimitConstExpr() (localctx ILimitConstExprContext) { localctx = NewLimitConstExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 818, DorisSQLParserRULE_limitConstExpr) + p.EnterRule(localctx, 818, StarRocksSQLParserRULE_limitConstExpr) p.SetState(6390) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -110467,29 +110467,29 @@ func (p *DorisSQLParser) LimitConstExpr() (localctx ILimitConstExprContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserINTEGER_VALUE: + case StarRocksSQLParserINTEGER_VALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(6387) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserPARAMETER: + case StarRocksSQLParserPARAMETER: p.EnterOuterAlt(localctx, 2) { p.SetState(6388) - p.Match(DorisSQLParserPARAMETER) + p.Match(StarRocksSQLParserPARAMETER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserAT: + case StarRocksSQLParserAT: p.EnterOuterAlt(localctx, 3) { p.SetState(6389) @@ -110553,13 +110553,13 @@ type LimitElementContext struct { func NewEmptyLimitElementContext() *LimitElementContext { var p = new(LimitElementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_limitElement + p.RuleIndex = StarRocksSQLParserRULE_limitElement return p } func InitEmptyLimitElementContext(p *LimitElementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_limitElement + p.RuleIndex = StarRocksSQLParserRULE_limitElement } func (*LimitElementContext) IsLimitElementContext() {} @@ -110570,7 +110570,7 @@ func NewLimitElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_limitElement + p.RuleIndex = StarRocksSQLParserRULE_limitElement return p } @@ -110586,7 +110586,7 @@ func (s *LimitElementContext) SetLimit(v ILimitConstExprContext) { s.limit = v } func (s *LimitElementContext) SetOffset(v ILimitConstExprContext) { s.offset = v } func (s *LimitElementContext) LIMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIMIT, 0) + return s.GetToken(StarRocksSQLParserLIMIT, 0) } func (s *LimitElementContext) AllLimitConstExpr() []ILimitConstExprContext { @@ -110631,7 +110631,7 @@ func (s *LimitElementContext) LimitConstExpr(i int) ILimitConstExprContext { } func (s *LimitElementContext) OFFSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOFFSET, 0) + return s.GetToken(StarRocksSQLParserOFFSET, 0) } func (s *LimitElementContext) GetRuleContext() antlr.RuleContext { @@ -110643,20 +110643,20 @@ func (s *LimitElementContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *LimitElementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLimitElement(s) } } func (s *LimitElementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLimitElement(s) } } func (s *LimitElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLimitElement(s) default: @@ -110664,9 +110664,9 @@ func (s *LimitElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) LimitElement() (localctx ILimitElementContext) { +func (p *StarRocksSQLParser) LimitElement() (localctx ILimitElementContext) { localctx = NewLimitElementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 820, DorisSQLParserRULE_limitElement) + p.EnterRule(localctx, 820, StarRocksSQLParserRULE_limitElement) var _la int p.SetState(6403) @@ -110680,7 +110680,7 @@ func (p *DorisSQLParser) LimitElement() (localctx ILimitElementContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(6392) - p.Match(DorisSQLParserLIMIT) + p.Match(StarRocksSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110700,10 +110700,10 @@ func (p *DorisSQLParser) LimitElement() (localctx ILimitElementContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserOFFSET { + if _la == StarRocksSQLParserOFFSET { { p.SetState(6394) - p.Match(DorisSQLParserOFFSET) + p.Match(StarRocksSQLParserOFFSET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110723,7 +110723,7 @@ func (p *DorisSQLParser) LimitElement() (localctx ILimitElementContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(6398) - p.Match(DorisSQLParserLIMIT) + p.Match(StarRocksSQLParserLIMIT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110738,7 +110738,7 @@ func (p *DorisSQLParser) LimitElement() (localctx ILimitElementContext) { } { p.SetState(6400) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -110833,13 +110833,13 @@ type QuerySpecificationContext struct { func NewEmptyQuerySpecificationContext() *QuerySpecificationContext { var p = new(QuerySpecificationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_querySpecification + p.RuleIndex = StarRocksSQLParserRULE_querySpecification return p } func InitEmptyQuerySpecificationContext(p *QuerySpecificationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_querySpecification + p.RuleIndex = StarRocksSQLParserRULE_querySpecification } func (*QuerySpecificationContext) IsQuerySpecificationContext() {} @@ -110850,7 +110850,7 @@ func NewQuerySpecificationContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_querySpecification + p.RuleIndex = StarRocksSQLParserRULE_querySpecification return p } @@ -110874,7 +110874,7 @@ func (s *QuerySpecificationContext) SetHaving(v IExpressionContext) { s.having = func (s *QuerySpecificationContext) SetQualifyFunction(v ISelectItemContext) { s.qualifyFunction = v } func (s *QuerySpecificationContext) SELECT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSELECT, 0) + return s.GetToken(StarRocksSQLParserSELECT, 0) } func (s *QuerySpecificationContext) AllSelectItem() []ISelectItemContext { @@ -110951,15 +110951,15 @@ func (s *QuerySpecificationContext) SetQuantifier() ISetQuantifierContext { } func (s *QuerySpecificationContext) WHERE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHERE, 0) + return s.GetToken(StarRocksSQLParserWHERE, 0) } func (s *QuerySpecificationContext) GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP, 0) + return s.GetToken(StarRocksSQLParserGROUP, 0) } func (s *QuerySpecificationContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *QuerySpecificationContext) GroupingElement() IGroupingElementContext { @@ -110979,11 +110979,11 @@ func (s *QuerySpecificationContext) GroupingElement() IGroupingElementContext { } func (s *QuerySpecificationContext) HAVING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHAVING, 0) + return s.GetToken(StarRocksSQLParserHAVING, 0) } func (s *QuerySpecificationContext) QUALIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUALIFY, 0) + return s.GetToken(StarRocksSQLParserQUALIFY, 0) } func (s *QuerySpecificationContext) ComparisonOperator() IComparisonOperatorContext { @@ -111044,7 +111044,7 @@ func (s *QuerySpecificationContext) Expression(i int) IExpressionContext { } func (s *QuerySpecificationContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *QuerySpecificationContext) GetRuleContext() antlr.RuleContext { @@ -111056,20 +111056,20 @@ func (s *QuerySpecificationContext) ToStringTree(ruleNames []string, recog antlr } func (s *QuerySpecificationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQuerySpecification(s) } } func (s *QuerySpecificationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQuerySpecification(s) } } func (s *QuerySpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQuerySpecification(s) default: @@ -111077,9 +111077,9 @@ func (s *QuerySpecificationContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationContext) { +func (p *StarRocksSQLParser) QuerySpecification() (localctx IQuerySpecificationContext) { localctx = NewQuerySpecificationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 822, DorisSQLParserRULE_querySpecification) + p.EnterRule(localctx, 822, StarRocksSQLParserRULE_querySpecification) var _la int var _alt int @@ -111087,7 +111087,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte p.EnterOuterAlt(localctx, 1) { p.SetState(6405) - p.Match(DorisSQLParserSELECT) + p.Match(StarRocksSQLParserSELECT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111100,7 +111100,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(6406) p.SetQuantifier() @@ -111124,7 +111124,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte if _alt == 1 { { p.SetState(6410) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111157,7 +111157,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 703, p.GetParserRuleContext()) == 1 { { p.SetState(6418) - p.Match(DorisSQLParserWHERE) + p.Match(StarRocksSQLParserWHERE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111180,7 +111180,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 704, p.GetParserRuleContext()) == 1 { { p.SetState(6422) - p.Match(DorisSQLParserGROUP) + p.Match(StarRocksSQLParserGROUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111188,7 +111188,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte } { p.SetState(6423) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111208,7 +111208,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 705, p.GetParserRuleContext()) == 1 { { p.SetState(6427) - p.Match(DorisSQLParserHAVING) + p.Match(StarRocksSQLParserHAVING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111231,7 +111231,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 706, p.GetParserRuleContext()) == 1 { { p.SetState(6431) - p.Match(DorisSQLParserQUALIFY) + p.Match(StarRocksSQLParserQUALIFY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111251,7 +111251,7 @@ func (p *DorisSQLParser) QuerySpecification() (localctx IQuerySpecificationConte { p.SetState(6434) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*QuerySpecificationContext).limit = _m if p.HasError() { @@ -111295,13 +111295,13 @@ type FromClauseContext struct { func NewEmptyFromClauseContext() *FromClauseContext { var p = new(FromClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_fromClause + p.RuleIndex = StarRocksSQLParserRULE_fromClause return p } func InitEmptyFromClauseContext(p *FromClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_fromClause + p.RuleIndex = StarRocksSQLParserRULE_fromClause } func (*FromClauseContext) IsFromClauseContext() {} @@ -111312,7 +111312,7 @@ func NewFromClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_fromClause + p.RuleIndex = StarRocksSQLParserRULE_fromClause return p } @@ -111350,28 +111350,28 @@ func (s *DualContext) GetRuleContext() antlr.RuleContext { } func (s *DualContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *DualContext) DUAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDUAL, 0) + return s.GetToken(StarRocksSQLParserDUAL, 0) } func (s *DualContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDual(s) } } func (s *DualContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDual(s) } } func (s *DualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDual(s) default: @@ -111398,7 +111398,7 @@ func (s *FromContext) GetRuleContext() antlr.RuleContext { } func (s *FromContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *FromContext) Relations() IRelationsContext { @@ -111434,20 +111434,20 @@ func (s *FromContext) PivotClause() IPivotClauseContext { } func (s *FromContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterFrom(s) } } func (s *FromContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitFrom(s) } } func (s *FromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitFrom(s) default: @@ -111455,9 +111455,9 @@ func (s *FromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) FromClause() (localctx IFromClauseContext) { +func (p *StarRocksSQLParser) FromClause() (localctx IFromClauseContext) { localctx = NewFromClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 824, DorisSQLParserRULE_fromClause) + p.EnterRule(localctx, 824, StarRocksSQLParserRULE_fromClause) p.SetState(6447) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -111474,7 +111474,7 @@ func (p *DorisSQLParser) FromClause() (localctx IFromClauseContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 708, p.GetParserRuleContext()) == 1 { { p.SetState(6438) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111506,7 +111506,7 @@ func (p *DorisSQLParser) FromClause() (localctx IFromClauseContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(6445) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111514,7 +111514,7 @@ func (p *DorisSQLParser) FromClause() (localctx IFromClauseContext) { } { p.SetState(6446) - p.Match(DorisSQLParserDUAL) + p.Match(StarRocksSQLParserDUAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111556,13 +111556,13 @@ type GroupingElementContext struct { func NewEmptyGroupingElementContext() *GroupingElementContext { var p = new(GroupingElementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_groupingElement + p.RuleIndex = StarRocksSQLParserRULE_groupingElement return p } func InitEmptyGroupingElementContext(p *GroupingElementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_groupingElement + p.RuleIndex = StarRocksSQLParserRULE_groupingElement } func (*GroupingElementContext) IsGroupingElementContext() {} @@ -111573,7 +111573,7 @@ func NewGroupingElementContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_groupingElement + p.RuleIndex = StarRocksSQLParserRULE_groupingElement return p } @@ -111611,11 +111611,11 @@ func (s *MultipleGroupingSetsContext) GetRuleContext() antlr.RuleContext { } func (s *MultipleGroupingSetsContext) GROUPING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPING, 0) + return s.GetToken(StarRocksSQLParserGROUPING, 0) } func (s *MultipleGroupingSetsContext) SETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSETS, 0) + return s.GetToken(StarRocksSQLParserSETS, 0) } func (s *MultipleGroupingSetsContext) AllGroupingSet() []IGroupingSetContext { @@ -111660,20 +111660,20 @@ func (s *MultipleGroupingSetsContext) GroupingSet(i int) IGroupingSetContext { } func (s *MultipleGroupingSetsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMultipleGroupingSets(s) } } func (s *MultipleGroupingSetsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMultipleGroupingSets(s) } } func (s *MultipleGroupingSetsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMultipleGroupingSets(s) default: @@ -111716,20 +111716,20 @@ func (s *SingleGroupingSetContext) ExpressionList() IExpressionListContext { } func (s *SingleGroupingSetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSingleGroupingSet(s) } } func (s *SingleGroupingSetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSingleGroupingSet(s) } } func (s *SingleGroupingSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSingleGroupingSet(s) default: @@ -111756,7 +111756,7 @@ func (s *CubeContext) GetRuleContext() antlr.RuleContext { } func (s *CubeContext) CUBE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCUBE, 0) + return s.GetToken(StarRocksSQLParserCUBE, 0) } func (s *CubeContext) ExpressionList() IExpressionListContext { @@ -111776,20 +111776,20 @@ func (s *CubeContext) ExpressionList() IExpressionListContext { } func (s *CubeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCube(s) } } func (s *CubeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCube(s) } } func (s *CubeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCube(s) default: @@ -111816,7 +111816,7 @@ func (s *RollupContext) GetRuleContext() antlr.RuleContext { } func (s *RollupContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *RollupContext) ExpressionList() IExpressionListContext { @@ -111836,20 +111836,20 @@ func (s *RollupContext) ExpressionList() IExpressionListContext { } func (s *RollupContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRollup(s) } } func (s *RollupContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRollup(s) } } func (s *RollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRollup(s) default: @@ -111857,9 +111857,9 @@ func (s *RollupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { +func (p *StarRocksSQLParser) GroupingElement() (localctx IGroupingElementContext) { localctx = NewGroupingElementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 826, DorisSQLParserRULE_groupingElement) + p.EnterRule(localctx, 826, StarRocksSQLParserRULE_groupingElement) var _la int p.SetState(6475) @@ -111874,7 +111874,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(6449) - p.Match(DorisSQLParserROLLUP) + p.Match(StarRocksSQLParserROLLUP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111882,7 +111882,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6450) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111904,7 +111904,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6454) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111916,7 +111916,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(6455) - p.Match(DorisSQLParserCUBE) + p.Match(StarRocksSQLParserCUBE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111924,7 +111924,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6456) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111946,7 +111946,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6460) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111958,7 +111958,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(6461) - p.Match(DorisSQLParserGROUPING) + p.Match(StarRocksSQLParserGROUPING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111966,7 +111966,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6462) - p.Match(DorisSQLParserSETS) + p.Match(StarRocksSQLParserSETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111974,7 +111974,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6463) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -111991,10 +111991,10 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6465) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112014,7 +112014,7 @@ func (p *DorisSQLParser) GroupingElement() (localctx IGroupingElementContext) { } { p.SetState(6472) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112069,13 +112069,13 @@ type GroupingSetContext struct { func NewEmptyGroupingSetContext() *GroupingSetContext { var p = new(GroupingSetContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_groupingSet + p.RuleIndex = StarRocksSQLParserRULE_groupingSet return p } func InitEmptyGroupingSetContext(p *GroupingSetContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_groupingSet + p.RuleIndex = StarRocksSQLParserRULE_groupingSet } func (*GroupingSetContext) IsGroupingSetContext() {} @@ -112086,7 +112086,7 @@ func NewGroupingSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_groupingSet + p.RuleIndex = StarRocksSQLParserRULE_groupingSet return p } @@ -112143,20 +112143,20 @@ func (s *GroupingSetContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *GroupingSetContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGroupingSet(s) } } func (s *GroupingSetContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGroupingSet(s) } } func (s *GroupingSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGroupingSet(s) default: @@ -112164,15 +112164,15 @@ func (s *GroupingSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) GroupingSet() (localctx IGroupingSetContext) { +func (p *StarRocksSQLParser) GroupingSet() (localctx IGroupingSetContext) { localctx = NewGroupingSetContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 828, DorisSQLParserRULE_groupingSet) + p.EnterRule(localctx, 828, StarRocksSQLParserRULE_groupingSet) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6477) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112199,10 +112199,10 @@ func (p *DorisSQLParser) GroupingSet() (localctx IGroupingSetContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6481) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112222,7 +112222,7 @@ func (p *DorisSQLParser) GroupingSet() (localctx IGroupingSetContext) { } { p.SetState(6488) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112274,13 +112274,13 @@ type CommonTableExpressionContext struct { func NewEmptyCommonTableExpressionContext() *CommonTableExpressionContext { var p = new(CommonTableExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_commonTableExpression + p.RuleIndex = StarRocksSQLParserRULE_commonTableExpression return p } func InitEmptyCommonTableExpressionContext(p *CommonTableExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_commonTableExpression + p.RuleIndex = StarRocksSQLParserRULE_commonTableExpression } func (*CommonTableExpressionContext) IsCommonTableExpressionContext() {} @@ -112291,7 +112291,7 @@ func NewCommonTableExpressionContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_commonTableExpression + p.RuleIndex = StarRocksSQLParserRULE_commonTableExpression return p } @@ -112303,7 +112303,7 @@ func (s *CommonTableExpressionContext) GetName() IIdentifierContext { return s.n func (s *CommonTableExpressionContext) SetName(v IIdentifierContext) { s.name = v } func (s *CommonTableExpressionContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *CommonTableExpressionContext) QueryRelation() IQueryRelationContext { @@ -112363,20 +112363,20 @@ func (s *CommonTableExpressionContext) ToStringTree(ruleNames []string, recog an } func (s *CommonTableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCommonTableExpression(s) } } func (s *CommonTableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCommonTableExpression(s) } } func (s *CommonTableExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCommonTableExpression(s) default: @@ -112384,9 +112384,9 @@ func (s *CommonTableExpressionContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) CommonTableExpression() (localctx ICommonTableExpressionContext) { +func (p *StarRocksSQLParser) CommonTableExpression() (localctx ICommonTableExpressionContext) { localctx = NewCommonTableExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 830, DorisSQLParserRULE_commonTableExpression) + p.EnterRule(localctx, 830, StarRocksSQLParserRULE_commonTableExpression) var _la int p.EnterOuterAlt(localctx, 1) @@ -112404,7 +112404,7 @@ func (p *DorisSQLParser) CommonTableExpression() (localctx ICommonTableExpressio } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(6491) p.ColumnAliases() @@ -112413,7 +112413,7 @@ func (p *DorisSQLParser) CommonTableExpression() (localctx ICommonTableExpressio } { p.SetState(6494) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112421,7 +112421,7 @@ func (p *DorisSQLParser) CommonTableExpression() (localctx ICommonTableExpressio } { p.SetState(6495) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112433,7 +112433,7 @@ func (p *DorisSQLParser) CommonTableExpression() (localctx ICommonTableExpressio } { p.SetState(6497) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112476,13 +112476,13 @@ type SetQuantifierContext struct { func NewEmptySetQuantifierContext() *SetQuantifierContext { var p = new(SetQuantifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setQuantifier + p.RuleIndex = StarRocksSQLParserRULE_setQuantifier return p } func InitEmptySetQuantifierContext(p *SetQuantifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_setQuantifier + p.RuleIndex = StarRocksSQLParserRULE_setQuantifier } func (*SetQuantifierContext) IsSetQuantifierContext() {} @@ -112493,7 +112493,7 @@ func NewSetQuantifierContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_setQuantifier + p.RuleIndex = StarRocksSQLParserRULE_setQuantifier return p } @@ -112501,11 +112501,11 @@ func NewSetQuantifierContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *SetQuantifierContext) GetParser() antlr.Parser { return s.parser } func (s *SetQuantifierContext) DISTINCT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTINCT, 0) + return s.GetToken(StarRocksSQLParserDISTINCT, 0) } func (s *SetQuantifierContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *SetQuantifierContext) GetRuleContext() antlr.RuleContext { @@ -112517,20 +112517,20 @@ func (s *SetQuantifierContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *SetQuantifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSetQuantifier(s) } } func (s *SetQuantifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSetQuantifier(s) } } func (s *SetQuantifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSetQuantifier(s) default: @@ -112538,9 +112538,9 @@ func (s *SetQuantifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) SetQuantifier() (localctx ISetQuantifierContext) { +func (p *StarRocksSQLParser) SetQuantifier() (localctx ISetQuantifierContext) { localctx = NewSetQuantifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 832, DorisSQLParserRULE_setQuantifier) + p.EnterRule(localctx, 832, StarRocksSQLParserRULE_setQuantifier) var _la int p.EnterOuterAlt(localctx, 1) @@ -112548,7 +112548,7 @@ func (p *DorisSQLParser) SetQuantifier() (localctx ISetQuantifierContext) { p.SetState(6499) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT) { + if !(_la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -112587,13 +112587,13 @@ type SelectItemContext struct { func NewEmptySelectItemContext() *SelectItemContext { var p = new(SelectItemContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_selectItem + p.RuleIndex = StarRocksSQLParserRULE_selectItem return p } func InitEmptySelectItemContext(p *SelectItemContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_selectItem + p.RuleIndex = StarRocksSQLParserRULE_selectItem } func (*SelectItemContext) IsSelectItemContext() {} @@ -112604,7 +112604,7 @@ func NewSelectItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_selectItem + p.RuleIndex = StarRocksSQLParserRULE_selectItem return p } @@ -112658,7 +112658,7 @@ func (s *SelectAllContext) QualifiedName() IQualifiedNameContext { } func (s *SelectAllContext) ASTERISK_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASTERISK_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserASTERISK_SYMBOL, 0) } func (s *SelectAllContext) ExcludeClause() IExcludeClauseContext { @@ -112678,20 +112678,20 @@ func (s *SelectAllContext) ExcludeClause() IExcludeClauseContext { } func (s *SelectAllContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSelectAll(s) } } func (s *SelectAllContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSelectAll(s) } } func (s *SelectAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSelectAll(s) default: @@ -112766,24 +112766,24 @@ func (s *SelectSingleContext) String_() IStringContext { } func (s *SelectSingleContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *SelectSingleContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSelectSingle(s) } } func (s *SelectSingleContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSelectSingle(s) } } func (s *SelectSingleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSelectSingle(s) default: @@ -112791,9 +112791,9 @@ func (s *SelectSingleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) SelectItem() (localctx ISelectItemContext) { +func (p *StarRocksSQLParser) SelectItem() (localctx ISelectItemContext) { localctx = NewSelectItemContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 834, DorisSQLParserRULE_selectItem) + p.EnterRule(localctx, 834, StarRocksSQLParserRULE_selectItem) var _la int p.SetState(6521) @@ -112821,10 +112821,10 @@ func (p *DorisSQLParser) SelectItem() (localctx ISelectItemContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6502) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112839,13 +112839,13 @@ func (p *DorisSQLParser) SelectItem() (localctx ISelectItemContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(6505) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(6506) p.String_() @@ -112869,7 +112869,7 @@ func (p *DorisSQLParser) SelectItem() (localctx ISelectItemContext) { } { p.SetState(6512) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112877,7 +112877,7 @@ func (p *DorisSQLParser) SelectItem() (localctx ISelectItemContext) { } { p.SetState(6513) - p.Match(DorisSQLParserASTERISK_SYMBOL) + p.Match(StarRocksSQLParserASTERISK_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112901,7 +112901,7 @@ func (p *DorisSQLParser) SelectItem() (localctx ISelectItemContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(6517) - p.Match(DorisSQLParserASTERISK_SYMBOL) + p.Match(StarRocksSQLParserASTERISK_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -112962,13 +112962,13 @@ type ExcludeClauseContext struct { func NewEmptyExcludeClauseContext() *ExcludeClauseContext { var p = new(ExcludeClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_excludeClause + p.RuleIndex = StarRocksSQLParserRULE_excludeClause return p } func InitEmptyExcludeClauseContext(p *ExcludeClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_excludeClause + p.RuleIndex = StarRocksSQLParserRULE_excludeClause } func (*ExcludeClauseContext) IsExcludeClauseContext() {} @@ -112979,7 +112979,7 @@ func NewExcludeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_excludeClause + p.RuleIndex = StarRocksSQLParserRULE_excludeClause return p } @@ -113028,11 +113028,11 @@ func (s *ExcludeClauseContext) Identifier(i int) IIdentifierContext { } func (s *ExcludeClauseContext) EXCEPT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXCEPT, 0) + return s.GetToken(StarRocksSQLParserEXCEPT, 0) } func (s *ExcludeClauseContext) EXCLUDE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXCLUDE, 0) + return s.GetToken(StarRocksSQLParserEXCLUDE, 0) } func (s *ExcludeClauseContext) GetRuleContext() antlr.RuleContext { @@ -113044,20 +113044,20 @@ func (s *ExcludeClauseContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *ExcludeClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExcludeClause(s) } } func (s *ExcludeClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExcludeClause(s) } } func (s *ExcludeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExcludeClause(s) default: @@ -113065,9 +113065,9 @@ func (s *ExcludeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) ExcludeClause() (localctx IExcludeClauseContext) { +func (p *StarRocksSQLParser) ExcludeClause() (localctx IExcludeClauseContext) { localctx = NewExcludeClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 836, DorisSQLParserRULE_excludeClause) + p.EnterRule(localctx, 836, StarRocksSQLParserRULE_excludeClause) var _la int p.EnterOuterAlt(localctx, 1) @@ -113075,7 +113075,7 @@ func (p *DorisSQLParser) ExcludeClause() (localctx IExcludeClauseContext) { p.SetState(6523) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserEXCEPT || _la == DorisSQLParserEXCLUDE) { + if !(_la == StarRocksSQLParserEXCEPT || _la == StarRocksSQLParserEXCLUDE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -113084,7 +113084,7 @@ func (p *DorisSQLParser) ExcludeClause() (localctx IExcludeClauseContext) { } { p.SetState(6524) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113101,10 +113101,10 @@ func (p *DorisSQLParser) ExcludeClause() (localctx IExcludeClauseContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6526) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113124,7 +113124,7 @@ func (p *DorisSQLParser) ExcludeClause() (localctx IExcludeClauseContext) { } { p.SetState(6533) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113169,13 +113169,13 @@ type RelationsContext struct { func NewEmptyRelationsContext() *RelationsContext { var p = new(RelationsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relations + p.RuleIndex = StarRocksSQLParserRULE_relations return p } func InitEmptyRelationsContext(p *RelationsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relations + p.RuleIndex = StarRocksSQLParserRULE_relations } func (*RelationsContext) IsRelationsContext() {} @@ -113186,7 +113186,7 @@ func NewRelationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_relations + p.RuleIndex = StarRocksSQLParserRULE_relations return p } @@ -113235,11 +113235,11 @@ func (s *RelationsContext) RelationLateralView(i int) IRelationLateralViewContex } func (s *RelationsContext) AllLATERAL() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserLATERAL) + return s.GetTokens(StarRocksSQLParserLATERAL) } func (s *RelationsContext) LATERAL(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserLATERAL, i) + return s.GetToken(StarRocksSQLParserLATERAL, i) } func (s *RelationsContext) GetRuleContext() antlr.RuleContext { @@ -113251,20 +113251,20 @@ func (s *RelationsContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *RelationsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRelations(s) } } func (s *RelationsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRelations(s) } } func (s *RelationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRelations(s) default: @@ -113272,9 +113272,9 @@ func (s *RelationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Relations() (localctx IRelationsContext) { +func (p *StarRocksSQLParser) Relations() (localctx IRelationsContext) { localctx = NewRelationsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 838, DorisSQLParserRULE_relations) + p.EnterRule(localctx, 838, StarRocksSQLParserRULE_relations) var _la int var _alt int @@ -113297,7 +113297,7 @@ func (p *DorisSQLParser) Relations() (localctx IRelationsContext) { if _alt == 1 { { p.SetState(6536) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113310,10 +113310,10 @@ func (p *DorisSQLParser) Relations() (localctx IRelationsContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLATERAL { + if _la == StarRocksSQLParserLATERAL { { p.SetState(6537) - p.Match(DorisSQLParserLATERAL) + p.Match(StarRocksSQLParserLATERAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113374,13 +113374,13 @@ type RelationLateralViewContext struct { func NewEmptyRelationLateralViewContext() *RelationLateralViewContext { var p = new(RelationLateralViewContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relationLateralView + p.RuleIndex = StarRocksSQLParserRULE_relationLateralView return p } func InitEmptyRelationLateralViewContext(p *RelationLateralViewContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relationLateralView + p.RuleIndex = StarRocksSQLParserRULE_relationLateralView } func (*RelationLateralViewContext) IsRelationLateralViewContext() {} @@ -113391,7 +113391,7 @@ func NewRelationLateralViewContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_relationLateralView + p.RuleIndex = StarRocksSQLParserRULE_relationLateralView return p } @@ -113439,20 +113439,20 @@ func (s *RelationLateralViewContext) ToStringTree(ruleNames []string, recog antl } func (s *RelationLateralViewContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRelationLateralView(s) } } func (s *RelationLateralViewContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRelationLateralView(s) } } func (s *RelationLateralViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRelationLateralView(s) default: @@ -113460,9 +113460,9 @@ func (s *RelationLateralViewContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) RelationLateralView() (localctx IRelationLateralViewContext) { +func (p *StarRocksSQLParser) RelationLateralView() (localctx IRelationLateralViewContext) { localctx = NewRelationLateralViewContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 840, DorisSQLParserRULE_relationLateralView) + p.EnterRule(localctx, 840, StarRocksSQLParserRULE_relationLateralView) p.EnterOuterAlt(localctx, 1) { p.SetState(6546) @@ -113530,13 +113530,13 @@ type LateralViewContext struct { func NewEmptyLateralViewContext() *LateralViewContext { var p = new(LateralViewContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_lateralView + p.RuleIndex = StarRocksSQLParserRULE_lateralView return p } func InitEmptyLateralViewContext(p *LateralViewContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_lateralView + p.RuleIndex = StarRocksSQLParserRULE_lateralView } func (*LateralViewContext) IsLateralViewContext() {} @@ -113547,7 +113547,7 @@ func NewLateralViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_lateralView + p.RuleIndex = StarRocksSQLParserRULE_lateralView return p } @@ -113559,11 +113559,11 @@ func (s *LateralViewContext) GetAlias() IIdentifierContext { return s.alias } func (s *LateralViewContext) SetAlias(v IIdentifierContext) { s.alias = v } func (s *LateralViewContext) LATERAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLATERAL, 0) + return s.GetToken(StarRocksSQLParserLATERAL, 0) } func (s *LateralViewContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *LateralViewContext) GeneratorFunction() IGeneratorFunctionContext { @@ -113583,7 +113583,7 @@ func (s *LateralViewContext) GeneratorFunction() IGeneratorFunctionContext { } func (s *LateralViewContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *LateralViewContext) ColumnAliasesWithoutParentheses() IColumnAliasesWithoutParenthesesContext { @@ -113668,20 +113668,20 @@ func (s *LateralViewContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *LateralViewContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLateralView(s) } } func (s *LateralViewContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLateralView(s) } } func (s *LateralViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLateralView(s) default: @@ -113689,15 +113689,15 @@ func (s *LateralViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) LateralView() (localctx ILateralViewContext) { +func (p *StarRocksSQLParser) LateralView() (localctx ILateralViewContext) { localctx = NewLateralViewContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 842, DorisSQLParserRULE_lateralView) + p.EnterRule(localctx, 842, StarRocksSQLParserRULE_lateralView) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6550) - p.Match(DorisSQLParserLATERAL) + p.Match(StarRocksSQLParserLATERAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113705,7 +113705,7 @@ func (p *DorisSQLParser) LateralView() (localctx ILateralViewContext) { } { p.SetState(6551) - p.Match(DorisSQLParserVIEW) + p.Match(StarRocksSQLParserVIEW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113727,10 +113727,10 @@ func (p *DorisSQLParser) LateralView() (localctx ILateralViewContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6554) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113758,7 +113758,7 @@ func (p *DorisSQLParser) LateralView() (localctx ILateralViewContext) { } { p.SetState(6562) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -113805,13 +113805,13 @@ type GeneratorFunctionContext struct { func NewEmptyGeneratorFunctionContext() *GeneratorFunctionContext { var p = new(GeneratorFunctionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_generatorFunction + p.RuleIndex = StarRocksSQLParserRULE_generatorFunction return p } func InitEmptyGeneratorFunctionContext(p *GeneratorFunctionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_generatorFunction + p.RuleIndex = StarRocksSQLParserRULE_generatorFunction } func (*GeneratorFunctionContext) IsGeneratorFunctionContext() {} @@ -113822,7 +113822,7 @@ func NewGeneratorFunctionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_generatorFunction + p.RuleIndex = StarRocksSQLParserRULE_generatorFunction return p } @@ -113830,11 +113830,11 @@ func NewGeneratorFunctionContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *GeneratorFunctionContext) GetParser() antlr.Parser { return s.parser } func (s *GeneratorFunctionContext) EXPLODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPLODE, 0) + return s.GetToken(StarRocksSQLParserEXPLODE, 0) } func (s *GeneratorFunctionContext) EXPLODE_SPLIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPLODE_SPLIT, 0) + return s.GetToken(StarRocksSQLParserEXPLODE_SPLIT, 0) } func (s *GeneratorFunctionContext) GetRuleContext() antlr.RuleContext { @@ -113846,20 +113846,20 @@ func (s *GeneratorFunctionContext) ToStringTree(ruleNames []string, recog antlr. } func (s *GeneratorFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGeneratorFunction(s) } } func (s *GeneratorFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGeneratorFunction(s) } } func (s *GeneratorFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGeneratorFunction(s) default: @@ -113867,9 +113867,9 @@ func (s *GeneratorFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) GeneratorFunction() (localctx IGeneratorFunctionContext) { +func (p *StarRocksSQLParser) GeneratorFunction() (localctx IGeneratorFunctionContext) { localctx = NewGeneratorFunctionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 844, DorisSQLParserRULE_generatorFunction) + p.EnterRule(localctx, 844, StarRocksSQLParserRULE_generatorFunction) var _la int p.EnterOuterAlt(localctx, 1) @@ -113877,7 +113877,7 @@ func (p *DorisSQLParser) GeneratorFunction() (localctx IGeneratorFunctionContext p.SetState(6565) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserEXPLODE || _la == DorisSQLParserEXPLODE_SPLIT) { + if !(_la == StarRocksSQLParserEXPLODE || _la == StarRocksSQLParserEXPLODE_SPLIT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -113922,13 +113922,13 @@ type RelationContext struct { func NewEmptyRelationContext() *RelationContext { var p = new(RelationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relation + p.RuleIndex = StarRocksSQLParserRULE_relation return p } func InitEmptyRelationContext(p *RelationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relation + p.RuleIndex = StarRocksSQLParserRULE_relation } func (*RelationContext) IsRelationContext() {} @@ -113939,7 +113939,7 @@ func NewRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_relation + p.RuleIndex = StarRocksSQLParserRULE_relation return p } @@ -114012,20 +114012,20 @@ func (s *RelationContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *RelationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRelation(s) } } func (s *RelationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRelation(s) } } func (s *RelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRelation(s) default: @@ -114033,9 +114033,9 @@ func (s *RelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Relation() (localctx IRelationContext) { +func (p *StarRocksSQLParser) Relation() (localctx IRelationContext) { localctx = NewRelationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 846, DorisSQLParserRULE_relation) + p.EnterRule(localctx, 846, StarRocksSQLParserRULE_relation) var _la int var _alt int @@ -114085,7 +114085,7 @@ func (p *DorisSQLParser) Relation() (localctx IRelationContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(6574) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -114102,7 +114102,7 @@ func (p *DorisSQLParser) Relation() (localctx IRelationContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserCROSS || ((int64((_la-177)) & ^0x3f) == 0 && ((int64(1)<<(_la-177))&4612811926924165121) != 0) || _la == DorisSQLParserRIGHT { + for _la == StarRocksSQLParserCROSS || ((int64((_la-177)) & ^0x3f) == 0 && ((int64(1)<<(_la-177))&4612811926924165121) != 0) || _la == StarRocksSQLParserRIGHT { { p.SetState(6576) p.JoinRelation() @@ -114117,7 +114117,7 @@ func (p *DorisSQLParser) Relation() (localctx IRelationContext) { } { p.SetState(6582) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -114159,13 +114159,13 @@ type RelationPrimaryContext struct { func NewEmptyRelationPrimaryContext() *RelationPrimaryContext { var p = new(RelationPrimaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relationPrimary + p.RuleIndex = StarRocksSQLParserRULE_relationPrimary return p } func InitEmptyRelationPrimaryContext(p *RelationPrimaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_relationPrimary + p.RuleIndex = StarRocksSQLParserRULE_relationPrimary } func (*RelationPrimaryContext) IsRelationPrimaryContext() {} @@ -114176,7 +114176,7 @@ func NewRelationPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_relationPrimary + p.RuleIndex = StarRocksSQLParserRULE_relationPrimary return p } @@ -114251,7 +114251,7 @@ func (s *SubqueryWithAliasContext) Identifier() IIdentifierContext { } func (s *SubqueryWithAliasContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *SubqueryWithAliasContext) ColumnAliases() IColumnAliasesContext { @@ -114271,20 +114271,20 @@ func (s *SubqueryWithAliasContext) ColumnAliases() IColumnAliasesContext { } func (s *SubqueryWithAliasContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubqueryWithAlias(s) } } func (s *SubqueryWithAliasContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubqueryWithAlias(s) } } func (s *SubqueryWithAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubqueryWithAlias(s) default: @@ -114316,7 +114316,7 @@ func (s *NormalizedTableFunctionContext) GetRuleContext() antlr.RuleContext { } func (s *NormalizedTableFunctionContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *NormalizedTableFunctionContext) QualifiedName() IQualifiedNameContext { @@ -114368,7 +114368,7 @@ func (s *NormalizedTableFunctionContext) Identifier() IIdentifierContext { } func (s *NormalizedTableFunctionContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *NormalizedTableFunctionContext) ColumnAliases() IColumnAliasesContext { @@ -114388,20 +114388,20 @@ func (s *NormalizedTableFunctionContext) ColumnAliases() IColumnAliasesContext { } func (s *NormalizedTableFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNormalizedTableFunction(s) } } func (s *NormalizedTableFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNormalizedTableFunction(s) } } func (s *NormalizedTableFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNormalizedTableFunction(s) default: @@ -114481,7 +114481,7 @@ func (s *TableFunctionContext) Identifier() IIdentifierContext { } func (s *TableFunctionContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *TableFunctionContext) ColumnAliases() IColumnAliasesContext { @@ -114501,20 +114501,20 @@ func (s *TableFunctionContext) ColumnAliases() IColumnAliasesContext { } func (s *TableFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTableFunction(s) } } func (s *TableFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTableFunction(s) } } func (s *TableFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTableFunction(s) default: @@ -114557,20 +114557,20 @@ func (s *ParenthesizedRelationContext) Relations() IRelationsContext { } func (s *ParenthesizedRelationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterParenthesizedRelation(s) } } func (s *ParenthesizedRelationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitParenthesizedRelation(s) } } func (s *ParenthesizedRelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitParenthesizedRelation(s) default: @@ -114602,7 +114602,7 @@ func (s *FileTableFunctionContext) GetRuleContext() antlr.RuleContext { } func (s *FileTableFunctionContext) FILES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILES, 0) + return s.GetToken(StarRocksSQLParserFILES, 0) } func (s *FileTableFunctionContext) PropertyList() IPropertyListContext { @@ -114638,7 +114638,7 @@ func (s *FileTableFunctionContext) Identifier() IIdentifierContext { } func (s *FileTableFunctionContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *FileTableFunctionContext) ColumnAliases() IColumnAliasesContext { @@ -114658,20 +114658,20 @@ func (s *FileTableFunctionContext) ColumnAliases() IColumnAliasesContext { } func (s *FileTableFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterFileTableFunction(s) } } func (s *FileTableFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitFileTableFunction(s) } } func (s *FileTableFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitFileTableFunction(s) default: @@ -114820,7 +114820,7 @@ func (s *TableAtomContext) BracketHint() IBracketHintContext { } func (s *TableAtomContext) BEFORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBEFORE, 0) + return s.GetToken(StarRocksSQLParserBEFORE, 0) } func (s *TableAtomContext) Identifier() IIdentifierContext { @@ -114856,24 +114856,24 @@ func (s *TableAtomContext) String_() IStringContext { } func (s *TableAtomContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *TableAtomContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTableAtom(s) } } func (s *TableAtomContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTableAtom(s) } } func (s *TableAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTableAtom(s) default: @@ -114905,7 +114905,7 @@ func (s *InlineTableContext) GetRuleContext() antlr.RuleContext { } func (s *InlineTableContext) VALUES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUES, 0) + return s.GetToken(StarRocksSQLParserVALUES, 0) } func (s *InlineTableContext) AllRowConstructor() []IRowConstructorContext { @@ -114966,7 +114966,7 @@ func (s *InlineTableContext) Identifier() IIdentifierContext { } func (s *InlineTableContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *InlineTableContext) ColumnAliases() IColumnAliasesContext { @@ -114986,20 +114986,20 @@ func (s *InlineTableContext) ColumnAliases() IColumnAliasesContext { } func (s *InlineTableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInlineTable(s) } } func (s *InlineTableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInlineTable(s) } } func (s *InlineTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInlineTable(s) default: @@ -115007,9 +115007,9 @@ func (s *InlineTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { +func (p *StarRocksSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { localctx = NewRelationPrimaryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 848, DorisSQLParserRULE_relationPrimary) + p.EnterRule(localctx, 848, StarRocksSQLParserRULE_relationPrimary) var _la int p.SetState(6689) @@ -115097,10 +115097,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6602) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115137,7 +115137,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 739, p.GetParserRuleContext()) == 1 { { p.SetState(6611) - p.Match(DorisSQLParserBEFORE) + p.Match(StarRocksSQLParserBEFORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115160,7 +115160,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(6615) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115168,7 +115168,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6616) - p.Match(DorisSQLParserVALUES) + p.Match(StarRocksSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115185,10 +115185,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6618) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115208,7 +115208,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6625) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115225,10 +115225,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6626) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115278,10 +115278,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6636) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115322,7 +115322,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6646) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115334,7 +115334,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6648) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115351,10 +115351,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6649) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115391,7 +115391,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { p.EnterOuterAlt(localctx, 5) { p.SetState(6658) - p.Match(DorisSQLParserTABLE) + p.Match(StarRocksSQLParserTABLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115399,7 +115399,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6659) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115411,7 +115411,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6661) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115423,7 +115423,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6663) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115431,7 +115431,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6664) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115448,10 +115448,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6665) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115488,7 +115488,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { p.EnterOuterAlt(localctx, 6) { p.SetState(6674) - p.Match(DorisSQLParserFILES) + p.Match(StarRocksSQLParserFILES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115509,10 +115509,10 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6676) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115549,7 +115549,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { p.EnterOuterAlt(localctx, 7) { p.SetState(6685) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115561,7 +115561,7 @@ func (p *DorisSQLParser) RelationPrimary() (localctx IRelationPrimaryContext) { } { p.SetState(6687) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115615,13 +115615,13 @@ type PivotClauseContext struct { func NewEmptyPivotClauseContext() *PivotClauseContext { var p = new(PivotClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pivotClause + p.RuleIndex = StarRocksSQLParserRULE_pivotClause return p } func InitEmptyPivotClauseContext(p *PivotClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pivotClause + p.RuleIndex = StarRocksSQLParserRULE_pivotClause } func (*PivotClauseContext) IsPivotClauseContext() {} @@ -115632,7 +115632,7 @@ func NewPivotClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_pivotClause + p.RuleIndex = StarRocksSQLParserRULE_pivotClause return p } @@ -115640,7 +115640,7 @@ func NewPivotClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *PivotClauseContext) GetParser() antlr.Parser { return s.parser } func (s *PivotClauseContext) PIVOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIVOT, 0) + return s.GetToken(StarRocksSQLParserPIVOT, 0) } func (s *PivotClauseContext) AllPivotAggregationExpression() []IPivotAggregationExpressionContext { @@ -115685,11 +115685,11 @@ func (s *PivotClauseContext) PivotAggregationExpression(i int) IPivotAggregation } func (s *PivotClauseContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *PivotClauseContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *PivotClauseContext) AllPivotValue() []IPivotValueContext { @@ -115774,20 +115774,20 @@ func (s *PivotClauseContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *PivotClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPivotClause(s) } } func (s *PivotClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPivotClause(s) } } func (s *PivotClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPivotClause(s) default: @@ -115795,15 +115795,15 @@ func (s *PivotClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { +func (p *StarRocksSQLParser) PivotClause() (localctx IPivotClauseContext) { localctx = NewPivotClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 850, DorisSQLParserRULE_pivotClause) + p.EnterRule(localctx, 850, StarRocksSQLParserRULE_pivotClause) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6691) - p.Match(DorisSQLParserPIVOT) + p.Match(StarRocksSQLParserPIVOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115811,7 +115811,7 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } { p.SetState(6692) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115828,10 +115828,10 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6694) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115851,7 +115851,7 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } { p.SetState(6701) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115864,13 +115864,13 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(6702) p.Identifier() } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(6703) p.IdentifierList() @@ -115882,7 +115882,7 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } { p.SetState(6706) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115890,7 +115890,7 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } { p.SetState(6707) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115907,10 +115907,10 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6709) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115930,7 +115930,7 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } { p.SetState(6716) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115938,7 +115938,7 @@ func (p *DorisSQLParser) PivotClause() (localctx IPivotClauseContext) { } { p.SetState(6717) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -115983,13 +115983,13 @@ type PivotAggregationExpressionContext struct { func NewEmptyPivotAggregationExpressionContext() *PivotAggregationExpressionContext { var p = new(PivotAggregationExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pivotAggregationExpression + p.RuleIndex = StarRocksSQLParserRULE_pivotAggregationExpression return p } func InitEmptyPivotAggregationExpressionContext(p *PivotAggregationExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pivotAggregationExpression + p.RuleIndex = StarRocksSQLParserRULE_pivotAggregationExpression } func (*PivotAggregationExpressionContext) IsPivotAggregationExpressionContext() {} @@ -116000,7 +116000,7 @@ func NewPivotAggregationExpressionContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_pivotAggregationExpression + p.RuleIndex = StarRocksSQLParserRULE_pivotAggregationExpression return p } @@ -116056,7 +116056,7 @@ func (s *PivotAggregationExpressionContext) String_() IStringContext { } func (s *PivotAggregationExpressionContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *PivotAggregationExpressionContext) GetRuleContext() antlr.RuleContext { @@ -116068,20 +116068,20 @@ func (s *PivotAggregationExpressionContext) ToStringTree(ruleNames []string, rec } func (s *PivotAggregationExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPivotAggregationExpression(s) } } func (s *PivotAggregationExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPivotAggregationExpression(s) } } func (s *PivotAggregationExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPivotAggregationExpression(s) default: @@ -116089,9 +116089,9 @@ func (s *PivotAggregationExpressionContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) PivotAggregationExpression() (localctx IPivotAggregationExpressionContext) { +func (p *StarRocksSQLParser) PivotAggregationExpression() (localctx IPivotAggregationExpressionContext) { localctx = NewPivotAggregationExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 852, DorisSQLParserRULE_pivotAggregationExpression) + p.EnterRule(localctx, 852, StarRocksSQLParserRULE_pivotAggregationExpression) var _la int p.EnterOuterAlt(localctx, 1) @@ -116114,10 +116114,10 @@ func (p *DorisSQLParser) PivotAggregationExpression() (localctx IPivotAggregatio } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6720) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -116132,13 +116132,13 @@ func (p *DorisSQLParser) PivotAggregationExpression() (localctx IPivotAggregatio } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(6723) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(6724) p.String_() @@ -116190,13 +116190,13 @@ type PivotValueContext struct { func NewEmptyPivotValueContext() *PivotValueContext { var p = new(PivotValueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pivotValue + p.RuleIndex = StarRocksSQLParserRULE_pivotValue return p } func InitEmptyPivotValueContext(p *PivotValueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_pivotValue + p.RuleIndex = StarRocksSQLParserRULE_pivotValue } func (*PivotValueContext) IsPivotValueContext() {} @@ -116207,7 +116207,7 @@ func NewPivotValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_pivotValue + p.RuleIndex = StarRocksSQLParserRULE_pivotValue return p } @@ -116279,7 +116279,7 @@ func (s *PivotValueContext) String_() IStringContext { } func (s *PivotValueContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *PivotValueContext) GetRuleContext() antlr.RuleContext { @@ -116291,20 +116291,20 @@ func (s *PivotValueContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *PivotValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPivotValue(s) } } func (s *PivotValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPivotValue(s) } } func (s *PivotValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPivotValue(s) default: @@ -116312,9 +116312,9 @@ func (s *PivotValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) PivotValue() (localctx IPivotValueContext) { +func (p *StarRocksSQLParser) PivotValue() (localctx IPivotValueContext) { localctx = NewPivotValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 854, DorisSQLParserRULE_pivotValue) + p.EnterRule(localctx, 854, StarRocksSQLParserRULE_pivotValue) var _la int p.EnterOuterAlt(localctx, 1) @@ -116325,13 +116325,13 @@ func (p *DorisSQLParser) PivotValue() (localctx IPivotValueContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCEIL, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserFALSE, DorisSQLParserFLOOR, DorisSQLParserINTERVAL, DorisSQLParserNULL, DorisSQLParserPARAMETER, DorisSQLParserTRUE, DorisSQLParserINTEGER_VALUE, DorisSQLParserDECIMAL_VALUE, DorisSQLParserDOUBLE_VALUE, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserBINARY_SINGLE_QUOTED_TEXT, DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT: + case StarRocksSQLParserCEIL, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserFALSE, StarRocksSQLParserFLOOR, StarRocksSQLParserINTERVAL, StarRocksSQLParserNULL, StarRocksSQLParserPARAMETER, StarRocksSQLParserTRUE, StarRocksSQLParserINTEGER_VALUE, StarRocksSQLParserDECIMAL_VALUE, StarRocksSQLParserDOUBLE_VALUE, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT, StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT: { p.SetState(6729) p.LiteralExpression() } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(6730) p.LiteralExpressionList() @@ -116356,10 +116356,10 @@ func (p *DorisSQLParser) PivotValue() (localctx IPivotValueContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(6733) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -116374,13 +116374,13 @@ func (p *DorisSQLParser) PivotValue() (localctx IPivotValueContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(6736) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(6737) p.String_() @@ -116429,13 +116429,13 @@ type SampleClauseContext struct { func NewEmptySampleClauseContext() *SampleClauseContext { var p = new(SampleClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_sampleClause + p.RuleIndex = StarRocksSQLParserRULE_sampleClause return p } func InitEmptySampleClauseContext(p *SampleClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_sampleClause + p.RuleIndex = StarRocksSQLParserRULE_sampleClause } func (*SampleClauseContext) IsSampleClauseContext() {} @@ -116446,7 +116446,7 @@ func NewSampleClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_sampleClause + p.RuleIndex = StarRocksSQLParserRULE_sampleClause return p } @@ -116454,7 +116454,7 @@ func NewSampleClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *SampleClauseContext) GetParser() antlr.Parser { return s.parser } func (s *SampleClauseContext) SAMPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSAMPLE, 0) + return s.GetToken(StarRocksSQLParserSAMPLE, 0) } func (s *SampleClauseContext) PropertyList() IPropertyListContext { @@ -116482,20 +116482,20 @@ func (s *SampleClauseContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *SampleClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSampleClause(s) } } func (s *SampleClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSampleClause(s) } } func (s *SampleClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSampleClause(s) default: @@ -116503,13 +116503,13 @@ func (s *SampleClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) SampleClause() (localctx ISampleClauseContext) { +func (p *StarRocksSQLParser) SampleClause() (localctx ISampleClauseContext) { localctx = NewSampleClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 856, DorisSQLParserRULE_sampleClause) + p.EnterRule(localctx, 856, StarRocksSQLParserRULE_sampleClause) p.EnterOuterAlt(localctx, 1) { p.SetState(6742) - p.Match(DorisSQLParserSAMPLE) + p.Match(StarRocksSQLParserSAMPLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -116564,13 +116564,13 @@ type ArgumentListContext struct { func NewEmptyArgumentListContext() *ArgumentListContext { var p = new(ArgumentListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_argumentList + p.RuleIndex = StarRocksSQLParserRULE_argumentList return p } func InitEmptyArgumentListContext(p *ArgumentListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_argumentList + p.RuleIndex = StarRocksSQLParserRULE_argumentList } func (*ArgumentListContext) IsArgumentListContext() {} @@ -116581,7 +116581,7 @@ func NewArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_argumentList + p.RuleIndex = StarRocksSQLParserRULE_argumentList return p } @@ -116629,20 +116629,20 @@ func (s *ArgumentListContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *ArgumentListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArgumentList(s) } } func (s *ArgumentListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArgumentList(s) } } func (s *ArgumentListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArgumentList(s) default: @@ -116650,9 +116650,9 @@ func (s *ArgumentListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) ArgumentList() (localctx IArgumentListContext) { +func (p *StarRocksSQLParser) ArgumentList() (localctx IArgumentListContext) { localctx = NewArgumentListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 858, DorisSQLParserRULE_argumentList) + p.EnterRule(localctx, 858, StarRocksSQLParserRULE_argumentList) p.SetState(6748) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -116714,13 +116714,13 @@ type NamedArgumentListContext struct { func NewEmptyNamedArgumentListContext() *NamedArgumentListContext { var p = new(NamedArgumentListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_namedArgumentList + p.RuleIndex = StarRocksSQLParserRULE_namedArgumentList return p } func InitEmptyNamedArgumentListContext(p *NamedArgumentListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_namedArgumentList + p.RuleIndex = StarRocksSQLParserRULE_namedArgumentList } func (*NamedArgumentListContext) IsNamedArgumentListContext() {} @@ -116731,7 +116731,7 @@ func NewNamedArgumentListContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_namedArgumentList + p.RuleIndex = StarRocksSQLParserRULE_namedArgumentList return p } @@ -116788,20 +116788,20 @@ func (s *NamedArgumentListContext) ToStringTree(ruleNames []string, recog antlr. } func (s *NamedArgumentListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNamedArgumentList(s) } } func (s *NamedArgumentListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNamedArgumentList(s) } } func (s *NamedArgumentListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNamedArgumentList(s) default: @@ -116809,9 +116809,9 @@ func (s *NamedArgumentListContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) NamedArgumentList() (localctx INamedArgumentListContext) { +func (p *StarRocksSQLParser) NamedArgumentList() (localctx INamedArgumentListContext) { localctx = NewNamedArgumentListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 860, DorisSQLParserRULE_namedArgumentList) + p.EnterRule(localctx, 860, StarRocksSQLParserRULE_namedArgumentList) var _la int p.EnterOuterAlt(localctx, 1) @@ -116826,10 +116826,10 @@ func (p *DorisSQLParser) NamedArgumentList() (localctx INamedArgumentListContext } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6751) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -116879,13 +116879,13 @@ type NamedArgumentContext struct { func NewEmptyNamedArgumentContext() *NamedArgumentContext { var p = new(NamedArgumentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_namedArgument + p.RuleIndex = StarRocksSQLParserRULE_namedArgument return p } func InitEmptyNamedArgumentContext(p *NamedArgumentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_namedArgument + p.RuleIndex = StarRocksSQLParserRULE_namedArgument } func (*NamedArgumentContext) IsNamedArgumentContext() {} @@ -116896,7 +116896,7 @@ func NewNamedArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_namedArgument + p.RuleIndex = StarRocksSQLParserRULE_namedArgument return p } @@ -116966,20 +116966,20 @@ func (s *NamedArgumentsContext) Expression() IExpressionContext { } func (s *NamedArgumentsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNamedArguments(s) } } func (s *NamedArgumentsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNamedArguments(s) } } func (s *NamedArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNamedArguments(s) default: @@ -116987,9 +116987,9 @@ func (s *NamedArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) NamedArgument() (localctx INamedArgumentContext) { +func (p *StarRocksSQLParser) NamedArgument() (localctx INamedArgumentContext) { localctx = NewNamedArgumentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 862, DorisSQLParserRULE_namedArgument) + p.EnterRule(localctx, 862, StarRocksSQLParserRULE_namedArgument) localctx = NewNamedArgumentsContext(p, localctx) p.EnterOuterAlt(localctx, 1) { @@ -116998,7 +116998,7 @@ func (p *DorisSQLParser) NamedArgument() (localctx INamedArgumentContext) { } { p.SetState(6759) - p.Match(DorisSQLParserT__4) + p.Match(StarRocksSQLParserT__4) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117056,13 +117056,13 @@ type JoinRelationContext struct { func NewEmptyJoinRelationContext() *JoinRelationContext { var p = new(JoinRelationContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_joinRelation + p.RuleIndex = StarRocksSQLParserRULE_joinRelation return p } func InitEmptyJoinRelationContext(p *JoinRelationContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_joinRelation + p.RuleIndex = StarRocksSQLParserRULE_joinRelation } func (*JoinRelationContext) IsJoinRelationContext() {} @@ -117073,7 +117073,7 @@ func NewJoinRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_joinRelation + p.RuleIndex = StarRocksSQLParserRULE_joinRelation return p } @@ -117133,7 +117133,7 @@ func (s *JoinRelationContext) BracketHint() IBracketHintContext { } func (s *JoinRelationContext) LATERAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLATERAL, 0) + return s.GetToken(StarRocksSQLParserLATERAL, 0) } func (s *JoinRelationContext) JoinCriteria() IJoinCriteriaContext { @@ -117177,20 +117177,20 @@ func (s *JoinRelationContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *JoinRelationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterJoinRelation(s) } } func (s *JoinRelationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitJoinRelation(s) } } func (s *JoinRelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitJoinRelation(s) default: @@ -117198,9 +117198,9 @@ func (s *JoinRelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { +func (p *StarRocksSQLParser) JoinRelation() (localctx IJoinRelationContext) { localctx = NewJoinRelationContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 864, DorisSQLParserRULE_joinRelation) + p.EnterRule(localctx, 864, StarRocksSQLParserRULE_joinRelation) var _la int p.SetState(6783) @@ -117210,7 +117210,7 @@ func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCROSS, DorisSQLParserINNER, DorisSQLParserJOIN: + case StarRocksSQLParserCROSS, StarRocksSQLParserINNER, StarRocksSQLParserJOIN: p.EnterOuterAlt(localctx, 1) { p.SetState(6762) @@ -117223,7 +117223,7 @@ func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__5 { + if _la == StarRocksSQLParserT__5 { { p.SetState(6763) p.BracketHint() @@ -117237,10 +117237,10 @@ func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLATERAL { + if _la == StarRocksSQLParserLATERAL { { p.SetState(6766) - p.Match(DorisSQLParserLATERAL) + p.Match(StarRocksSQLParserLATERAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117268,7 +117268,7 @@ func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { goto errorExit } - case DorisSQLParserFULL, DorisSQLParserLEFT, DorisSQLParserRIGHT: + case StarRocksSQLParserFULL, StarRocksSQLParserLEFT, StarRocksSQLParserRIGHT: p.EnterOuterAlt(localctx, 2) { p.SetState(6773) @@ -117281,7 +117281,7 @@ func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__5 { + if _la == StarRocksSQLParserT__5 { { p.SetState(6774) p.BracketHint() @@ -117295,10 +117295,10 @@ func (p *DorisSQLParser) JoinRelation() (localctx IJoinRelationContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLATERAL { + if _la == StarRocksSQLParserLATERAL { { p.SetState(6777) - p.Match(DorisSQLParserLATERAL) + p.Match(StarRocksSQLParserLATERAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117360,13 +117360,13 @@ type CrossOrInnerJoinTypeContext struct { func NewEmptyCrossOrInnerJoinTypeContext() *CrossOrInnerJoinTypeContext { var p = new(CrossOrInnerJoinTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_crossOrInnerJoinType + p.RuleIndex = StarRocksSQLParserRULE_crossOrInnerJoinType return p } func InitEmptyCrossOrInnerJoinTypeContext(p *CrossOrInnerJoinTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_crossOrInnerJoinType + p.RuleIndex = StarRocksSQLParserRULE_crossOrInnerJoinType } func (*CrossOrInnerJoinTypeContext) IsCrossOrInnerJoinTypeContext() {} @@ -117377,7 +117377,7 @@ func NewCrossOrInnerJoinTypeContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_crossOrInnerJoinType + p.RuleIndex = StarRocksSQLParserRULE_crossOrInnerJoinType return p } @@ -117385,15 +117385,15 @@ func NewCrossOrInnerJoinTypeContext(parser antlr.Parser, parent antlr.ParserRule func (s *CrossOrInnerJoinTypeContext) GetParser() antlr.Parser { return s.parser } func (s *CrossOrInnerJoinTypeContext) JOIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOIN, 0) + return s.GetToken(StarRocksSQLParserJOIN, 0) } func (s *CrossOrInnerJoinTypeContext) INNER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINNER, 0) + return s.GetToken(StarRocksSQLParserINNER, 0) } func (s *CrossOrInnerJoinTypeContext) CROSS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCROSS, 0) + return s.GetToken(StarRocksSQLParserCROSS, 0) } func (s *CrossOrInnerJoinTypeContext) GetRuleContext() antlr.RuleContext { @@ -117405,20 +117405,20 @@ func (s *CrossOrInnerJoinTypeContext) ToStringTree(ruleNames []string, recog ant } func (s *CrossOrInnerJoinTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCrossOrInnerJoinType(s) } } func (s *CrossOrInnerJoinTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCrossOrInnerJoinType(s) } } func (s *CrossOrInnerJoinTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCrossOrInnerJoinType(s) default: @@ -117426,9 +117426,9 @@ func (s *CrossOrInnerJoinTypeContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeContext) { +func (p *StarRocksSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeContext) { localctx = NewCrossOrInnerJoinTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 866, DorisSQLParserRULE_crossOrInnerJoinType) + p.EnterRule(localctx, 866, StarRocksSQLParserRULE_crossOrInnerJoinType) p.SetState(6791) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -117440,7 +117440,7 @@ func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeC p.EnterOuterAlt(localctx, 1) { p.SetState(6785) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117451,7 +117451,7 @@ func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeC p.EnterOuterAlt(localctx, 2) { p.SetState(6786) - p.Match(DorisSQLParserINNER) + p.Match(StarRocksSQLParserINNER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117459,7 +117459,7 @@ func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeC } { p.SetState(6787) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117470,7 +117470,7 @@ func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeC p.EnterOuterAlt(localctx, 3) { p.SetState(6788) - p.Match(DorisSQLParserCROSS) + p.Match(StarRocksSQLParserCROSS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117481,7 +117481,7 @@ func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeC p.EnterOuterAlt(localctx, 4) { p.SetState(6789) - p.Match(DorisSQLParserCROSS) + p.Match(StarRocksSQLParserCROSS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117489,7 +117489,7 @@ func (p *DorisSQLParser) CrossOrInnerJoinType() (localctx ICrossOrInnerJoinTypeC } { p.SetState(6790) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117541,13 +117541,13 @@ type OuterAndSemiJoinTypeContext struct { func NewEmptyOuterAndSemiJoinTypeContext() *OuterAndSemiJoinTypeContext { var p = new(OuterAndSemiJoinTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_outerAndSemiJoinType + p.RuleIndex = StarRocksSQLParserRULE_outerAndSemiJoinType return p } func InitEmptyOuterAndSemiJoinTypeContext(p *OuterAndSemiJoinTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_outerAndSemiJoinType + p.RuleIndex = StarRocksSQLParserRULE_outerAndSemiJoinType } func (*OuterAndSemiJoinTypeContext) IsOuterAndSemiJoinTypeContext() {} @@ -117558,7 +117558,7 @@ func NewOuterAndSemiJoinTypeContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_outerAndSemiJoinType + p.RuleIndex = StarRocksSQLParserRULE_outerAndSemiJoinType return p } @@ -117566,31 +117566,31 @@ func NewOuterAndSemiJoinTypeContext(parser antlr.Parser, parent antlr.ParserRule func (s *OuterAndSemiJoinTypeContext) GetParser() antlr.Parser { return s.parser } func (s *OuterAndSemiJoinTypeContext) LEFT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLEFT, 0) + return s.GetToken(StarRocksSQLParserLEFT, 0) } func (s *OuterAndSemiJoinTypeContext) JOIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOIN, 0) + return s.GetToken(StarRocksSQLParserJOIN, 0) } func (s *OuterAndSemiJoinTypeContext) RIGHT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRIGHT, 0) + return s.GetToken(StarRocksSQLParserRIGHT, 0) } func (s *OuterAndSemiJoinTypeContext) FULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFULL, 0) + return s.GetToken(StarRocksSQLParserFULL, 0) } func (s *OuterAndSemiJoinTypeContext) OUTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOUTER, 0) + return s.GetToken(StarRocksSQLParserOUTER, 0) } func (s *OuterAndSemiJoinTypeContext) SEMI() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSEMI, 0) + return s.GetToken(StarRocksSQLParserSEMI, 0) } func (s *OuterAndSemiJoinTypeContext) ANTI() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANTI, 0) + return s.GetToken(StarRocksSQLParserANTI, 0) } func (s *OuterAndSemiJoinTypeContext) GetRuleContext() antlr.RuleContext { @@ -117602,20 +117602,20 @@ func (s *OuterAndSemiJoinTypeContext) ToStringTree(ruleNames []string, recog ant } func (s *OuterAndSemiJoinTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOuterAndSemiJoinType(s) } } func (s *OuterAndSemiJoinTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOuterAndSemiJoinType(s) } } func (s *OuterAndSemiJoinTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOuterAndSemiJoinType(s) default: @@ -117623,9 +117623,9 @@ func (s *OuterAndSemiJoinTypeContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeContext) { +func (p *StarRocksSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeContext) { localctx = NewOuterAndSemiJoinTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 868, DorisSQLParserRULE_outerAndSemiJoinType) + p.EnterRule(localctx, 868, StarRocksSQLParserRULE_outerAndSemiJoinType) p.SetState(6820) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -117637,7 +117637,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 1) { p.SetState(6793) - p.Match(DorisSQLParserLEFT) + p.Match(StarRocksSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117645,7 +117645,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6794) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117656,7 +117656,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 2) { p.SetState(6795) - p.Match(DorisSQLParserRIGHT) + p.Match(StarRocksSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117664,7 +117664,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6796) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117675,7 +117675,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 3) { p.SetState(6797) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117683,7 +117683,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6798) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117694,7 +117694,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 4) { p.SetState(6799) - p.Match(DorisSQLParserLEFT) + p.Match(StarRocksSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117702,7 +117702,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6800) - p.Match(DorisSQLParserOUTER) + p.Match(StarRocksSQLParserOUTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117710,7 +117710,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6801) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117721,7 +117721,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 5) { p.SetState(6802) - p.Match(DorisSQLParserRIGHT) + p.Match(StarRocksSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117729,7 +117729,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6803) - p.Match(DorisSQLParserOUTER) + p.Match(StarRocksSQLParserOUTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117737,7 +117737,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6804) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117748,7 +117748,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 6) { p.SetState(6805) - p.Match(DorisSQLParserFULL) + p.Match(StarRocksSQLParserFULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117756,7 +117756,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6806) - p.Match(DorisSQLParserOUTER) + p.Match(StarRocksSQLParserOUTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117764,7 +117764,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6807) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117775,7 +117775,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 7) { p.SetState(6808) - p.Match(DorisSQLParserLEFT) + p.Match(StarRocksSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117783,7 +117783,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6809) - p.Match(DorisSQLParserSEMI) + p.Match(StarRocksSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117791,7 +117791,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6810) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117802,7 +117802,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 8) { p.SetState(6811) - p.Match(DorisSQLParserRIGHT) + p.Match(StarRocksSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117810,7 +117810,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6812) - p.Match(DorisSQLParserSEMI) + p.Match(StarRocksSQLParserSEMI) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117818,7 +117818,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6813) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117829,7 +117829,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 9) { p.SetState(6814) - p.Match(DorisSQLParserLEFT) + p.Match(StarRocksSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117837,7 +117837,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6815) - p.Match(DorisSQLParserANTI) + p.Match(StarRocksSQLParserANTI) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117845,7 +117845,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6816) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117856,7 +117856,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC p.EnterOuterAlt(localctx, 10) { p.SetState(6817) - p.Match(DorisSQLParserRIGHT) + p.Match(StarRocksSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117864,7 +117864,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6818) - p.Match(DorisSQLParserANTI) + p.Match(StarRocksSQLParserANTI) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117872,7 +117872,7 @@ func (p *DorisSQLParser) OuterAndSemiJoinType() (localctx IOuterAndSemiJoinTypeC } { p.SetState(6819) - p.Match(DorisSQLParserJOIN) + p.Match(StarRocksSQLParserJOIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -117922,13 +117922,13 @@ type BracketHintContext struct { func NewEmptyBracketHintContext() *BracketHintContext { var p = new(BracketHintContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_bracketHint + p.RuleIndex = StarRocksSQLParserRULE_bracketHint return p } func InitEmptyBracketHintContext(p *BracketHintContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_bracketHint + p.RuleIndex = StarRocksSQLParserRULE_bracketHint } func (*BracketHintContext) IsBracketHintContext() {} @@ -117939,7 +117939,7 @@ func NewBracketHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_bracketHint + p.RuleIndex = StarRocksSQLParserRULE_bracketHint return p } @@ -117988,7 +117988,7 @@ func (s *BracketHintContext) Identifier(i int) IIdentifierContext { } func (s *BracketHintContext) BITOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITOR, 0) + return s.GetToken(StarRocksSQLParserBITOR, 0) } func (s *BracketHintContext) PrimaryExpression() IPrimaryExpressionContext { @@ -118032,20 +118032,20 @@ func (s *BracketHintContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *BracketHintContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBracketHint(s) } } func (s *BracketHintContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBracketHint(s) } } func (s *BracketHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBracketHint(s) default: @@ -118053,9 +118053,9 @@ func (s *BracketHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { +func (p *StarRocksSQLParser) BracketHint() (localctx IBracketHintContext) { localctx = NewBracketHintContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 870, DorisSQLParserRULE_bracketHint) + p.EnterRule(localctx, 870, StarRocksSQLParserRULE_bracketHint) var _la int p.SetState(6840) @@ -118069,7 +118069,7 @@ func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(6822) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118086,10 +118086,10 @@ func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6824) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118109,7 +118109,7 @@ func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { } { p.SetState(6831) - p.Match(DorisSQLParserT__6) + p.Match(StarRocksSQLParserT__6) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118120,7 +118120,7 @@ func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(6833) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118132,7 +118132,7 @@ func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { } { p.SetState(6835) - p.Match(DorisSQLParserBITOR) + p.Match(StarRocksSQLParserBITOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118148,7 +118148,7 @@ func (p *DorisSQLParser) BracketHint() (localctx IBracketHintContext) { } { p.SetState(6838) - p.Match(DorisSQLParserT__6) + p.Match(StarRocksSQLParserT__6) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118210,13 +118210,13 @@ type HintMapContext struct { func NewEmptyHintMapContext() *HintMapContext { var p = new(HintMapContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_hintMap + p.RuleIndex = StarRocksSQLParserRULE_hintMap return p } func InitEmptyHintMapContext(p *HintMapContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_hintMap + p.RuleIndex = StarRocksSQLParserRULE_hintMap } func (*HintMapContext) IsHintMapContext() {} @@ -118227,7 +118227,7 @@ func NewHintMapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_hintMap + p.RuleIndex = StarRocksSQLParserRULE_hintMap return p } @@ -118243,7 +118243,7 @@ func (s *HintMapContext) SetK(v IIdentifierOrStringContext) { s.k = v } func (s *HintMapContext) SetV(v ILiteralExpressionContext) { s.v = v } func (s *HintMapContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *HintMapContext) IdentifierOrString() IIdentifierOrStringContext { @@ -118287,20 +118287,20 @@ func (s *HintMapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *HintMapContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterHintMap(s) } } func (s *HintMapContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitHintMap(s) } } func (s *HintMapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitHintMap(s) default: @@ -118308,9 +118308,9 @@ func (s *HintMapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) HintMap() (localctx IHintMapContext) { +func (p *StarRocksSQLParser) HintMap() (localctx IHintMapContext) { localctx = NewHintMapContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 872, DorisSQLParserRULE_hintMap) + p.EnterRule(localctx, 872, StarRocksSQLParserRULE_hintMap) p.EnterOuterAlt(localctx, 1) { p.SetState(6842) @@ -118321,7 +118321,7 @@ func (p *DorisSQLParser) HintMap() (localctx IHintMapContext) { } { p.SetState(6843) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118374,13 +118374,13 @@ type JoinCriteriaContext struct { func NewEmptyJoinCriteriaContext() *JoinCriteriaContext { var p = new(JoinCriteriaContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_joinCriteria + p.RuleIndex = StarRocksSQLParserRULE_joinCriteria return p } func InitEmptyJoinCriteriaContext(p *JoinCriteriaContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_joinCriteria + p.RuleIndex = StarRocksSQLParserRULE_joinCriteria } func (*JoinCriteriaContext) IsJoinCriteriaContext() {} @@ -118391,7 +118391,7 @@ func NewJoinCriteriaContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_joinCriteria + p.RuleIndex = StarRocksSQLParserRULE_joinCriteria return p } @@ -118399,7 +118399,7 @@ func NewJoinCriteriaContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *JoinCriteriaContext) GetParser() antlr.Parser { return s.parser } func (s *JoinCriteriaContext) ON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserON, 0) + return s.GetToken(StarRocksSQLParserON, 0) } func (s *JoinCriteriaContext) Expression() IExpressionContext { @@ -118419,7 +118419,7 @@ func (s *JoinCriteriaContext) Expression() IExpressionContext { } func (s *JoinCriteriaContext) USING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSING, 0) + return s.GetToken(StarRocksSQLParserUSING, 0) } func (s *JoinCriteriaContext) AllIdentifier() []IIdentifierContext { @@ -118472,20 +118472,20 @@ func (s *JoinCriteriaContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *JoinCriteriaContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterJoinCriteria(s) } } func (s *JoinCriteriaContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitJoinCriteria(s) } } func (s *JoinCriteriaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitJoinCriteria(s) default: @@ -118493,9 +118493,9 @@ func (s *JoinCriteriaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { +func (p *StarRocksSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { localctx = NewJoinCriteriaContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 874, DorisSQLParserRULE_joinCriteria) + p.EnterRule(localctx, 874, StarRocksSQLParserRULE_joinCriteria) var _la int p.SetState(6860) @@ -118505,11 +118505,11 @@ func (p *DorisSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserON: + case StarRocksSQLParserON: p.EnterOuterAlt(localctx, 1) { p.SetState(6846) - p.Match(DorisSQLParserON) + p.Match(StarRocksSQLParserON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118520,11 +118520,11 @@ func (p *DorisSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { p.expression(0) } - case DorisSQLParserUSING: + case StarRocksSQLParserUSING: p.EnterOuterAlt(localctx, 2) { p.SetState(6848) - p.Match(DorisSQLParserUSING) + p.Match(StarRocksSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118532,7 +118532,7 @@ func (p *DorisSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { } { p.SetState(6849) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118549,10 +118549,10 @@ func (p *DorisSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6851) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118572,7 +118572,7 @@ func (p *DorisSQLParser) JoinCriteria() (localctx IJoinCriteriaContext) { } { p.SetState(6858) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118620,13 +118620,13 @@ type ColumnAliasesContext struct { func NewEmptyColumnAliasesContext() *ColumnAliasesContext { var p = new(ColumnAliasesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnAliases + p.RuleIndex = StarRocksSQLParserRULE_columnAliases return p } func InitEmptyColumnAliasesContext(p *ColumnAliasesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnAliases + p.RuleIndex = StarRocksSQLParserRULE_columnAliases } func (*ColumnAliasesContext) IsColumnAliasesContext() {} @@ -118637,7 +118637,7 @@ func NewColumnAliasesContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnAliases + p.RuleIndex = StarRocksSQLParserRULE_columnAliases return p } @@ -118694,20 +118694,20 @@ func (s *ColumnAliasesContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *ColumnAliasesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnAliases(s) } } func (s *ColumnAliasesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnAliases(s) } } func (s *ColumnAliasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnAliases(s) default: @@ -118715,15 +118715,15 @@ func (s *ColumnAliasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) ColumnAliases() (localctx IColumnAliasesContext) { +func (p *StarRocksSQLParser) ColumnAliases() (localctx IColumnAliasesContext) { localctx = NewColumnAliasesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 876, DorisSQLParserRULE_columnAliases) + p.EnterRule(localctx, 876, StarRocksSQLParserRULE_columnAliases) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6862) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118740,10 +118740,10 @@ func (p *DorisSQLParser) ColumnAliases() (localctx IColumnAliasesContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6864) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118763,7 +118763,7 @@ func (p *DorisSQLParser) ColumnAliases() (localctx IColumnAliasesContext) { } { p.SetState(6871) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118806,13 +118806,13 @@ type ColumnAliasesWithoutParenthesesContext struct { func NewEmptyColumnAliasesWithoutParenthesesContext() *ColumnAliasesWithoutParenthesesContext { var p = new(ColumnAliasesWithoutParenthesesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnAliasesWithoutParentheses + p.RuleIndex = StarRocksSQLParserRULE_columnAliasesWithoutParentheses return p } func InitEmptyColumnAliasesWithoutParenthesesContext(p *ColumnAliasesWithoutParenthesesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnAliasesWithoutParentheses + p.RuleIndex = StarRocksSQLParserRULE_columnAliasesWithoutParentheses } func (*ColumnAliasesWithoutParenthesesContext) IsColumnAliasesWithoutParenthesesContext() {} @@ -118823,7 +118823,7 @@ func NewColumnAliasesWithoutParenthesesContext(parser antlr.Parser, parent antlr antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnAliasesWithoutParentheses + p.RuleIndex = StarRocksSQLParserRULE_columnAliasesWithoutParentheses return p } @@ -118880,20 +118880,20 @@ func (s *ColumnAliasesWithoutParenthesesContext) ToStringTree(ruleNames []string } func (s *ColumnAliasesWithoutParenthesesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnAliasesWithoutParentheses(s) } } func (s *ColumnAliasesWithoutParenthesesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnAliasesWithoutParentheses(s) } } func (s *ColumnAliasesWithoutParenthesesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnAliasesWithoutParentheses(s) default: @@ -118901,9 +118901,9 @@ func (s *ColumnAliasesWithoutParenthesesContext) Accept(visitor antlr.ParseTreeV } } -func (p *DorisSQLParser) ColumnAliasesWithoutParentheses() (localctx IColumnAliasesWithoutParenthesesContext) { +func (p *StarRocksSQLParser) ColumnAliasesWithoutParentheses() (localctx IColumnAliasesWithoutParenthesesContext) { localctx = NewColumnAliasesWithoutParenthesesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 878, DorisSQLParserRULE_columnAliasesWithoutParentheses) + p.EnterRule(localctx, 878, StarRocksSQLParserRULE_columnAliasesWithoutParentheses) var _alt int p.EnterOuterAlt(localctx, 1) @@ -118924,7 +118924,7 @@ func (p *DorisSQLParser) ColumnAliasesWithoutParentheses() (localctx IColumnAlia if _alt == 1 { { p.SetState(6874) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -118987,13 +118987,13 @@ type PartitionNamesContext struct { func NewEmptyPartitionNamesContext() *PartitionNamesContext { var p = new(PartitionNamesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionNames + p.RuleIndex = StarRocksSQLParserRULE_partitionNames return p } func InitEmptyPartitionNamesContext(p *PartitionNamesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionNames + p.RuleIndex = StarRocksSQLParserRULE_partitionNames } func (*PartitionNamesContext) IsPartitionNamesContext() {} @@ -119004,7 +119004,7 @@ func NewPartitionNamesContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionNames + p.RuleIndex = StarRocksSQLParserRULE_partitionNames return p } @@ -119053,15 +119053,15 @@ func (s *PartitionNamesContext) IdentifierOrString(i int) IIdentifierOrStringCon } func (s *PartitionNamesContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *PartitionNamesContext) PARTITIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITIONS, 0) + return s.GetToken(StarRocksSQLParserPARTITIONS, 0) } func (s *PartitionNamesContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *PartitionNamesContext) KeyPartitions() IKeyPartitionsContext { @@ -119089,20 +119089,20 @@ func (s *PartitionNamesContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *PartitionNamesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionNames(s) } } func (s *PartitionNamesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionNames(s) } } func (s *PartitionNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionNames(s) default: @@ -119110,9 +119110,9 @@ func (s *PartitionNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { +func (p *StarRocksSQLParser) PartitionNames() (localctx IPartitionNamesContext) { localctx = NewPartitionNamesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 880, DorisSQLParserRULE_partitionNames) + p.EnterRule(localctx, 880, StarRocksSQLParserRULE_partitionNames) var _la int p.SetState(6902) @@ -119131,10 +119131,10 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(6881) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119146,7 +119146,7 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { p.SetState(6884) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS) { + if !(_la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -119155,7 +119155,7 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { } { p.SetState(6885) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119172,10 +119172,10 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6887) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119195,7 +119195,7 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { } { p.SetState(6894) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119211,10 +119211,10 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserTEMPORARY { { p.SetState(6896) - p.Match(DorisSQLParserTEMPORARY) + p.Match(StarRocksSQLParserTEMPORARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119226,7 +119226,7 @@ func (p *DorisSQLParser) PartitionNames() (localctx IPartitionNamesContext) { p.SetState(6899) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS) { + if !(_la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -119280,13 +119280,13 @@ type KeyPartitionsContext struct { func NewEmptyKeyPartitionsContext() *KeyPartitionsContext { var p = new(KeyPartitionsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_keyPartitions + p.RuleIndex = StarRocksSQLParserRULE_keyPartitions return p } func InitEmptyKeyPartitionsContext(p *KeyPartitionsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_keyPartitions + p.RuleIndex = StarRocksSQLParserRULE_keyPartitions } func (*KeyPartitionsContext) IsKeyPartitionsContext() {} @@ -119297,7 +119297,7 @@ func NewKeyPartitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_keyPartitions + p.RuleIndex = StarRocksSQLParserRULE_keyPartitions return p } @@ -119335,7 +119335,7 @@ func (s *KeyPartitionListContext) GetRuleContext() antlr.RuleContext { } func (s *KeyPartitionListContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *KeyPartitionListContext) AllKeyPartition() []IKeyPartitionContext { @@ -119380,20 +119380,20 @@ func (s *KeyPartitionListContext) KeyPartition(i int) IKeyPartitionContext { } func (s *KeyPartitionListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterKeyPartitionList(s) } } func (s *KeyPartitionListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitKeyPartitionList(s) } } func (s *KeyPartitionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitKeyPartitionList(s) default: @@ -119401,16 +119401,16 @@ func (s *KeyPartitionListContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) KeyPartitions() (localctx IKeyPartitionsContext) { +func (p *StarRocksSQLParser) KeyPartitions() (localctx IKeyPartitionsContext) { localctx = NewKeyPartitionsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 882, DorisSQLParserRULE_keyPartitions) + p.EnterRule(localctx, 882, StarRocksSQLParserRULE_keyPartitions) var _la int localctx = NewKeyPartitionListContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(6904) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119418,7 +119418,7 @@ func (p *DorisSQLParser) KeyPartitions() (localctx IKeyPartitionsContext) { } { p.SetState(6905) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119435,10 +119435,10 @@ func (p *DorisSQLParser) KeyPartitions() (localctx IKeyPartitionsContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6907) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119458,7 +119458,7 @@ func (p *DorisSQLParser) KeyPartitions() (localctx IKeyPartitionsContext) { } { p.SetState(6914) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119502,13 +119502,13 @@ type TabletListContext struct { func NewEmptyTabletListContext() *TabletListContext { var p = new(TabletListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tabletList + p.RuleIndex = StarRocksSQLParserRULE_tabletList return p } func InitEmptyTabletListContext(p *TabletListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tabletList + p.RuleIndex = StarRocksSQLParserRULE_tabletList } func (*TabletListContext) IsTabletListContext() {} @@ -119519,7 +119519,7 @@ func NewTabletListContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tabletList + p.RuleIndex = StarRocksSQLParserRULE_tabletList return p } @@ -119527,15 +119527,15 @@ func NewTabletListContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *TabletListContext) GetParser() antlr.Parser { return s.parser } func (s *TabletListContext) TABLET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLET, 0) + return s.GetToken(StarRocksSQLParserTABLET, 0) } func (s *TabletListContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *TabletListContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *TabletListContext) GetRuleContext() antlr.RuleContext { @@ -119547,20 +119547,20 @@ func (s *TabletListContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *TabletListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTabletList(s) } } func (s *TabletListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTabletList(s) } } func (s *TabletListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTabletList(s) default: @@ -119568,15 +119568,15 @@ func (s *TabletListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TabletList() (localctx ITabletListContext) { +func (p *StarRocksSQLParser) TabletList() (localctx ITabletListContext) { localctx = NewTabletListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 884, DorisSQLParserRULE_tabletList) + p.EnterRule(localctx, 884, StarRocksSQLParserRULE_tabletList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6916) - p.Match(DorisSQLParserTABLET) + p.Match(StarRocksSQLParserTABLET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119584,7 +119584,7 @@ func (p *DorisSQLParser) TabletList() (localctx ITabletListContext) { } { p.SetState(6917) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119592,7 +119592,7 @@ func (p *DorisSQLParser) TabletList() (localctx ITabletListContext) { } { p.SetState(6918) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119605,10 +119605,10 @@ func (p *DorisSQLParser) TabletList() (localctx ITabletListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6919) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119616,7 +119616,7 @@ func (p *DorisSQLParser) TabletList() (localctx ITabletListContext) { } { p.SetState(6920) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119632,7 +119632,7 @@ func (p *DorisSQLParser) TabletList() (localctx ITabletListContext) { } { p.SetState(6926) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119677,13 +119677,13 @@ type PrepareStatementContext struct { func NewEmptyPrepareStatementContext() *PrepareStatementContext { var p = new(PrepareStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_prepareStatement + p.RuleIndex = StarRocksSQLParserRULE_prepareStatement return p } func InitEmptyPrepareStatementContext(p *PrepareStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_prepareStatement + p.RuleIndex = StarRocksSQLParserRULE_prepareStatement } func (*PrepareStatementContext) IsPrepareStatementContext() {} @@ -119694,7 +119694,7 @@ func NewPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_prepareStatement + p.RuleIndex = StarRocksSQLParserRULE_prepareStatement return p } @@ -119702,7 +119702,7 @@ func NewPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *PrepareStatementContext) GetParser() antlr.Parser { return s.parser } func (s *PrepareStatementContext) PREPARE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPREPARE, 0) + return s.GetToken(StarRocksSQLParserPREPARE, 0) } func (s *PrepareStatementContext) Identifier() IIdentifierContext { @@ -119722,7 +119722,7 @@ func (s *PrepareStatementContext) Identifier() IIdentifierContext { } func (s *PrepareStatementContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *PrepareStatementContext) PrepareSql() IPrepareSqlContext { @@ -119750,20 +119750,20 @@ func (s *PrepareStatementContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *PrepareStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrepareStatement(s) } } func (s *PrepareStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrepareStatement(s) } } func (s *PrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrepareStatement(s) default: @@ -119771,13 +119771,13 @@ func (s *PrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) PrepareStatement() (localctx IPrepareStatementContext) { +func (p *StarRocksSQLParser) PrepareStatement() (localctx IPrepareStatementContext) { localctx = NewPrepareStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 886, DorisSQLParserRULE_prepareStatement) + p.EnterRule(localctx, 886, StarRocksSQLParserRULE_prepareStatement) p.EnterOuterAlt(localctx, 1) { p.SetState(6928) - p.Match(DorisSQLParserPREPARE) + p.Match(StarRocksSQLParserPREPARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119789,7 +119789,7 @@ func (p *DorisSQLParser) PrepareStatement() (localctx IPrepareStatementContext) } { p.SetState(6930) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119836,13 +119836,13 @@ type PrepareSqlContext struct { func NewEmptyPrepareSqlContext() *PrepareSqlContext { var p = new(PrepareSqlContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_prepareSql + p.RuleIndex = StarRocksSQLParserRULE_prepareSql return p } func InitEmptyPrepareSqlContext(p *PrepareSqlContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_prepareSql + p.RuleIndex = StarRocksSQLParserRULE_prepareSql } func (*PrepareSqlContext) IsPrepareSqlContext() {} @@ -119853,7 +119853,7 @@ func NewPrepareSqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_prepareSql + p.RuleIndex = StarRocksSQLParserRULE_prepareSql return p } @@ -119877,7 +119877,7 @@ func (s *PrepareSqlContext) Statement() IStatementContext { } func (s *PrepareSqlContext) SINGLE_QUOTED_TEXT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSINGLE_QUOTED_TEXT, 0) + return s.GetToken(StarRocksSQLParserSINGLE_QUOTED_TEXT, 0) } func (s *PrepareSqlContext) GetRuleContext() antlr.RuleContext { @@ -119889,20 +119889,20 @@ func (s *PrepareSqlContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *PrepareSqlContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPrepareSql(s) } } func (s *PrepareSqlContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPrepareSql(s) } } func (s *PrepareSqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPrepareSql(s) default: @@ -119910,9 +119910,9 @@ func (s *PrepareSqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) PrepareSql() (localctx IPrepareSqlContext) { +func (p *StarRocksSQLParser) PrepareSql() (localctx IPrepareSqlContext) { localctx = NewPrepareSqlContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 888, DorisSQLParserRULE_prepareSql) + p.EnterRule(localctx, 888, StarRocksSQLParserRULE_prepareSql) p.SetState(6935) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -119920,18 +119920,18 @@ func (p *DorisSQLParser) PrepareSql() (localctx IPrepareSqlContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1, DorisSQLParserADD, DorisSQLParserADMIN, DorisSQLParserALTER, DorisSQLParserANALYZE, DorisSQLParserBACKUP, DorisSQLParserBEGIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCOMMIT, DorisSQLParserCREATE, DorisSQLParserDEALLOCATE, DorisSQLParserDELETE, DorisSQLParserDESC, DorisSQLParserDESCRIBE, DorisSQLParserDROP, DorisSQLParserEXECUTE, DorisSQLParserEXPLAIN, DorisSQLParserEXPORT, DorisSQLParserGRANT, DorisSQLParserHELP, DorisSQLParserINSTALL, DorisSQLParserINSERT, DorisSQLParserKILL, DorisSQLParserLOAD, DorisSQLParserPAUSE, DorisSQLParserPREPARE, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserREVOKE, DorisSQLParserROLLBACK, DorisSQLParserSELECT, DorisSQLParserSET, DorisSQLParserSHOW, DorisSQLParserSTART, DorisSQLParserSTOP, DorisSQLParserSUBMIT, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRUNCATE, DorisSQLParserUNINSTALL, DorisSQLParserUPDATE, DorisSQLParserUSE, DorisSQLParserWITH, DorisSQLParserLOCK, DorisSQLParserUNLOCK: + case StarRocksSQLParserT__1, StarRocksSQLParserADD, StarRocksSQLParserADMIN, StarRocksSQLParserALTER, StarRocksSQLParserANALYZE, StarRocksSQLParserBACKUP, StarRocksSQLParserBEGIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCOMMIT, StarRocksSQLParserCREATE, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDELETE, StarRocksSQLParserDESC, StarRocksSQLParserDESCRIBE, StarRocksSQLParserDROP, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPLAIN, StarRocksSQLParserEXPORT, StarRocksSQLParserGRANT, StarRocksSQLParserHELP, StarRocksSQLParserINSTALL, StarRocksSQLParserINSERT, StarRocksSQLParserKILL, StarRocksSQLParserLOAD, StarRocksSQLParserPAUSE, StarRocksSQLParserPREPARE, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserREVOKE, StarRocksSQLParserROLLBACK, StarRocksSQLParserSELECT, StarRocksSQLParserSET, StarRocksSQLParserSHOW, StarRocksSQLParserSTART, StarRocksSQLParserSTOP, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUPDATE, StarRocksSQLParserUSE, StarRocksSQLParserWITH, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK: p.EnterOuterAlt(localctx, 1) { p.SetState(6933) p.Statement() } - case DorisSQLParserSINGLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT: p.EnterOuterAlt(localctx, 2) { p.SetState(6934) - p.Match(DorisSQLParserSINGLE_QUOTED_TEXT) + p.Match(StarRocksSQLParserSINGLE_QUOTED_TEXT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -119984,13 +119984,13 @@ type ExecuteStatementContext struct { func NewEmptyExecuteStatementContext() *ExecuteStatementContext { var p = new(ExecuteStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_executeStatement + p.RuleIndex = StarRocksSQLParserRULE_executeStatement return p } func InitEmptyExecuteStatementContext(p *ExecuteStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_executeStatement + p.RuleIndex = StarRocksSQLParserRULE_executeStatement } func (*ExecuteStatementContext) IsExecuteStatementContext() {} @@ -120001,7 +120001,7 @@ func NewExecuteStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_executeStatement + p.RuleIndex = StarRocksSQLParserRULE_executeStatement return p } @@ -120009,7 +120009,7 @@ func NewExecuteStatementContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *ExecuteStatementContext) GetParser() antlr.Parser { return s.parser } func (s *ExecuteStatementContext) EXECUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXECUTE, 0) + return s.GetToken(StarRocksSQLParserEXECUTE, 0) } func (s *ExecuteStatementContext) Identifier() IIdentifierContext { @@ -120029,15 +120029,15 @@ func (s *ExecuteStatementContext) Identifier() IIdentifierContext { } func (s *ExecuteStatementContext) USING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSING, 0) + return s.GetToken(StarRocksSQLParserUSING, 0) } func (s *ExecuteStatementContext) AllAT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserAT) + return s.GetTokens(StarRocksSQLParserAT) } func (s *ExecuteStatementContext) AT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserAT, i) + return s.GetToken(StarRocksSQLParserAT, i) } func (s *ExecuteStatementContext) AllIdentifierOrString() []IIdentifierOrStringContext { @@ -120090,20 +120090,20 @@ func (s *ExecuteStatementContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *ExecuteStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExecuteStatement(s) } } func (s *ExecuteStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExecuteStatement(s) } } func (s *ExecuteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExecuteStatement(s) default: @@ -120111,15 +120111,15 @@ func (s *ExecuteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) ExecuteStatement() (localctx IExecuteStatementContext) { +func (p *StarRocksSQLParser) ExecuteStatement() (localctx IExecuteStatementContext) { localctx = NewExecuteStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 890, DorisSQLParserRULE_executeStatement) + p.EnterRule(localctx, 890, StarRocksSQLParserRULE_executeStatement) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6937) - p.Match(DorisSQLParserEXECUTE) + p.Match(StarRocksSQLParserEXECUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120136,10 +120136,10 @@ func (p *DorisSQLParser) ExecuteStatement() (localctx IExecuteStatementContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserUSING { + if _la == StarRocksSQLParserUSING { { p.SetState(6939) - p.Match(DorisSQLParserUSING) + p.Match(StarRocksSQLParserUSING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120147,7 +120147,7 @@ func (p *DorisSQLParser) ExecuteStatement() (localctx IExecuteStatementContext) } { p.SetState(6940) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120164,10 +120164,10 @@ func (p *DorisSQLParser) ExecuteStatement() (localctx IExecuteStatementContext) } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6942) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120175,7 +120175,7 @@ func (p *DorisSQLParser) ExecuteStatement() (localctx IExecuteStatementContext) } { p.SetState(6943) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120234,13 +120234,13 @@ type DeallocateStatementContext struct { func NewEmptyDeallocateStatementContext() *DeallocateStatementContext { var p = new(DeallocateStatementContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_deallocateStatement + p.RuleIndex = StarRocksSQLParserRULE_deallocateStatement return p } func InitEmptyDeallocateStatementContext(p *DeallocateStatementContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_deallocateStatement + p.RuleIndex = StarRocksSQLParserRULE_deallocateStatement } func (*DeallocateStatementContext) IsDeallocateStatementContext() {} @@ -120251,7 +120251,7 @@ func NewDeallocateStatementContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_deallocateStatement + p.RuleIndex = StarRocksSQLParserRULE_deallocateStatement return p } @@ -120259,7 +120259,7 @@ func NewDeallocateStatementContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *DeallocateStatementContext) GetParser() antlr.Parser { return s.parser } func (s *DeallocateStatementContext) PREPARE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPREPARE, 0) + return s.GetToken(StarRocksSQLParserPREPARE, 0) } func (s *DeallocateStatementContext) Identifier() IIdentifierContext { @@ -120279,11 +120279,11 @@ func (s *DeallocateStatementContext) Identifier() IIdentifierContext { } func (s *DeallocateStatementContext) DEALLOCATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEALLOCATE, 0) + return s.GetToken(StarRocksSQLParserDEALLOCATE, 0) } func (s *DeallocateStatementContext) DROP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDROP, 0) + return s.GetToken(StarRocksSQLParserDROP, 0) } func (s *DeallocateStatementContext) GetRuleContext() antlr.RuleContext { @@ -120295,20 +120295,20 @@ func (s *DeallocateStatementContext) ToStringTree(ruleNames []string, recog antl } func (s *DeallocateStatementContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDeallocateStatement(s) } } func (s *DeallocateStatementContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDeallocateStatement(s) } } func (s *DeallocateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDeallocateStatement(s) default: @@ -120316,9 +120316,9 @@ func (s *DeallocateStatementContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) DeallocateStatement() (localctx IDeallocateStatementContext) { +func (p *StarRocksSQLParser) DeallocateStatement() (localctx IDeallocateStatementContext) { localctx = NewDeallocateStatementContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 892, DorisSQLParserRULE_deallocateStatement) + p.EnterRule(localctx, 892, StarRocksSQLParserRULE_deallocateStatement) var _la int p.EnterOuterAlt(localctx, 1) @@ -120326,7 +120326,7 @@ func (p *DorisSQLParser) DeallocateStatement() (localctx IDeallocateStatementCon p.SetState(6952) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDEALLOCATE || _la == DorisSQLParserDROP) { + if !(_la == StarRocksSQLParserDEALLOCATE || _la == StarRocksSQLParserDROP) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -120335,7 +120335,7 @@ func (p *DorisSQLParser) DeallocateStatement() (localctx IDeallocateStatementCon } { p.SetState(6953) - p.Match(DorisSQLParserPREPARE) + p.Match(StarRocksSQLParserPREPARE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120383,13 +120383,13 @@ type ReplicaListContext struct { func NewEmptyReplicaListContext() *ReplicaListContext { var p = new(ReplicaListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_replicaList + p.RuleIndex = StarRocksSQLParserRULE_replicaList return p } func InitEmptyReplicaListContext(p *ReplicaListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_replicaList + p.RuleIndex = StarRocksSQLParserRULE_replicaList } func (*ReplicaListContext) IsReplicaListContext() {} @@ -120400,7 +120400,7 @@ func NewReplicaListContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_replicaList + p.RuleIndex = StarRocksSQLParserRULE_replicaList return p } @@ -120408,15 +120408,15 @@ func NewReplicaListContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *ReplicaListContext) GetParser() antlr.Parser { return s.parser } func (s *ReplicaListContext) REPLICA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLICA, 0) + return s.GetToken(StarRocksSQLParserREPLICA, 0) } func (s *ReplicaListContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *ReplicaListContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *ReplicaListContext) GetRuleContext() antlr.RuleContext { @@ -120428,20 +120428,20 @@ func (s *ReplicaListContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *ReplicaListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterReplicaList(s) } } func (s *ReplicaListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitReplicaList(s) } } func (s *ReplicaListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitReplicaList(s) default: @@ -120449,15 +120449,15 @@ func (s *ReplicaListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) ReplicaList() (localctx IReplicaListContext) { +func (p *StarRocksSQLParser) ReplicaList() (localctx IReplicaListContext) { localctx = NewReplicaListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 894, DorisSQLParserRULE_replicaList) + p.EnterRule(localctx, 894, StarRocksSQLParserRULE_replicaList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6956) - p.Match(DorisSQLParserREPLICA) + p.Match(StarRocksSQLParserREPLICA) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120465,7 +120465,7 @@ func (p *DorisSQLParser) ReplicaList() (localctx IReplicaListContext) { } { p.SetState(6957) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120473,7 +120473,7 @@ func (p *DorisSQLParser) ReplicaList() (localctx IReplicaListContext) { } { p.SetState(6958) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120486,10 +120486,10 @@ func (p *DorisSQLParser) ReplicaList() (localctx IReplicaListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6959) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120497,7 +120497,7 @@ func (p *DorisSQLParser) ReplicaList() (localctx IReplicaListContext) { } { p.SetState(6960) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120513,7 +120513,7 @@ func (p *DorisSQLParser) ReplicaList() (localctx IReplicaListContext) { } { p.SetState(6966) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120556,13 +120556,13 @@ type ExpressionsWithDefaultContext struct { func NewEmptyExpressionsWithDefaultContext() *ExpressionsWithDefaultContext { var p = new(ExpressionsWithDefaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionsWithDefault + p.RuleIndex = StarRocksSQLParserRULE_expressionsWithDefault return p } func InitEmptyExpressionsWithDefaultContext(p *ExpressionsWithDefaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionsWithDefault + p.RuleIndex = StarRocksSQLParserRULE_expressionsWithDefault } func (*ExpressionsWithDefaultContext) IsExpressionsWithDefaultContext() {} @@ -120573,7 +120573,7 @@ func NewExpressionsWithDefaultContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_expressionsWithDefault + p.RuleIndex = StarRocksSQLParserRULE_expressionsWithDefault return p } @@ -120630,20 +120630,20 @@ func (s *ExpressionsWithDefaultContext) ToStringTree(ruleNames []string, recog a } func (s *ExpressionsWithDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExpressionsWithDefault(s) } } func (s *ExpressionsWithDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExpressionsWithDefault(s) } } func (s *ExpressionsWithDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExpressionsWithDefault(s) default: @@ -120651,15 +120651,15 @@ func (s *ExpressionsWithDefaultContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) ExpressionsWithDefault() (localctx IExpressionsWithDefaultContext) { +func (p *StarRocksSQLParser) ExpressionsWithDefault() (localctx IExpressionsWithDefaultContext) { localctx = NewExpressionsWithDefaultContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 896, DorisSQLParserRULE_expressionsWithDefault) + p.EnterRule(localctx, 896, StarRocksSQLParserRULE_expressionsWithDefault) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(6968) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120676,10 +120676,10 @@ func (p *DorisSQLParser) ExpressionsWithDefault() (localctx IExpressionsWithDefa } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6970) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120699,7 +120699,7 @@ func (p *DorisSQLParser) ExpressionsWithDefault() (localctx IExpressionsWithDefa } { p.SetState(6977) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120742,13 +120742,13 @@ type ExpressionOrDefaultContext struct { func NewEmptyExpressionOrDefaultContext() *ExpressionOrDefaultContext { var p = new(ExpressionOrDefaultContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionOrDefault + p.RuleIndex = StarRocksSQLParserRULE_expressionOrDefault return p } func InitEmptyExpressionOrDefaultContext(p *ExpressionOrDefaultContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionOrDefault + p.RuleIndex = StarRocksSQLParserRULE_expressionOrDefault } func (*ExpressionOrDefaultContext) IsExpressionOrDefaultContext() {} @@ -120759,7 +120759,7 @@ func NewExpressionOrDefaultContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_expressionOrDefault + p.RuleIndex = StarRocksSQLParserRULE_expressionOrDefault return p } @@ -120783,7 +120783,7 @@ func (s *ExpressionOrDefaultContext) Expression() IExpressionContext { } func (s *ExpressionOrDefaultContext) DEFAULT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFAULT, 0) + return s.GetToken(StarRocksSQLParserDEFAULT, 0) } func (s *ExpressionOrDefaultContext) GetRuleContext() antlr.RuleContext { @@ -120795,20 +120795,20 @@ func (s *ExpressionOrDefaultContext) ToStringTree(ruleNames []string, recog antl } func (s *ExpressionOrDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExpressionOrDefault(s) } } func (s *ExpressionOrDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExpressionOrDefault(s) } } func (s *ExpressionOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExpressionOrDefault(s) default: @@ -120816,9 +120816,9 @@ func (s *ExpressionOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ExpressionOrDefault() (localctx IExpressionOrDefaultContext) { +func (p *StarRocksSQLParser) ExpressionOrDefault() (localctx IExpressionOrDefaultContext) { localctx = NewExpressionOrDefaultContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 898, DorisSQLParserRULE_expressionOrDefault) + p.EnterRule(localctx, 898, StarRocksSQLParserRULE_expressionOrDefault) p.SetState(6981) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -120826,18 +120826,18 @@ func (p *DorisSQLParser) ExpressionOrDefault() (localctx IExpressionOrDefaultCon } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1, DorisSQLParserT__5, DorisSQLParserT__8, DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCASE, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHAR, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCONVERT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserCURRENT_DATE, DorisSQLParserCURRENT_GROUP, DorisSQLParserCURRENT_ROLE, DorisSQLParserCURRENT_TIME, DorisSQLParserCURRENT_TIMESTAMP, DorisSQLParserCURRENT_USER, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATABASE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDENSE_RANK, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserNTILE, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXISTS, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFALSE, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFIRST_VALUE, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUPING, DorisSQLParserGROUPING_ID, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIF, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAG, DorisSQLParserLAST, DorisSQLParserLAST_VALUE, DorisSQLParserLEAD, DorisSQLParserLEFT, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIKE, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCALTIME, DorisSQLParserLOCALTIMESTAMP, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMOD, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNOT, DorisSQLParserNULL, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARAMETER, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREGEXP, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserRIGHT, DorisSQLParserRLIKE, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserROW_NUMBER, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSCHEMA, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserPLUS_SYMBOL, DorisSQLParserMINUS_SYMBOL, DorisSQLParserLOGICAL_NOT, DorisSQLParserBITNOT, DorisSQLParserAT, DorisSQLParserINTEGER_VALUE, DorisSQLParserDECIMAL_VALUE, DorisSQLParserDOUBLE_VALUE, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserBINARY_SINGLE_QUOTED_TEXT, DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserT__1, StarRocksSQLParserT__5, StarRocksSQLParserT__8, StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCASE, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHAR, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCONVERT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserCURRENT_DATE, StarRocksSQLParserCURRENT_GROUP, StarRocksSQLParserCURRENT_ROLE, StarRocksSQLParserCURRENT_TIME, StarRocksSQLParserCURRENT_TIMESTAMP, StarRocksSQLParserCURRENT_USER, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATABASE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDENSE_RANK, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserNTILE, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXISTS, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFALSE, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFIRST_VALUE, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUPING, StarRocksSQLParserGROUPING_ID, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIF, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAG, StarRocksSQLParserLAST, StarRocksSQLParserLAST_VALUE, StarRocksSQLParserLEAD, StarRocksSQLParserLEFT, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIKE, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCALTIME, StarRocksSQLParserLOCALTIMESTAMP, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMOD, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNOT, StarRocksSQLParserNULL, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARAMETER, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREGEXP, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserRIGHT, StarRocksSQLParserRLIKE, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserROW_NUMBER, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSCHEMA, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserPLUS_SYMBOL, StarRocksSQLParserMINUS_SYMBOL, StarRocksSQLParserLOGICAL_NOT, StarRocksSQLParserBITNOT, StarRocksSQLParserAT, StarRocksSQLParserINTEGER_VALUE, StarRocksSQLParserDECIMAL_VALUE, StarRocksSQLParserDOUBLE_VALUE, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT, StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: p.EnterOuterAlt(localctx, 1) { p.SetState(6979) p.expression(0) } - case DorisSQLParserDEFAULT: + case StarRocksSQLParserDEFAULT: p.EnterOuterAlt(localctx, 2) { p.SetState(6980) - p.Match(DorisSQLParserDEFAULT) + p.Match(StarRocksSQLParserDEFAULT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -120885,13 +120885,13 @@ type MapExpressionListContext struct { func NewEmptyMapExpressionListContext() *MapExpressionListContext { var p = new(MapExpressionListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mapExpressionList + p.RuleIndex = StarRocksSQLParserRULE_mapExpressionList return p } func InitEmptyMapExpressionListContext(p *MapExpressionListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mapExpressionList + p.RuleIndex = StarRocksSQLParserRULE_mapExpressionList } func (*MapExpressionListContext) IsMapExpressionListContext() {} @@ -120902,7 +120902,7 @@ func NewMapExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_mapExpressionList + p.RuleIndex = StarRocksSQLParserRULE_mapExpressionList return p } @@ -120959,20 +120959,20 @@ func (s *MapExpressionListContext) ToStringTree(ruleNames []string, recog antlr. } func (s *MapExpressionListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMapExpressionList(s) } } func (s *MapExpressionListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMapExpressionList(s) } } func (s *MapExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMapExpressionList(s) default: @@ -120980,9 +120980,9 @@ func (s *MapExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) MapExpressionList() (localctx IMapExpressionListContext) { +func (p *StarRocksSQLParser) MapExpressionList() (localctx IMapExpressionListContext) { localctx = NewMapExpressionListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 900, DorisSQLParserRULE_mapExpressionList) + p.EnterRule(localctx, 900, StarRocksSQLParserRULE_mapExpressionList) var _la int p.EnterOuterAlt(localctx, 1) @@ -120997,10 +120997,10 @@ func (p *DorisSQLParser) MapExpressionList() (localctx IMapExpressionListContext } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(6984) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -121069,13 +121069,13 @@ type MapExpressionContext struct { func NewEmptyMapExpressionContext() *MapExpressionContext { var p = new(MapExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mapExpression + p.RuleIndex = StarRocksSQLParserRULE_mapExpression return p } func InitEmptyMapExpressionContext(p *MapExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mapExpression + p.RuleIndex = StarRocksSQLParserRULE_mapExpression } func (*MapExpressionContext) IsMapExpressionContext() {} @@ -121086,7 +121086,7 @@ func NewMapExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_mapExpression + p.RuleIndex = StarRocksSQLParserRULE_mapExpression return p } @@ -121151,20 +121151,20 @@ func (s *MapExpressionContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *MapExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMapExpression(s) } } func (s *MapExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMapExpression(s) } } func (s *MapExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMapExpression(s) default: @@ -121172,9 +121172,9 @@ func (s *MapExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) MapExpression() (localctx IMapExpressionContext) { +func (p *StarRocksSQLParser) MapExpression() (localctx IMapExpressionContext) { localctx = NewMapExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 902, DorisSQLParserRULE_mapExpression) + p.EnterRule(localctx, 902, StarRocksSQLParserRULE_mapExpression) p.EnterOuterAlt(localctx, 1) { p.SetState(6991) @@ -121185,7 +121185,7 @@ func (p *DorisSQLParser) MapExpression() (localctx IMapExpressionContext) { } { p.SetState(6992) - p.Match(DorisSQLParserT__7) + p.Match(StarRocksSQLParserT__7) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -121235,13 +121235,13 @@ type ExpressionSingletonContext struct { func NewEmptyExpressionSingletonContext() *ExpressionSingletonContext { var p = new(ExpressionSingletonContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionSingleton + p.RuleIndex = StarRocksSQLParserRULE_expressionSingleton return p } func InitEmptyExpressionSingletonContext(p *ExpressionSingletonContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionSingleton + p.RuleIndex = StarRocksSQLParserRULE_expressionSingleton } func (*ExpressionSingletonContext) IsExpressionSingletonContext() {} @@ -121252,7 +121252,7 @@ func NewExpressionSingletonContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_expressionSingleton + p.RuleIndex = StarRocksSQLParserRULE_expressionSingleton return p } @@ -121276,7 +121276,7 @@ func (s *ExpressionSingletonContext) Expression() IExpressionContext { } func (s *ExpressionSingletonContext) EOF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEOF, 0) + return s.GetToken(StarRocksSQLParserEOF, 0) } func (s *ExpressionSingletonContext) GetRuleContext() antlr.RuleContext { @@ -121288,20 +121288,20 @@ func (s *ExpressionSingletonContext) ToStringTree(ruleNames []string, recog antl } func (s *ExpressionSingletonContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExpressionSingleton(s) } } func (s *ExpressionSingletonContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExpressionSingleton(s) } } func (s *ExpressionSingletonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExpressionSingleton(s) default: @@ -121309,9 +121309,9 @@ func (s *ExpressionSingletonContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ExpressionSingleton() (localctx IExpressionSingletonContext) { +func (p *StarRocksSQLParser) ExpressionSingleton() (localctx IExpressionSingletonContext) { localctx = NewExpressionSingletonContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 904, DorisSQLParserRULE_expressionSingleton) + p.EnterRule(localctx, 904, StarRocksSQLParserRULE_expressionSingleton) p.EnterOuterAlt(localctx, 1) { p.SetState(6995) @@ -121319,7 +121319,7 @@ func (p *DorisSQLParser) ExpressionSingleton() (localctx IExpressionSingletonCon } { p.SetState(6996) - p.Match(DorisSQLParserEOF) + p.Match(StarRocksSQLParserEOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -121357,13 +121357,13 @@ type ExpressionContext struct { func NewEmptyExpressionContext() *ExpressionContext { var p = new(ExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expression + p.RuleIndex = StarRocksSQLParserRULE_expression return p } func InitEmptyExpressionContext(p *ExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expression + p.RuleIndex = StarRocksSQLParserRULE_expression } func (*ExpressionContext) IsExpressionContext() {} @@ -121374,7 +121374,7 @@ func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_expression + p.RuleIndex = StarRocksSQLParserRULE_expression return p } @@ -121428,24 +121428,24 @@ func (s *ExpressionDefaultContext) BooleanExpression() IBooleanExpressionContext } func (s *ExpressionDefaultContext) BINARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBINARY, 0) + return s.GetToken(StarRocksSQLParserBINARY, 0) } func (s *ExpressionDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExpressionDefault(s) } } func (s *ExpressionDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExpressionDefault(s) } } func (s *ExpressionDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExpressionDefault(s) default: @@ -121472,7 +121472,7 @@ func (s *LogicalNotContext) GetRuleContext() antlr.RuleContext { } func (s *LogicalNotContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *LogicalNotContext) Expression() IExpressionContext { @@ -121492,20 +121492,20 @@ func (s *LogicalNotContext) Expression() IExpressionContext { } func (s *LogicalNotContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLogicalNot(s) } } func (s *LogicalNotContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLogicalNot(s) } } func (s *LogicalNotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLogicalNot(s) default: @@ -121588,36 +121588,36 @@ func (s *LogicalBinaryContext) Expression(i int) IExpressionContext { } func (s *LogicalBinaryContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *LogicalBinaryContext) LOGICAL_AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGICAL_AND, 0) + return s.GetToken(StarRocksSQLParserLOGICAL_AND, 0) } func (s *LogicalBinaryContext) OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOR, 0) + return s.GetToken(StarRocksSQLParserOR, 0) } func (s *LogicalBinaryContext) LOGICAL_OR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGICAL_OR, 0) + return s.GetToken(StarRocksSQLParserLOGICAL_OR, 0) } func (s *LogicalBinaryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLogicalBinary(s) } } func (s *LogicalBinaryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLogicalBinary(s) } } func (s *LogicalBinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLogicalBinary(s) default: @@ -121625,11 +121625,11 @@ func (s *LogicalBinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) Expression() (localctx IExpressionContext) { +func (p *StarRocksSQLParser) Expression() (localctx IExpressionContext) { return p.expression(0) } -func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { +func (p *StarRocksSQLParser) expression(_p int) (localctx IExpressionContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() @@ -121637,7 +121637,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { var _prevctx IExpressionContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 906 - p.EnterRecursionRule(localctx, 906, DorisSQLParserRULE_expression, _p) + p.EnterRecursionRule(localctx, 906, StarRocksSQLParserRULE_expression, _p) var _la int var _alt int @@ -121650,7 +121650,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserT__1, DorisSQLParserT__5, DorisSQLParserT__8, DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCASE, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHAR, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCONVERT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserCURRENT_DATE, DorisSQLParserCURRENT_GROUP, DorisSQLParserCURRENT_ROLE, DorisSQLParserCURRENT_TIME, DorisSQLParserCURRENT_TIMESTAMP, DorisSQLParserCURRENT_USER, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATABASE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDENSE_RANK, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserNTILE, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXISTS, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFALSE, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFIRST_VALUE, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUPING, DorisSQLParserGROUPING_ID, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIF, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAG, DorisSQLParserLAST, DorisSQLParserLAST_VALUE, DorisSQLParserLEAD, DorisSQLParserLEFT, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIKE, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCALTIME, DorisSQLParserLOCALTIMESTAMP, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMOD, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULL, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARAMETER, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREGEXP, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserRIGHT, DorisSQLParserRLIKE, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserROW_NUMBER, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSCHEMA, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserPLUS_SYMBOL, DorisSQLParserMINUS_SYMBOL, DorisSQLParserLOGICAL_NOT, DorisSQLParserBITNOT, DorisSQLParserAT, DorisSQLParserINTEGER_VALUE, DorisSQLParserDECIMAL_VALUE, DorisSQLParserDOUBLE_VALUE, DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT, DorisSQLParserBINARY_SINGLE_QUOTED_TEXT, DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserT__1, StarRocksSQLParserT__5, StarRocksSQLParserT__8, StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCASE, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHAR, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCONVERT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserCURRENT_DATE, StarRocksSQLParserCURRENT_GROUP, StarRocksSQLParserCURRENT_ROLE, StarRocksSQLParserCURRENT_TIME, StarRocksSQLParserCURRENT_TIMESTAMP, StarRocksSQLParserCURRENT_USER, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATABASE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDENSE_RANK, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserNTILE, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXISTS, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFALSE, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFIRST_VALUE, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUPING, StarRocksSQLParserGROUPING_ID, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIF, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAG, StarRocksSQLParserLAST, StarRocksSQLParserLAST_VALUE, StarRocksSQLParserLEAD, StarRocksSQLParserLEFT, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIKE, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCALTIME, StarRocksSQLParserLOCALTIMESTAMP, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMOD, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULL, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARAMETER, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREGEXP, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserRIGHT, StarRocksSQLParserRLIKE, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserROW_NUMBER, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSCHEMA, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserPLUS_SYMBOL, StarRocksSQLParserMINUS_SYMBOL, StarRocksSQLParserLOGICAL_NOT, StarRocksSQLParserBITNOT, StarRocksSQLParserAT, StarRocksSQLParserINTEGER_VALUE, StarRocksSQLParserDECIMAL_VALUE, StarRocksSQLParserDOUBLE_VALUE, StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT, StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT, StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: localctx = NewExpressionDefaultContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx @@ -121661,7 +121661,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 797, p.GetParserRuleContext()) == 1 { { p.SetState(6999) - p.Match(DorisSQLParserBINARY) + p.Match(StarRocksSQLParserBINARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -121676,13 +121676,13 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { p.booleanExpression(0) } - case DorisSQLParserNOT: + case StarRocksSQLParserNOT: localctx = NewLogicalNotContext(p, localctx) p.SetParserRuleContext(localctx) _prevctx = localctx { p.SetState(7003) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -121724,7 +121724,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { localctx = NewLogicalBinaryContext(p, NewExpressionContext(p, _parentctx, _parentState)) localctx.(*LogicalBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_expression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_expression) p.SetState(7007) if !(p.Precpred(p.GetParserRuleContext(), 2)) { @@ -121740,7 +121740,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserAND || _la == DorisSQLParserLOGICAL_AND) { + if !(_la == StarRocksSQLParserAND || _la == StarRocksSQLParserLOGICAL_AND) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*LogicalBinaryContext).operator = _ri @@ -121761,7 +121761,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { localctx = NewLogicalBinaryContext(p, NewExpressionContext(p, _parentctx, _parentState)) localctx.(*LogicalBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_expression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_expression) p.SetState(7010) if !(p.Precpred(p.GetParserRuleContext(), 1)) { @@ -121777,7 +121777,7 @@ func (p *DorisSQLParser) expression(_p int) (localctx IExpressionContext) { _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserOR || _la == DorisSQLParserLOGICAL_OR) { + if !(_la == StarRocksSQLParserOR || _la == StarRocksSQLParserLOGICAL_OR) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*LogicalBinaryContext).operator = _ri @@ -121846,13 +121846,13 @@ type ExpressionListContext struct { func NewEmptyExpressionListContext() *ExpressionListContext { var p = new(ExpressionListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionList + p.RuleIndex = StarRocksSQLParserRULE_expressionList return p } func InitEmptyExpressionListContext(p *ExpressionListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_expressionList + p.RuleIndex = StarRocksSQLParserRULE_expressionList } func (*ExpressionListContext) IsExpressionListContext() {} @@ -121863,7 +121863,7 @@ func NewExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_expressionList + p.RuleIndex = StarRocksSQLParserRULE_expressionList return p } @@ -121920,20 +121920,20 @@ func (s *ExpressionListContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *ExpressionListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExpressionList(s) } } func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExpressionList(s) } } func (s *ExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExpressionList(s) default: @@ -121941,9 +121941,9 @@ func (s *ExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) ExpressionList() (localctx IExpressionListContext) { +func (p *StarRocksSQLParser) ExpressionList() (localctx IExpressionListContext) { localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 908, DorisSQLParserRULE_expressionList) + p.EnterRule(localctx, 908, StarRocksSQLParserRULE_expressionList) var _alt int p.EnterOuterAlt(localctx, 1) @@ -121964,7 +121964,7 @@ func (p *DorisSQLParser) ExpressionList() (localctx IExpressionListContext) { if _alt == 1 { { p.SetState(7019) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122018,13 +122018,13 @@ type BooleanExpressionContext struct { func NewEmptyBooleanExpressionContext() *BooleanExpressionContext { var p = new(BooleanExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_booleanExpression + p.RuleIndex = StarRocksSQLParserRULE_booleanExpression return p } func InitEmptyBooleanExpressionContext(p *BooleanExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_booleanExpression + p.RuleIndex = StarRocksSQLParserRULE_booleanExpression } func (*BooleanExpressionContext) IsBooleanExpressionContext() {} @@ -122035,7 +122035,7 @@ func NewBooleanExpressionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_booleanExpression + p.RuleIndex = StarRocksSQLParserRULE_booleanExpression return p } @@ -122131,20 +122131,20 @@ func (s *ComparisonContext) Predicate() IPredicateContext { } func (s *ComparisonContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterComparison(s) } } func (s *ComparisonContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitComparison(s) } } func (s *ComparisonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitComparison(s) default: @@ -122187,20 +122187,20 @@ func (s *BooleanExpressionDefaultContext) Predicate() IPredicateContext { } func (s *BooleanExpressionDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBooleanExpressionDefault(s) } } func (s *BooleanExpressionDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBooleanExpressionDefault(s) } } func (s *BooleanExpressionDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBooleanExpressionDefault(s) default: @@ -122243,32 +122243,32 @@ func (s *IsNullContext) BooleanExpression() IBooleanExpressionContext { } func (s *IsNullContext) IS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIS, 0) + return s.GetToken(StarRocksSQLParserIS, 0) } func (s *IsNullContext) NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULL, 0) + return s.GetToken(StarRocksSQLParserNULL, 0) } func (s *IsNullContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *IsNullContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIsNull(s) } } func (s *IsNullContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIsNull(s) } } func (s *IsNullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIsNull(s) default: @@ -122343,20 +122343,20 @@ func (s *ScalarSubqueryContext) QueryRelation() IQueryRelationContext { } func (s *ScalarSubqueryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterScalarSubquery(s) } } func (s *ScalarSubqueryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitScalarSubquery(s) } } func (s *ScalarSubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitScalarSubquery(s) default: @@ -122364,11 +122364,11 @@ func (s *ScalarSubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) BooleanExpression() (localctx IBooleanExpressionContext) { +func (p *StarRocksSQLParser) BooleanExpression() (localctx IBooleanExpressionContext) { return p.booleanExpression(0) } -func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionContext) { +func (p *StarRocksSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() @@ -122376,7 +122376,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC var _prevctx IBooleanExpressionContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 910 - p.EnterRecursionRule(localctx, 910, DorisSQLParserRULE_booleanExpression, _p) + p.EnterRecursionRule(localctx, 910, StarRocksSQLParserRULE_booleanExpression, _p) var _la int var _alt int @@ -122416,7 +122416,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 803, p.GetParserRuleContext()) { case 1: localctx = NewIsNullContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_booleanExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_booleanExpression) p.SetState(7029) if !(p.Precpred(p.GetParserRuleContext(), 3)) { @@ -122425,7 +122425,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC } { p.SetState(7030) - p.Match(DorisSQLParserIS) + p.Match(StarRocksSQLParserIS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122438,10 +122438,10 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7031) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122451,7 +122451,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC } { p.SetState(7034) - p.Match(DorisSQLParserNULL) + p.Match(StarRocksSQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122462,7 +122462,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC localctx = NewComparisonContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) localctx.(*ComparisonContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_booleanExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_booleanExpression) p.SetState(7035) if !(p.Precpred(p.GetParserRuleContext(), 2)) { @@ -122483,7 +122483,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC case 3: localctx = NewScalarSubqueryContext(p, NewBooleanExpressionContext(p, _parentctx, _parentState)) - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_booleanExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_booleanExpression) p.SetState(7039) if !(p.Precpred(p.GetParserRuleContext(), 1)) { @@ -122496,7 +122496,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC } { p.SetState(7041) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122508,7 +122508,7 @@ func (p *DorisSQLParser) booleanExpression(_p int) (localctx IBooleanExpressionC } { p.SetState(7043) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122575,13 +122575,13 @@ type PredicateContext struct { func NewEmptyPredicateContext() *PredicateContext { var p = new(PredicateContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_predicate + p.RuleIndex = StarRocksSQLParserRULE_predicate return p } func InitEmptyPredicateContext(p *PredicateContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_predicate + p.RuleIndex = StarRocksSQLParserRULE_predicate } func (*PredicateContext) IsPredicateContext() {} @@ -122592,7 +122592,7 @@ func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_predicate + p.RuleIndex = StarRocksSQLParserRULE_predicate return p } @@ -122660,20 +122660,20 @@ func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *PredicateContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPredicate(s) } } func (s *PredicateContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPredicate(s) } } func (s *PredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPredicate(s) default: @@ -122681,9 +122681,9 @@ func (s *PredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Predicate() (localctx IPredicateContext) { +func (p *StarRocksSQLParser) Predicate() (localctx IPredicateContext) { localctx = NewPredicateContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 912, DorisSQLParserRULE_predicate) + p.EnterRule(localctx, 912, StarRocksSQLParserRULE_predicate) p.SetState(7055) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -122763,13 +122763,13 @@ type TupleInSubqueryContext struct { func NewEmptyTupleInSubqueryContext() *TupleInSubqueryContext { var p = new(TupleInSubqueryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tupleInSubquery + p.RuleIndex = StarRocksSQLParserRULE_tupleInSubquery return p } func InitEmptyTupleInSubqueryContext(p *TupleInSubqueryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tupleInSubquery + p.RuleIndex = StarRocksSQLParserRULE_tupleInSubquery } func (*TupleInSubqueryContext) IsTupleInSubqueryContext() {} @@ -122780,7 +122780,7 @@ func NewTupleInSubqueryContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tupleInSubquery + p.RuleIndex = StarRocksSQLParserRULE_tupleInSubquery return p } @@ -122829,7 +122829,7 @@ func (s *TupleInSubqueryContext) Expression(i int) IExpressionContext { } func (s *TupleInSubqueryContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *TupleInSubqueryContext) QueryRelation() IQueryRelationContext { @@ -122849,7 +122849,7 @@ func (s *TupleInSubqueryContext) QueryRelation() IQueryRelationContext { } func (s *TupleInSubqueryContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *TupleInSubqueryContext) GetRuleContext() antlr.RuleContext { @@ -122861,20 +122861,20 @@ func (s *TupleInSubqueryContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *TupleInSubqueryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTupleInSubquery(s) } } func (s *TupleInSubqueryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTupleInSubquery(s) } } func (s *TupleInSubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTupleInSubquery(s) default: @@ -122882,15 +122882,15 @@ func (s *TupleInSubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { +func (p *StarRocksSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { localctx = NewTupleInSubqueryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 914, DorisSQLParserRULE_tupleInSubquery) + p.EnterRule(localctx, 914, StarRocksSQLParserRULE_tupleInSubquery) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7057) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122907,10 +122907,10 @@ func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == DorisSQLParserT__2 { + for ok := true; ok; ok = _la == StarRocksSQLParserT__2 { { p.SetState(7059) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122930,7 +122930,7 @@ func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { } { p.SetState(7065) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122943,10 +122943,10 @@ func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7066) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122956,7 +122956,7 @@ func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { } { p.SetState(7069) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122964,7 +122964,7 @@ func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { } { p.SetState(7070) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -122976,7 +122976,7 @@ func (p *DorisSQLParser) TupleInSubquery() (localctx ITupleInSubqueryContext) { } { p.SetState(7072) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123022,13 +123022,13 @@ type PredicateOperationsContext struct { func NewEmptyPredicateOperationsContext() *PredicateOperationsContext { var p = new(PredicateOperationsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_predicateOperations + p.RuleIndex = StarRocksSQLParserRULE_predicateOperations return p } func InitEmptyPredicateOperationsContext(p *PredicateOperationsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_predicateOperations + p.RuleIndex = StarRocksSQLParserRULE_predicateOperations } func (*PredicateOperationsContext) IsPredicateOperationsContext() {} @@ -123039,7 +123039,7 @@ func NewPredicateOperationsContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_predicateOperations + p.RuleIndex = StarRocksSQLParserRULE_predicateOperations p.value = value @@ -123089,15 +123089,15 @@ func (s *LikeContext) GetRuleContext() antlr.RuleContext { } func (s *LikeContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *LikeContext) RLIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRLIKE, 0) + return s.GetToken(StarRocksSQLParserRLIKE, 0) } func (s *LikeContext) REGEXP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREGEXP, 0) + return s.GetToken(StarRocksSQLParserREGEXP, 0) } func (s *LikeContext) ValueExpression() IValueExpressionContext { @@ -123117,24 +123117,24 @@ func (s *LikeContext) ValueExpression() IValueExpressionContext { } func (s *LikeContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *LikeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLike(s) } } func (s *LikeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLike(s) } } func (s *LikeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLike(s) default: @@ -123161,7 +123161,7 @@ func (s *InSubqueryContext) GetRuleContext() antlr.RuleContext { } func (s *InSubqueryContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *InSubqueryContext) QueryRelation() IQueryRelationContext { @@ -123181,24 +123181,24 @@ func (s *InSubqueryContext) QueryRelation() IQueryRelationContext { } func (s *InSubqueryContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *InSubqueryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInSubquery(s) } } func (s *InSubqueryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInSubquery(s) } } func (s *InSubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInSubquery(s) default: @@ -123225,7 +123225,7 @@ func (s *InListContext) GetRuleContext() antlr.RuleContext { } func (s *InListContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *InListContext) ExpressionList() IExpressionListContext { @@ -123245,24 +123245,24 @@ func (s *InListContext) ExpressionList() IExpressionListContext { } func (s *InListContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *InListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInList(s) } } func (s *InListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInList(s) } } func (s *InListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInList(s) default: @@ -123299,11 +123299,11 @@ func (s *BetweenContext) GetRuleContext() antlr.RuleContext { } func (s *BetweenContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBETWEEN, 0) + return s.GetToken(StarRocksSQLParserBETWEEN, 0) } func (s *BetweenContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *BetweenContext) ValueExpression() IValueExpressionContext { @@ -123339,24 +123339,24 @@ func (s *BetweenContext) Predicate() IPredicateContext { } func (s *BetweenContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *BetweenContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBetween(s) } } func (s *BetweenContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBetween(s) } } func (s *BetweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBetween(s) default: @@ -123364,9 +123364,9 @@ func (s *BetweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (localctx IPredicateOperationsContext) { +func (p *StarRocksSQLParser) PredicateOperations(value antlr.ParserRuleContext) (localctx IPredicateOperationsContext) { localctx = NewPredicateOperationsContext(p, p.GetParserRuleContext(), p.GetState(), value) - p.EnterRule(localctx, 916, DorisSQLParserRULE_predicateOperations) + p.EnterRule(localctx, 916, StarRocksSQLParserRULE_predicateOperations) var _la int p.SetState(7103) @@ -123386,10 +123386,10 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7074) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123399,7 +123399,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7077) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123407,7 +123407,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7078) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123419,7 +123419,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7080) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123436,10 +123436,10 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7082) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123449,7 +123449,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7085) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123457,7 +123457,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7086) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123469,7 +123469,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7088) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123486,10 +123486,10 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7090) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123499,7 +123499,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7093) - p.Match(DorisSQLParserBETWEEN) + p.Match(StarRocksSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123514,7 +123514,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } { p.SetState(7095) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123538,10 +123538,10 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7098) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -123553,7 +123553,7 @@ func (p *DorisSQLParser) PredicateOperations(value antlr.ParserRuleContext) (loc p.SetState(7101) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserLIKE || _la == DorisSQLParserREGEXP || _la == DorisSQLParserRLIKE) { + if !(_la == StarRocksSQLParserLIKE || _la == StarRocksSQLParserREGEXP || _la == StarRocksSQLParserRLIKE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -123603,13 +123603,13 @@ type ValueExpressionContext struct { func NewEmptyValueExpressionContext() *ValueExpressionContext { var p = new(ValueExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_valueExpression + p.RuleIndex = StarRocksSQLParserRULE_valueExpression return p } func InitEmptyValueExpressionContext(p *ValueExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_valueExpression + p.RuleIndex = StarRocksSQLParserRULE_valueExpression } func (*ValueExpressionContext) IsValueExpressionContext() {} @@ -123620,7 +123620,7 @@ func NewValueExpressionContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_valueExpression + p.RuleIndex = StarRocksSQLParserRULE_valueExpression return p } @@ -123674,20 +123674,20 @@ func (s *ValueExpressionDefaultContext) PrimaryExpression() IPrimaryExpressionCo } func (s *ValueExpressionDefaultContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterValueExpressionDefault(s) } } func (s *ValueExpressionDefaultContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitValueExpressionDefault(s) } } func (s *ValueExpressionDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitValueExpressionDefault(s) default: @@ -123770,72 +123770,72 @@ func (s *ArithmeticBinaryContext) ValueExpression(i int) IValueExpressionContext } func (s *ArithmeticBinaryContext) BITXOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITXOR, 0) + return s.GetToken(StarRocksSQLParserBITXOR, 0) } func (s *ArithmeticBinaryContext) ASTERISK_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASTERISK_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserASTERISK_SYMBOL, 0) } func (s *ArithmeticBinaryContext) SLASH_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSLASH_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserSLASH_SYMBOL, 0) } func (s *ArithmeticBinaryContext) PERCENT_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERCENT_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserPERCENT_SYMBOL, 0) } func (s *ArithmeticBinaryContext) INT_DIV() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINT_DIV, 0) + return s.GetToken(StarRocksSQLParserINT_DIV, 0) } func (s *ArithmeticBinaryContext) MOD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMOD, 0) + return s.GetToken(StarRocksSQLParserMOD, 0) } func (s *ArithmeticBinaryContext) PLUS_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUS_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserPLUS_SYMBOL, 0) } func (s *ArithmeticBinaryContext) MINUS_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUS_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserMINUS_SYMBOL, 0) } func (s *ArithmeticBinaryContext) BITAND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITAND, 0) + return s.GetToken(StarRocksSQLParserBITAND, 0) } func (s *ArithmeticBinaryContext) BITOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITOR, 0) + return s.GetToken(StarRocksSQLParserBITOR, 0) } func (s *ArithmeticBinaryContext) BIT_SHIFT_LEFT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBIT_SHIFT_LEFT, 0) + return s.GetToken(StarRocksSQLParserBIT_SHIFT_LEFT, 0) } func (s *ArithmeticBinaryContext) BIT_SHIFT_RIGHT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBIT_SHIFT_RIGHT, 0) + return s.GetToken(StarRocksSQLParserBIT_SHIFT_RIGHT, 0) } func (s *ArithmeticBinaryContext) BIT_SHIFT_RIGHT_LOGICAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBIT_SHIFT_RIGHT_LOGICAL, 0) + return s.GetToken(StarRocksSQLParserBIT_SHIFT_RIGHT_LOGICAL, 0) } func (s *ArithmeticBinaryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArithmeticBinary(s) } } func (s *ArithmeticBinaryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArithmeticBinary(s) } } func (s *ArithmeticBinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArithmeticBinary(s) default: @@ -123843,11 +123843,11 @@ func (s *ArithmeticBinaryContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) ValueExpression() (localctx IValueExpressionContext) { +func (p *StarRocksSQLParser) ValueExpression() (localctx IValueExpressionContext) { return p.valueExpression(0) } -func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionContext) { +func (p *StarRocksSQLParser) valueExpression(_p int) (localctx IValueExpressionContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() @@ -123855,7 +123855,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte var _prevctx IValueExpressionContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 918 - p.EnterRecursionRule(localctx, 918, DorisSQLParserRULE_valueExpression, _p) + p.EnterRecursionRule(localctx, 918, StarRocksSQLParserRULE_valueExpression, _p) var _la int var _alt int @@ -123897,7 +123897,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7108) if !(p.Precpred(p.GetParserRuleContext(), 8)) { @@ -123907,7 +123907,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte { p.SetState(7109) - var _m = p.Match(DorisSQLParserBITXOR) + var _m = p.Match(StarRocksSQLParserBITXOR) localctx.(*ArithmeticBinaryContext).operator = _m if p.HasError() { @@ -123927,7 +123927,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7111) if !(p.Precpred(p.GetParserRuleContext(), 7)) { @@ -123943,7 +123943,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserMOD || ((int64((_la-519)) & ^0x3f) == 0 && ((int64(1)<<(_la-519))&71) != 0)) { + if !(_la == StarRocksSQLParserMOD || ((int64((_la-519)) & ^0x3f) == 0 && ((int64(1)<<(_la-519))&71) != 0)) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*ArithmeticBinaryContext).operator = _ri @@ -123964,7 +123964,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7114) if !(p.Precpred(p.GetParserRuleContext(), 6)) { @@ -123980,7 +123980,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserPLUS_SYMBOL || _la == DorisSQLParserMINUS_SYMBOL) { + if !(_la == StarRocksSQLParserPLUS_SYMBOL || _la == StarRocksSQLParserMINUS_SYMBOL) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*ArithmeticBinaryContext).operator = _ri @@ -124001,7 +124001,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7117) if !(p.Precpred(p.GetParserRuleContext(), 5)) { @@ -124011,7 +124011,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte { p.SetState(7118) - var _m = p.Match(DorisSQLParserBITAND) + var _m = p.Match(StarRocksSQLParserBITAND) localctx.(*ArithmeticBinaryContext).operator = _m if p.HasError() { @@ -124031,7 +124031,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7120) if !(p.Precpred(p.GetParserRuleContext(), 4)) { @@ -124041,7 +124041,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte { p.SetState(7121) - var _m = p.Match(DorisSQLParserBITOR) + var _m = p.Match(StarRocksSQLParserBITOR) localctx.(*ArithmeticBinaryContext).operator = _m if p.HasError() { @@ -124061,7 +124061,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7123) if !(p.Precpred(p.GetParserRuleContext(), 3)) { @@ -124071,7 +124071,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte { p.SetState(7124) - var _m = p.Match(DorisSQLParserBIT_SHIFT_LEFT) + var _m = p.Match(StarRocksSQLParserBIT_SHIFT_LEFT) localctx.(*ArithmeticBinaryContext).operator = _m if p.HasError() { @@ -124091,7 +124091,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7126) if !(p.Precpred(p.GetParserRuleContext(), 2)) { @@ -124101,7 +124101,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte { p.SetState(7127) - var _m = p.Match(DorisSQLParserBIT_SHIFT_RIGHT) + var _m = p.Match(StarRocksSQLParserBIT_SHIFT_RIGHT) localctx.(*ArithmeticBinaryContext).operator = _m if p.HasError() { @@ -124121,7 +124121,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte localctx = NewArithmeticBinaryContext(p, NewValueExpressionContext(p, _parentctx, _parentState)) localctx.(*ArithmeticBinaryContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_valueExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_valueExpression) p.SetState(7129) if !(p.Precpred(p.GetParserRuleContext(), 1)) { @@ -124131,7 +124131,7 @@ func (p *DorisSQLParser) valueExpression(_p int) (localctx IValueExpressionConte { p.SetState(7130) - var _m = p.Match(DorisSQLParserBIT_SHIFT_RIGHT_LOGICAL) + var _m = p.Match(StarRocksSQLParserBIT_SHIFT_RIGHT_LOGICAL) localctx.(*ArithmeticBinaryContext).operator = _m if p.HasError() { @@ -124194,13 +124194,13 @@ type PrimaryExpressionContext struct { func NewEmptyPrimaryExpressionContext() *PrimaryExpressionContext { var p = new(PrimaryExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_primaryExpression + p.RuleIndex = StarRocksSQLParserRULE_primaryExpression return p } func InitEmptyPrimaryExpressionContext(p *PrimaryExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_primaryExpression + p.RuleIndex = StarRocksSQLParserRULE_primaryExpression } func (*PrimaryExpressionContext) IsPrimaryExpressionContext() {} @@ -124211,7 +124211,7 @@ func NewPrimaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_primaryExpression + p.RuleIndex = StarRocksSQLParserRULE_primaryExpression return p } @@ -124275,7 +124275,7 @@ func (s *DereferenceContext) PrimaryExpression() IPrimaryExpressionContext { } func (s *DereferenceContext) DOT_IDENTIFIER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOT_IDENTIFIER, 0) + return s.GetToken(StarRocksSQLParserDOT_IDENTIFIER, 0) } func (s *DereferenceContext) Identifier() IIdentifierContext { @@ -124295,20 +124295,20 @@ func (s *DereferenceContext) Identifier() IIdentifierContext { } func (s *DereferenceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDereference(s) } } func (s *DereferenceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDereference(s) } } func (s *DereferenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDereference(s) default: @@ -124335,7 +124335,7 @@ func (s *OdbcFunctionCallExpressionContext) GetRuleContext() antlr.RuleContext { } func (s *OdbcFunctionCallExpressionContext) FN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFN, 0) + return s.GetToken(StarRocksSQLParserFN, 0) } func (s *OdbcFunctionCallExpressionContext) FunctionCall() IFunctionCallContext { @@ -124355,20 +124355,20 @@ func (s *OdbcFunctionCallExpressionContext) FunctionCall() IFunctionCallContext } func (s *OdbcFunctionCallExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOdbcFunctionCallExpression(s) } } func (s *OdbcFunctionCallExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOdbcFunctionCallExpression(s) } } func (s *OdbcFunctionCallExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOdbcFunctionCallExpression(s) default: @@ -124405,7 +124405,7 @@ func (s *MatchExprContext) GetRuleContext() antlr.RuleContext { } func (s *MatchExprContext) MATCH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATCH, 0) + return s.GetToken(StarRocksSQLParserMATCH, 0) } func (s *MatchExprContext) AllPrimaryExpression() []IPrimaryExpressionContext { @@ -124450,24 +124450,24 @@ func (s *MatchExprContext) PrimaryExpression(i int) IPrimaryExpressionContext { } func (s *MatchExprContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *MatchExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMatchExpr(s) } } func (s *MatchExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMatchExpr(s) } } func (s *MatchExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMatchExpr(s) default: @@ -124510,20 +124510,20 @@ func (s *ColumnRefContext) ColumnReference() IColumnReferenceContext { } func (s *ColumnRefContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnRef(s) } } func (s *ColumnRefContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnRef(s) } } func (s *ColumnRefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnRef(s) default: @@ -124550,7 +124550,7 @@ func (s *ConvertContext) GetRuleContext() antlr.RuleContext { } func (s *ConvertContext) CONVERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONVERT, 0) + return s.GetToken(StarRocksSQLParserCONVERT, 0) } func (s *ConvertContext) Expression() IExpressionContext { @@ -124586,20 +124586,20 @@ func (s *ConvertContext) Type_() ITypeContext { } func (s *ConvertContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterConvert(s) } } func (s *ConvertContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitConvert(s) } } func (s *ConvertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitConvert(s) default: @@ -124668,20 +124668,20 @@ func (s *CollectionSubscriptContext) ValueExpression() IValueExpressionContext { } func (s *CollectionSubscriptContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCollectionSubscript(s) } } func (s *CollectionSubscriptContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCollectionSubscript(s) } } func (s *CollectionSubscriptContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCollectionSubscript(s) default: @@ -124724,20 +124724,20 @@ func (s *LiteralContext) LiteralExpression() ILiteralExpressionContext { } func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLiteral(s) } } func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLiteral(s) } } func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLiteral(s) default: @@ -124764,7 +124764,7 @@ func (s *CastContext) GetRuleContext() antlr.RuleContext { } func (s *CastContext) CAST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCAST, 0) + return s.GetToken(StarRocksSQLParserCAST, 0) } func (s *CastContext) Expression() IExpressionContext { @@ -124784,7 +124784,7 @@ func (s *CastContext) Expression() IExpressionContext { } func (s *CastContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *CastContext) Type_() ITypeContext { @@ -124804,20 +124804,20 @@ func (s *CastContext) Type_() ITypeContext { } func (s *CastContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCast(s) } } func (s *CastContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCast(s) } } func (s *CastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCast(s) default: @@ -124860,20 +124860,20 @@ func (s *ParenthesizedExpressionContext) Expression() IExpressionContext { } func (s *ParenthesizedExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterParenthesizedExpression(s) } } func (s *ParenthesizedExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitParenthesizedExpression(s) } } func (s *ParenthesizedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitParenthesizedExpression(s) default: @@ -124916,20 +124916,20 @@ func (s *UserVariableExpressionContext) UserVariable() IUserVariableContext { } func (s *UserVariableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUserVariableExpression(s) } } func (s *UserVariableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUserVariableExpression(s) } } func (s *UserVariableExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUserVariableExpression(s) default: @@ -124972,20 +124972,20 @@ func (s *FunctionCallExpressionContext) FunctionCall() IFunctionCallContext { } func (s *FunctionCallExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterFunctionCallExpression(s) } } func (s *FunctionCallExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitFunctionCallExpression(s) } } func (s *FunctionCallExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitFunctionCallExpression(s) default: @@ -125022,11 +125022,11 @@ func (s *SimpleCaseContext) GetRuleContext() antlr.RuleContext { } func (s *SimpleCaseContext) CASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCASE, 0) + return s.GetToken(StarRocksSQLParserCASE, 0) } func (s *SimpleCaseContext) END() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEND, 0) + return s.GetToken(StarRocksSQLParserEND, 0) } func (s *SimpleCaseContext) AllExpression() []IExpressionContext { @@ -125112,24 +125112,24 @@ func (s *SimpleCaseContext) WhenClause(i int) IWhenClauseContext { } func (s *SimpleCaseContext) ELSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserELSE, 0) + return s.GetToken(StarRocksSQLParserELSE, 0) } func (s *SimpleCaseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSimpleCase(s) } } func (s *SimpleCaseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSimpleCase(s) } } func (s *SimpleCaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSimpleCase(s) default: @@ -125172,7 +125172,7 @@ func (s *ArrowExpressionContext) PrimaryExpression() IPrimaryExpressionContext { } func (s *ArrowExpressionContext) ARROW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARROW, 0) + return s.GetToken(StarRocksSQLParserARROW, 0) } func (s *ArrowExpressionContext) String_() IStringContext { @@ -125192,20 +125192,20 @@ func (s *ArrowExpressionContext) String_() IStringContext { } func (s *ArrowExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArrowExpression(s) } } func (s *ArrowExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArrowExpression(s) } } func (s *ArrowExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArrowExpression(s) default: @@ -125232,7 +125232,7 @@ func (s *ArrayExprContext) GetRuleContext() antlr.RuleContext { } func (s *ArrayExprContext) ARRAY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY, 0) + return s.GetToken(StarRocksSQLParserARRAY, 0) } func (s *ArrayExprContext) ExpressionList() IExpressionListContext { @@ -125252,20 +125252,20 @@ func (s *ArrayExprContext) ExpressionList() IExpressionListContext { } func (s *ArrayExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArrayExpr(s) } } func (s *ArrayExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArrayExpr(s) } } func (s *ArrayExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArrayExpr(s) default: @@ -125308,20 +125308,20 @@ func (s *SystemVariableExpressionContext) SystemVariable() ISystemVariableContex } func (s *SystemVariableExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSystemVariableExpression(s) } } func (s *SystemVariableExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSystemVariableExpression(s) } } func (s *SystemVariableExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSystemVariableExpression(s) default: @@ -125358,7 +125358,7 @@ func (s *ConcatContext) GetRuleContext() antlr.RuleContext { } func (s *ConcatContext) CONCAT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONCAT, 0) + return s.GetToken(StarRocksSQLParserCONCAT, 0) } func (s *ConcatContext) AllPrimaryExpression() []IPrimaryExpressionContext { @@ -125403,20 +125403,20 @@ func (s *ConcatContext) PrimaryExpression(i int) IPrimaryExpressionContext { } func (s *ConcatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterConcat(s) } } func (s *ConcatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitConcat(s) } } func (s *ConcatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitConcat(s) default: @@ -125459,20 +125459,20 @@ func (s *SubqueryExpressionContext) Subquery() ISubqueryContext { } func (s *SubqueryExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubqueryExpression(s) } } func (s *SubqueryExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubqueryExpression(s) } } func (s *SubqueryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubqueryExpression(s) default: @@ -125499,7 +125499,7 @@ func (s *LambdaFunctionExprContext) GetRuleContext() antlr.RuleContext { } func (s *LambdaFunctionExprContext) ARROW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARROW, 0) + return s.GetToken(StarRocksSQLParserARROW, 0) } func (s *LambdaFunctionExprContext) Expression() IExpressionContext { @@ -125567,20 +125567,20 @@ func (s *LambdaFunctionExprContext) ExpressionList() IExpressionListContext { } func (s *LambdaFunctionExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLambdaFunctionExpr(s) } } func (s *LambdaFunctionExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLambdaFunctionExpr(s) } } func (s *LambdaFunctionExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLambdaFunctionExpr(s) default: @@ -125607,7 +125607,7 @@ func (s *DictionaryGetExprContext) GetRuleContext() antlr.RuleContext { } func (s *DictionaryGetExprContext) DICTIONARY_GET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY_GET, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY_GET, 0) } func (s *DictionaryGetExprContext) ExpressionList() IExpressionListContext { @@ -125627,20 +125627,20 @@ func (s *DictionaryGetExprContext) ExpressionList() IExpressionListContext { } func (s *DictionaryGetExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDictionaryGetExpr(s) } } func (s *DictionaryGetExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDictionaryGetExpr(s) } } func (s *DictionaryGetExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDictionaryGetExpr(s) default: @@ -125683,7 +125683,7 @@ func (s *CollateContext) PrimaryExpression() IPrimaryExpressionContext { } func (s *CollateContext) COLLATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLLATE, 0) + return s.GetToken(StarRocksSQLParserCOLLATE, 0) } func (s *CollateContext) Identifier() IIdentifierContext { @@ -125719,20 +125719,20 @@ func (s *CollateContext) String_() IStringContext { } func (s *CollateContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCollate(s) } } func (s *CollateContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCollate(s) } } func (s *CollateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCollate(s) default: @@ -125791,20 +125791,20 @@ func (s *ArrayConstructorContext) ExpressionList() IExpressionListContext { } func (s *ArrayConstructorContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArrayConstructor(s) } } func (s *ArrayConstructorContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArrayConstructor(s) } } func (s *ArrayConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArrayConstructor(s) default: @@ -125863,24 +125863,24 @@ func (s *MapConstructorContext) MapExpressionList() IMapExpressionListContext { } func (s *MapConstructorContext) MAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAP, 0) + return s.GetToken(StarRocksSQLParserMAP, 0) } func (s *MapConstructorContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMapConstructor(s) } } func (s *MapConstructorContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMapConstructor(s) } } func (s *MapConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMapConstructor(s) default: @@ -125933,28 +125933,28 @@ func (s *ArraySliceContext) PrimaryExpression() IPrimaryExpressionContext { } func (s *ArraySliceContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *ArraySliceContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *ArraySliceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArraySlice(s) } } func (s *ArraySliceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArraySlice(s) } } func (s *ArraySliceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArraySlice(s) default: @@ -125981,7 +125981,7 @@ func (s *ExistsContext) GetRuleContext() antlr.RuleContext { } func (s *ExistsContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *ExistsContext) QueryRelation() IQueryRelationContext { @@ -126001,20 +126001,20 @@ func (s *ExistsContext) QueryRelation() IQueryRelationContext { } func (s *ExistsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExists(s) } } func (s *ExistsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExists(s) } } func (s *ExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExists(s) default: @@ -126046,11 +126046,11 @@ func (s *SearchedCaseContext) GetRuleContext() antlr.RuleContext { } func (s *SearchedCaseContext) CASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCASE, 0) + return s.GetToken(StarRocksSQLParserCASE, 0) } func (s *SearchedCaseContext) END() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEND, 0) + return s.GetToken(StarRocksSQLParserEND, 0) } func (s *SearchedCaseContext) AllWhenClause() []IWhenClauseContext { @@ -126095,7 +126095,7 @@ func (s *SearchedCaseContext) WhenClause(i int) IWhenClauseContext { } func (s *SearchedCaseContext) ELSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserELSE, 0) + return s.GetToken(StarRocksSQLParserELSE, 0) } func (s *SearchedCaseContext) Expression() IExpressionContext { @@ -126115,20 +126115,20 @@ func (s *SearchedCaseContext) Expression() IExpressionContext { } func (s *SearchedCaseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSearchedCase(s) } } func (s *SearchedCaseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSearchedCase(s) } } func (s *SearchedCaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSearchedCase(s) default: @@ -126176,36 +126176,36 @@ func (s *ArithmeticUnaryContext) PrimaryExpression() IPrimaryExpressionContext { } func (s *ArithmeticUnaryContext) MINUS_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUS_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserMINUS_SYMBOL, 0) } func (s *ArithmeticUnaryContext) PLUS_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUS_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserPLUS_SYMBOL, 0) } func (s *ArithmeticUnaryContext) BITNOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITNOT, 0) + return s.GetToken(StarRocksSQLParserBITNOT, 0) } func (s *ArithmeticUnaryContext) LOGICAL_NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGICAL_NOT, 0) + return s.GetToken(StarRocksSQLParserLOGICAL_NOT, 0) } func (s *ArithmeticUnaryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArithmeticUnary(s) } } func (s *ArithmeticUnaryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArithmeticUnary(s) } } func (s *ArithmeticUnaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArithmeticUnary(s) default: @@ -126213,11 +126213,11 @@ func (s *ArithmeticUnaryContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { +func (p *StarRocksSQLParser) PrimaryExpression() (localctx IPrimaryExpressionContext) { return p.primaryExpression(0) } -func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionContext) { +func (p *StarRocksSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionContext) { var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() _parentState := p.GetState() @@ -126225,7 +126225,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC var _prevctx IPrimaryExpressionContext = localctx var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. _startState := 920 - p.EnterRecursionRule(localctx, 920, DorisSQLParserRULE_primaryExpression, _p) + p.EnterRecursionRule(localctx, 920, StarRocksSQLParserRULE_primaryExpression, _p) var _la int var _alt int @@ -126263,7 +126263,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7140) - p.Match(DorisSQLParserARRAY) + p.Match(StarRocksSQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126271,7 +126271,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7141) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126283,7 +126283,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7143) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126296,7 +126296,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7145) - p.Match(DorisSQLParserDICTIONARY_GET) + p.Match(StarRocksSQLParserDICTIONARY_GET) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126304,7 +126304,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7146) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126316,7 +126316,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7148) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126338,7 +126338,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7151) - p.Match(DorisSQLParserT__8) + p.Match(StarRocksSQLParserT__8) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126346,7 +126346,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7152) - p.Match(DorisSQLParserFN) + p.Match(StarRocksSQLParserFN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126358,7 +126358,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7154) - p.Match(DorisSQLParserT__9) + p.Match(StarRocksSQLParserT__9) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126417,7 +126417,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC { p.SetState(7160) - var _m = p.Match(DorisSQLParserLOGICAL_NOT) + var _m = p.Match(StarRocksSQLParserLOGICAL_NOT) localctx.(*ArithmeticUnaryContext).operator = _m if p.HasError() { @@ -126436,7 +126436,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7162) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126448,7 +126448,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7164) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126461,7 +126461,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7166) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126469,7 +126469,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7167) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126481,7 +126481,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7169) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126503,7 +126503,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7172) - p.Match(DorisSQLParserCAST) + p.Match(StarRocksSQLParserCAST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126511,7 +126511,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7173) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126523,7 +126523,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7175) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126535,7 +126535,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7177) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126548,7 +126548,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7179) - p.Match(DorisSQLParserCONVERT) + p.Match(StarRocksSQLParserCONVERT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126556,7 +126556,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7180) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126568,7 +126568,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7182) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126580,7 +126580,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7184) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126593,7 +126593,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7186) - p.Match(DorisSQLParserCASE) + p.Match(StarRocksSQLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126613,7 +126613,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == DorisSQLParserWHEN { + for ok := true; ok; ok = _la == StarRocksSQLParserWHEN { { p.SetState(7188) p.WhenClause() @@ -126633,10 +126633,10 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserELSE { + if _la == StarRocksSQLParserELSE { { p.SetState(7193) - p.Match(DorisSQLParserELSE) + p.Match(StarRocksSQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126653,7 +126653,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7197) - p.Match(DorisSQLParserEND) + p.Match(StarRocksSQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126666,7 +126666,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7199) - p.Match(DorisSQLParserCASE) + p.Match(StarRocksSQLParserCASE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126679,7 +126679,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - for ok := true; ok; ok = _la == DorisSQLParserWHEN { + for ok := true; ok; ok = _la == StarRocksSQLParserWHEN { { p.SetState(7200) p.WhenClause() @@ -126699,10 +126699,10 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserELSE { + if _la == StarRocksSQLParserELSE { { p.SetState(7205) - p.Match(DorisSQLParserELSE) + p.Match(StarRocksSQLParserELSE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126719,7 +126719,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7209) - p.Match(DorisSQLParserEND) + p.Match(StarRocksSQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126737,7 +126737,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserARRAY { + if _la == StarRocksSQLParserARRAY { { p.SetState(7211) p.ArrayType() @@ -126746,7 +126746,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7214) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126768,7 +126768,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7218) - p.Match(DorisSQLParserT__6) + p.Match(StarRocksSQLParserT__6) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126785,7 +126785,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7220) - p.Match(DorisSQLParserT__8) + p.Match(StarRocksSQLParserT__8) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126807,7 +126807,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7224) - p.Match(DorisSQLParserT__9) + p.Match(StarRocksSQLParserT__9) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126820,7 +126820,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC _prevctx = localctx { p.SetState(7226) - p.Match(DorisSQLParserMAP) + p.Match(StarRocksSQLParserMAP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126828,7 +126828,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7227) - p.Match(DorisSQLParserT__8) + p.Match(StarRocksSQLParserT__8) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126850,7 +126850,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7231) - p.Match(DorisSQLParserT__9) + p.Match(StarRocksSQLParserT__9) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126868,13 +126868,13 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(7232) p.Identifier() } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(7233) p.IdentifierList() @@ -126886,7 +126886,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7236) - p.Match(DorisSQLParserARROW) + p.Match(StarRocksSQLParserARROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126907,7 +126907,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7240) - p.Match(DorisSQLParserARROW) + p.Match(StarRocksSQLParserARROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126915,7 +126915,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7241) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126937,7 +126937,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7245) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -126974,7 +126974,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC localctx = NewConcatContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) localctx.(*ConcatContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7249) if !(p.Precpred(p.GetParserRuleContext(), 19)) { @@ -126983,7 +126983,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7250) - p.Match(DorisSQLParserCONCAT) + p.Match(StarRocksSQLParserCONCAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127001,7 +127001,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC localctx = NewMatchExprContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) localctx.(*MatchExprContext).left = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7252) if !(p.Precpred(p.GetParserRuleContext(), 1)) { @@ -127015,10 +127015,10 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserNOT { + if _la == StarRocksSQLParserNOT { { p.SetState(7253) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127028,7 +127028,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7256) - p.Match(DorisSQLParserMATCH) + p.Match(StarRocksSQLParserMATCH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127044,7 +127044,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC case 3: localctx = NewCollateContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7258) if !(p.Precpred(p.GetParserRuleContext(), 23)) { @@ -127053,7 +127053,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7259) - p.Match(DorisSQLParserCOLLATE) + p.Match(StarRocksSQLParserCOLLATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127066,13 +127066,13 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(7260) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(7261) p.String_() @@ -127087,7 +127087,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC localctx = NewDereferenceContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) localctx.(*DereferenceContext).base = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7264) if !(p.Precpred(p.GetParserRuleContext(), 20)) { @@ -127101,20 +127101,20 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDOT_IDENTIFIER: + case StarRocksSQLParserDOT_IDENTIFIER: { p.SetState(7265) - p.Match(DorisSQLParserDOT_IDENTIFIER) + p.Match(StarRocksSQLParserDOT_IDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserT__0: + case StarRocksSQLParserT__0: { p.SetState(7266) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127137,7 +127137,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC localctx = NewCollectionSubscriptContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) localctx.(*CollectionSubscriptContext).value = _prevctx - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7270) if !(p.Precpred(p.GetParserRuleContext(), 6)) { @@ -127146,7 +127146,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7271) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127161,7 +127161,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7273) - p.Match(DorisSQLParserT__6) + p.Match(StarRocksSQLParserT__6) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127170,7 +127170,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC case 6: localctx = NewArraySliceContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7275) if !(p.Precpred(p.GetParserRuleContext(), 5)) { @@ -127179,7 +127179,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7276) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127192,11 +127192,11 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTEGER_VALUE { + if _la == StarRocksSQLParserINTEGER_VALUE { { p.SetState(7277) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*ArraySliceContext).start_ = _m if p.HasError() { @@ -127208,7 +127208,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7280) - p.Match(DorisSQLParserT__7) + p.Match(StarRocksSQLParserT__7) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127221,11 +127221,11 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTEGER_VALUE { + if _la == StarRocksSQLParserINTEGER_VALUE { { p.SetState(7281) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*ArraySliceContext).end = _m if p.HasError() { @@ -127237,7 +127237,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7284) - p.Match(DorisSQLParserT__6) + p.Match(StarRocksSQLParserT__6) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127246,7 +127246,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC case 7: localctx = NewArrowExpressionContext(p, NewPrimaryExpressionContext(p, _parentctx, _parentState)) - p.PushNewRecursionContext(localctx, _startState, DorisSQLParserRULE_primaryExpression) + p.PushNewRecursionContext(localctx, _startState, StarRocksSQLParserRULE_primaryExpression) p.SetState(7285) if !(p.Precpred(p.GetParserRuleContext(), 4)) { @@ -127255,7 +127255,7 @@ func (p *DorisSQLParser) primaryExpression(_p int) (localctx IPrimaryExpressionC } { p.SetState(7286) - p.Match(DorisSQLParserARROW) + p.Match(StarRocksSQLParserARROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127313,13 +127313,13 @@ type LiteralExpressionContext struct { func NewEmptyLiteralExpressionContext() *LiteralExpressionContext { var p = new(LiteralExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_literalExpression + p.RuleIndex = StarRocksSQLParserRULE_literalExpression return p } func InitEmptyLiteralExpressionContext(p *LiteralExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_literalExpression + p.RuleIndex = StarRocksSQLParserRULE_literalExpression } func (*LiteralExpressionContext) IsLiteralExpressionContext() {} @@ -127330,7 +127330,7 @@ func NewLiteralExpressionContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_literalExpression + p.RuleIndex = StarRocksSQLParserRULE_literalExpression return p } @@ -127384,20 +127384,20 @@ func (s *BinaryLiteralContext) Binary() IBinaryContext { } func (s *BinaryLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBinaryLiteral(s) } } func (s *BinaryLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBinaryLiteral(s) } } func (s *BinaryLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBinaryLiteral(s) default: @@ -127424,24 +127424,24 @@ func (s *NullLiteralContext) GetRuleContext() antlr.RuleContext { } func (s *NullLiteralContext) NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULL, 0) + return s.GetToken(StarRocksSQLParserNULL, 0) } func (s *NullLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNullLiteral(s) } } func (s *NullLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNullLiteral(s) } } func (s *NullLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNullLiteral(s) default: @@ -127484,20 +127484,20 @@ func (s *StringLiteralContext) String_() IStringContext { } func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterStringLiteral(s) } } func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitStringLiteral(s) } } func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitStringLiteral(s) default: @@ -127524,24 +127524,24 @@ func (s *ParameterContext) GetRuleContext() antlr.RuleContext { } func (s *ParameterContext) PARAMETER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARAMETER, 0) + return s.GetToken(StarRocksSQLParserPARAMETER, 0) } func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterParameter(s) } } func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitParameter(s) } } func (s *ParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitParameter(s) default: @@ -127584,28 +127584,28 @@ func (s *DateLiteralContext) String_() IStringContext { } func (s *DateLiteralContext) DATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATE, 0) + return s.GetToken(StarRocksSQLParserDATE, 0) } func (s *DateLiteralContext) DATETIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATETIME, 0) + return s.GetToken(StarRocksSQLParserDATETIME, 0) } func (s *DateLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDateLiteral(s) } } func (s *DateLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDateLiteral(s) } } func (s *DateLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDateLiteral(s) default: @@ -127648,20 +127648,20 @@ func (s *BooleanLiteralContext) BooleanValue() IBooleanValueContext { } func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBooleanLiteral(s) } } func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBooleanLiteral(s) } } func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBooleanLiteral(s) default: @@ -127704,20 +127704,20 @@ func (s *NumericLiteralContext) Number() INumberContext { } func (s *NumericLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNumericLiteral(s) } } func (s *NumericLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNumericLiteral(s) } } func (s *NumericLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNumericLiteral(s) default: @@ -127760,20 +127760,20 @@ func (s *IntervalLiteralContext) Interval() IIntervalContext { } func (s *IntervalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIntervalLiteral(s) } } func (s *IntervalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIntervalLiteral(s) } } func (s *IntervalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIntervalLiteral(s) default: @@ -127816,20 +127816,20 @@ func (s *UnitBoundaryLiteralContext) UnitBoundary() IUnitBoundaryContext { } func (s *UnitBoundaryLiteralContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUnitBoundaryLiteral(s) } } func (s *UnitBoundaryLiteralContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUnitBoundaryLiteral(s) } } func (s *UnitBoundaryLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUnitBoundaryLiteral(s) default: @@ -127837,9 +127837,9 @@ func (s *UnitBoundaryLiteralContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext) { +func (p *StarRocksSQLParser) LiteralExpression() (localctx ILiteralExpressionContext) { localctx = NewLiteralExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 922, DorisSQLParserRULE_literalExpression) + p.EnterRule(localctx, 922, StarRocksSQLParserRULE_literalExpression) var _la int p.SetState(7303) @@ -127849,19 +127849,19 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext } switch p.GetTokenStream().LA(1) { - case DorisSQLParserNULL: + case StarRocksSQLParserNULL: localctx = NewNullLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(7293) - p.Match(DorisSQLParserNULL) + p.Match(StarRocksSQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserFALSE, DorisSQLParserTRUE: + case StarRocksSQLParserFALSE, StarRocksSQLParserTRUE: localctx = NewBooleanLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 2) { @@ -127869,7 +127869,7 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.BooleanValue() } - case DorisSQLParserINTEGER_VALUE, DorisSQLParserDECIMAL_VALUE, DorisSQLParserDOUBLE_VALUE: + case StarRocksSQLParserINTEGER_VALUE, StarRocksSQLParserDECIMAL_VALUE, StarRocksSQLParserDOUBLE_VALUE: localctx = NewNumericLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 3) { @@ -127877,14 +127877,14 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.Number() } - case DorisSQLParserDATE, DorisSQLParserDATETIME: + case StarRocksSQLParserDATE, StarRocksSQLParserDATETIME: localctx = NewDateLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 4) { p.SetState(7296) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDATE || _la == DorisSQLParserDATETIME) { + if !(_la == StarRocksSQLParserDATE || _la == StarRocksSQLParserDATETIME) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -127896,7 +127896,7 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.String_() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: localctx = NewStringLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 5) { @@ -127904,7 +127904,7 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.String_() } - case DorisSQLParserINTERVAL: + case StarRocksSQLParserINTERVAL: localctx = NewIntervalLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 6) { @@ -127912,7 +127912,7 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.Interval() } - case DorisSQLParserCEIL, DorisSQLParserFLOOR: + case StarRocksSQLParserCEIL, StarRocksSQLParserFLOOR: localctx = NewUnitBoundaryLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 7) { @@ -127920,7 +127920,7 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.UnitBoundary() } - case DorisSQLParserBINARY_SINGLE_QUOTED_TEXT, DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT: + case StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT, StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT: localctx = NewBinaryLiteralContext(p, localctx) p.EnterOuterAlt(localctx, 8) { @@ -127928,12 +127928,12 @@ func (p *DorisSQLParser) LiteralExpression() (localctx ILiteralExpressionContext p.Binary() } - case DorisSQLParserPARAMETER: + case StarRocksSQLParserPARAMETER: localctx = NewParameterContext(p, localctx) p.EnterOuterAlt(localctx, 9) { p.SetState(7302) - p.Match(DorisSQLParserPARAMETER) + p.Match(StarRocksSQLParserPARAMETER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -127976,13 +127976,13 @@ type FunctionCallContext struct { func NewEmptyFunctionCallContext() *FunctionCallContext { var p = new(FunctionCallContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_functionCall + p.RuleIndex = StarRocksSQLParserRULE_functionCall return p } func InitEmptyFunctionCallContext(p *FunctionCallContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_functionCall + p.RuleIndex = StarRocksSQLParserRULE_functionCall } func (*FunctionCallContext) IsFunctionCallContext() {} @@ -127993,7 +127993,7 @@ func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_functionCall + p.RuleIndex = StarRocksSQLParserRULE_functionCall return p } @@ -128063,20 +128063,20 @@ func (s *AggregationFunctionCallContext) Over() IOverContext { } func (s *AggregationFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAggregationFunctionCall(s) } } func (s *AggregationFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAggregationFunctionCall(s) } } func (s *AggregationFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAggregationFunctionCall(s) default: @@ -128103,7 +128103,7 @@ func (s *ExtractContext) GetRuleContext() antlr.RuleContext { } func (s *ExtractContext) EXTRACT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTRACT, 0) + return s.GetToken(StarRocksSQLParserEXTRACT, 0) } func (s *ExtractContext) Identifier() IIdentifierContext { @@ -128123,7 +128123,7 @@ func (s *ExtractContext) Identifier() IIdentifierContext { } func (s *ExtractContext) FROM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFROM, 0) + return s.GetToken(StarRocksSQLParserFROM, 0) } func (s *ExtractContext) ValueExpression() IValueExpressionContext { @@ -128143,20 +128143,20 @@ func (s *ExtractContext) ValueExpression() IValueExpressionContext { } func (s *ExtractContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExtract(s) } } func (s *ExtractContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExtract(s) } } func (s *ExtractContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExtract(s) default: @@ -128199,20 +128199,20 @@ func (s *SpecialFunctionContext) SpecialFunctionExpression() ISpecialFunctionExp } func (s *SpecialFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSpecialFunction(s) } } func (s *SpecialFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSpecialFunction(s) } } func (s *SpecialFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSpecialFunction(s) default: @@ -128312,20 +128312,20 @@ func (s *SimpleFunctionCallContext) Over() IOverContext { } func (s *SimpleFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSimpleFunctionCall(s) } } func (s *SimpleFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSimpleFunctionCall(s) } } func (s *SimpleFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSimpleFunctionCall(s) default: @@ -128368,20 +128368,20 @@ func (s *SpecialDateTimeContext) SpecialDateTimeExpression() ISpecialDateTimeExp } func (s *SpecialDateTimeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSpecialDateTime(s) } } func (s *SpecialDateTimeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSpecialDateTime(s) } } func (s *SpecialDateTimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSpecialDateTime(s) default: @@ -128440,20 +128440,20 @@ func (s *WindowFunctionCallContext) Over() IOverContext { } func (s *WindowFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterWindowFunctionCall(s) } } func (s *WindowFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitWindowFunctionCall(s) } } func (s *WindowFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitWindowFunctionCall(s) default: @@ -128496,20 +128496,20 @@ func (s *InformationFunctionContext) InformationFunctionExpression() IInformatio } func (s *InformationFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInformationFunction(s) } } func (s *InformationFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInformationFunction(s) } } func (s *InformationFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInformationFunction(s) default: @@ -128536,7 +128536,7 @@ func (s *TranslateFunctionCallContext) GetRuleContext() antlr.RuleContext { } func (s *TranslateFunctionCallContext) TRANSLATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSLATE, 0) + return s.GetToken(StarRocksSQLParserTRANSLATE, 0) } func (s *TranslateFunctionCallContext) AllExpression() []IExpressionContext { @@ -128581,20 +128581,20 @@ func (s *TranslateFunctionCallContext) Expression(i int) IExpressionContext { } func (s *TranslateFunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTranslateFunctionCall(s) } } func (s *TranslateFunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTranslateFunctionCall(s) } } func (s *TranslateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTranslateFunctionCall(s) default: @@ -128621,7 +128621,7 @@ func (s *GroupingOperationContext) GetRuleContext() antlr.RuleContext { } func (s *GroupingOperationContext) GROUPING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPING, 0) + return s.GetToken(StarRocksSQLParserGROUPING, 0) } func (s *GroupingOperationContext) AllExpression() []IExpressionContext { @@ -128666,24 +128666,24 @@ func (s *GroupingOperationContext) Expression(i int) IExpressionContext { } func (s *GroupingOperationContext) GROUPING_ID() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUPING_ID, 0) + return s.GetToken(StarRocksSQLParserGROUPING_ID, 0) } func (s *GroupingOperationContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterGroupingOperation(s) } } func (s *GroupingOperationContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitGroupingOperation(s) } } func (s *GroupingOperationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitGroupingOperation(s) default: @@ -128691,9 +128691,9 @@ func (s *GroupingOperationContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { +func (p *StarRocksSQLParser) FunctionCall() (localctx IFunctionCallContext) { localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 924, DorisSQLParserRULE_functionCall) + p.EnterRule(localctx, 924, StarRocksSQLParserRULE_functionCall) var _la int p.SetState(7377) @@ -128708,7 +128708,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(7305) - p.Match(DorisSQLParserEXTRACT) + p.Match(StarRocksSQLParserEXTRACT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128716,7 +128716,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7306) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128728,7 +128728,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7308) - p.Match(DorisSQLParserFROM) + p.Match(StarRocksSQLParserFROM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128740,7 +128740,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7310) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128752,7 +128752,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(7312) - p.Match(DorisSQLParserGROUPING) + p.Match(StarRocksSQLParserGROUPING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128760,7 +128760,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7313) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128785,10 +128785,10 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7315) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128810,7 +128810,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7324) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128822,7 +128822,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(7325) - p.Match(DorisSQLParserGROUPING_ID) + p.Match(StarRocksSQLParserGROUPING_ID) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128830,7 +128830,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7326) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128855,10 +128855,10 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7328) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128880,7 +128880,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7337) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128948,7 +128948,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { p.EnterOuterAlt(localctx, 9) { p.SetState(7348) - p.Match(DorisSQLParserTRANSLATE) + p.Match(StarRocksSQLParserTRANSLATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128956,7 +128956,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7349) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -128981,10 +128981,10 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7351) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129006,7 +129006,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7360) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129022,7 +129022,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7362) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129047,10 +129047,10 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7364) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129072,7 +129072,7 @@ func (p *DorisSQLParser) FunctionCall() (localctx IFunctionCallContext) { } { p.SetState(7373) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129147,13 +129147,13 @@ type AggregationFunctionContext struct { func NewEmptyAggregationFunctionContext() *AggregationFunctionContext { var p = new(AggregationFunctionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_aggregationFunction + p.RuleIndex = StarRocksSQLParserRULE_aggregationFunction return p } func InitEmptyAggregationFunctionContext(p *AggregationFunctionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_aggregationFunction + p.RuleIndex = StarRocksSQLParserRULE_aggregationFunction } func (*AggregationFunctionContext) IsAggregationFunctionContext() {} @@ -129164,7 +129164,7 @@ func NewAggregationFunctionContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_aggregationFunction + p.RuleIndex = StarRocksSQLParserRULE_aggregationFunction return p } @@ -129172,7 +129172,7 @@ func NewAggregationFunctionContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *AggregationFunctionContext) GetParser() antlr.Parser { return s.parser } func (s *AggregationFunctionContext) AVG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAVG, 0) + return s.GetToken(StarRocksSQLParserAVG, 0) } func (s *AggregationFunctionContext) AllExpression() []IExpressionContext { @@ -129233,11 +129233,11 @@ func (s *AggregationFunctionContext) SetQuantifier() ISetQuantifierContext { } func (s *AggregationFunctionContext) COUNT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOUNT, 0) + return s.GetToken(StarRocksSQLParserCOUNT, 0) } func (s *AggregationFunctionContext) ASTERISK_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASTERISK_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserASTERISK_SYMBOL, 0) } func (s *AggregationFunctionContext) BracketHint() IBracketHintContext { @@ -129257,27 +129257,27 @@ func (s *AggregationFunctionContext) BracketHint() IBracketHintContext { } func (s *AggregationFunctionContext) MAX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAX, 0) + return s.GetToken(StarRocksSQLParserMAX, 0) } func (s *AggregationFunctionContext) MIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMIN, 0) + return s.GetToken(StarRocksSQLParserMIN, 0) } func (s *AggregationFunctionContext) SUM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUM, 0) + return s.GetToken(StarRocksSQLParserSUM, 0) } func (s *AggregationFunctionContext) ARRAY_AGG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY_AGG, 0) + return s.GetToken(StarRocksSQLParserARRAY_AGG, 0) } func (s *AggregationFunctionContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *AggregationFunctionContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *AggregationFunctionContext) AllSortItem() []ISortItemContext { @@ -129322,15 +129322,15 @@ func (s *AggregationFunctionContext) SortItem(i int) ISortItemContext { } func (s *AggregationFunctionContext) ARRAY_AGG_DISTINCT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY_AGG_DISTINCT, 0) + return s.GetToken(StarRocksSQLParserARRAY_AGG_DISTINCT, 0) } func (s *AggregationFunctionContext) GROUP_CONCAT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP_CONCAT, 0) + return s.GetToken(StarRocksSQLParserGROUP_CONCAT, 0) } func (s *AggregationFunctionContext) SEPARATOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSEPARATOR, 0) + return s.GetToken(StarRocksSQLParserSEPARATOR, 0) } func (s *AggregationFunctionContext) GetRuleContext() antlr.RuleContext { @@ -129342,20 +129342,20 @@ func (s *AggregationFunctionContext) ToStringTree(ruleNames []string, recog antl } func (s *AggregationFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAggregationFunction(s) } } func (s *AggregationFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAggregationFunction(s) } } func (s *AggregationFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAggregationFunction(s) default: @@ -129363,9 +129363,9 @@ func (s *AggregationFunctionContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionContext) { +func (p *StarRocksSQLParser) AggregationFunction() (localctx IAggregationFunctionContext) { localctx = NewAggregationFunctionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 926, DorisSQLParserRULE_aggregationFunction) + p.EnterRule(localctx, 926, StarRocksSQLParserRULE_aggregationFunction) var _la int p.SetState(7504) @@ -129379,7 +129379,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 1) { p.SetState(7379) - p.Match(DorisSQLParserAVG) + p.Match(StarRocksSQLParserAVG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129387,7 +129387,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7380) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129400,7 +129400,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7381) p.SetQuantifier() @@ -129413,7 +129413,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7385) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129424,7 +129424,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 2) { p.SetState(7387) - p.Match(DorisSQLParserCOUNT) + p.Match(StarRocksSQLParserCOUNT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129432,7 +129432,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7388) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129445,10 +129445,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserASTERISK_SYMBOL { + if _la == StarRocksSQLParserASTERISK_SYMBOL { { p.SetState(7389) - p.Match(DorisSQLParserASTERISK_SYMBOL) + p.Match(StarRocksSQLParserASTERISK_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129458,7 +129458,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7392) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129469,7 +129469,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 3) { p.SetState(7393) - p.Match(DorisSQLParserCOUNT) + p.Match(StarRocksSQLParserCOUNT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129477,7 +129477,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7394) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129490,7 +129490,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7395) p.SetQuantifier() @@ -129528,10 +129528,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7402) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129553,7 +129553,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7411) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129564,7 +129564,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 4) { p.SetState(7412) - p.Match(DorisSQLParserMAX) + p.Match(StarRocksSQLParserMAX) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129572,7 +129572,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7413) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129585,7 +129585,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7414) p.SetQuantifier() @@ -129598,7 +129598,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7418) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129609,7 +129609,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 5) { p.SetState(7420) - p.Match(DorisSQLParserMIN) + p.Match(StarRocksSQLParserMIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129617,7 +129617,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7421) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129630,7 +129630,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7422) p.SetQuantifier() @@ -129643,7 +129643,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7426) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129654,7 +129654,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 6) { p.SetState(7428) - p.Match(DorisSQLParserSUM) + p.Match(StarRocksSQLParserSUM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129662,7 +129662,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7429) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129675,7 +129675,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7430) p.SetQuantifier() @@ -129688,7 +129688,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7434) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129699,7 +129699,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 7) { p.SetState(7436) - p.Match(DorisSQLParserARRAY_AGG) + p.Match(StarRocksSQLParserARRAY_AGG) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129707,7 +129707,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7437) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129720,7 +129720,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7438) p.SetQuantifier() @@ -129738,10 +129738,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(7442) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129749,7 +129749,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7443) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129766,10 +129766,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7445) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129791,7 +129791,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7454) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129802,7 +129802,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 8) { p.SetState(7456) - p.Match(DorisSQLParserARRAY_AGG_DISTINCT) + p.Match(StarRocksSQLParserARRAY_AGG_DISTINCT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129810,7 +129810,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7457) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129827,10 +129827,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(7459) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129838,7 +129838,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7460) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129855,10 +129855,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7462) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129880,7 +129880,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7471) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129891,7 +129891,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon p.EnterOuterAlt(localctx, 9) { p.SetState(7473) - p.Match(DorisSQLParserGROUP_CONCAT) + p.Match(StarRocksSQLParserGROUP_CONCAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129899,7 +129899,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7474) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129912,7 +129912,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserALL || _la == DorisSQLParserDISTINCT { + if _la == StarRocksSQLParserALL || _la == StarRocksSQLParserDISTINCT { { p.SetState(7475) p.SetQuantifier() @@ -129930,10 +129930,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7479) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129958,10 +129958,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(7486) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129969,7 +129969,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7487) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -129986,10 +129986,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7489) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130016,10 +130016,10 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSEPARATOR { + if _la == StarRocksSQLParserSEPARATOR { { p.SetState(7498) - p.Match(DorisSQLParserSEPARATOR) + p.Match(StarRocksSQLParserSEPARATOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130033,7 +130033,7 @@ func (p *DorisSQLParser) AggregationFunction() (localctx IAggregationFunctionCon } { p.SetState(7502) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130080,13 +130080,13 @@ type UserVariableContext struct { func NewEmptyUserVariableContext() *UserVariableContext { var p = new(UserVariableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_userVariable + p.RuleIndex = StarRocksSQLParserRULE_userVariable return p } func InitEmptyUserVariableContext(p *UserVariableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_userVariable + p.RuleIndex = StarRocksSQLParserRULE_userVariable } func (*UserVariableContext) IsUserVariableContext() {} @@ -130097,7 +130097,7 @@ func NewUserVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_userVariable + p.RuleIndex = StarRocksSQLParserRULE_userVariable return p } @@ -130105,7 +130105,7 @@ func NewUserVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *UserVariableContext) GetParser() antlr.Parser { return s.parser } func (s *UserVariableContext) AT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAT, 0) + return s.GetToken(StarRocksSQLParserAT, 0) } func (s *UserVariableContext) IdentifierOrString() IIdentifierOrStringContext { @@ -130133,20 +130133,20 @@ func (s *UserVariableContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *UserVariableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUserVariable(s) } } func (s *UserVariableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUserVariable(s) } } func (s *UserVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUserVariable(s) default: @@ -130154,13 +130154,13 @@ func (s *UserVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) UserVariable() (localctx IUserVariableContext) { +func (p *StarRocksSQLParser) UserVariable() (localctx IUserVariableContext) { localctx = NewUserVariableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 928, DorisSQLParserRULE_userVariable) + p.EnterRule(localctx, 928, StarRocksSQLParserRULE_userVariable) p.EnterOuterAlt(localctx, 1) { p.SetState(7506) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130209,13 +130209,13 @@ type SystemVariableContext struct { func NewEmptySystemVariableContext() *SystemVariableContext { var p = new(SystemVariableContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_systemVariable + p.RuleIndex = StarRocksSQLParserRULE_systemVariable return p } func InitEmptySystemVariableContext(p *SystemVariableContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_systemVariable + p.RuleIndex = StarRocksSQLParserRULE_systemVariable } func (*SystemVariableContext) IsSystemVariableContext() {} @@ -130226,7 +130226,7 @@ func NewSystemVariableContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_systemVariable + p.RuleIndex = StarRocksSQLParserRULE_systemVariable return p } @@ -130234,11 +130234,11 @@ func NewSystemVariableContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *SystemVariableContext) GetParser() antlr.Parser { return s.parser } func (s *SystemVariableContext) AllAT() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserAT) + return s.GetTokens(StarRocksSQLParserAT) } func (s *SystemVariableContext) AT(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserAT, i) + return s.GetToken(StarRocksSQLParserAT, i) } func (s *SystemVariableContext) Identifier() IIdentifierContext { @@ -130282,20 +130282,20 @@ func (s *SystemVariableContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *SystemVariableContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSystemVariable(s) } } func (s *SystemVariableContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSystemVariable(s) } } func (s *SystemVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSystemVariable(s) default: @@ -130303,13 +130303,13 @@ func (s *SystemVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) SystemVariable() (localctx ISystemVariableContext) { +func (p *StarRocksSQLParser) SystemVariable() (localctx ISystemVariableContext) { localctx = NewSystemVariableContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 930, DorisSQLParserRULE_systemVariable) + p.EnterRule(localctx, 930, StarRocksSQLParserRULE_systemVariable) p.EnterOuterAlt(localctx, 1) { p.SetState(7509) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130317,7 +130317,7 @@ func (p *DorisSQLParser) SystemVariable() (localctx ISystemVariableContext) { } { p.SetState(7510) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130333,7 +130333,7 @@ func (p *DorisSQLParser) SystemVariable() (localctx ISystemVariableContext) { } { p.SetState(7512) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130383,13 +130383,13 @@ type ColumnReferenceContext struct { func NewEmptyColumnReferenceContext() *ColumnReferenceContext { var p = new(ColumnReferenceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnReference + p.RuleIndex = StarRocksSQLParserRULE_columnReference return p } func InitEmptyColumnReferenceContext(p *ColumnReferenceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_columnReference + p.RuleIndex = StarRocksSQLParserRULE_columnReference } func (*ColumnReferenceContext) IsColumnReferenceContext() {} @@ -130400,7 +130400,7 @@ func NewColumnReferenceContext(parser antlr.Parser, parent antlr.ParserRuleConte antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_columnReference + p.RuleIndex = StarRocksSQLParserRULE_columnReference return p } @@ -130432,20 +130432,20 @@ func (s *ColumnReferenceContext) ToStringTree(ruleNames []string, recog antlr.Re } func (s *ColumnReferenceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterColumnReference(s) } } func (s *ColumnReferenceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitColumnReference(s) } } func (s *ColumnReferenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitColumnReference(s) default: @@ -130453,9 +130453,9 @@ func (s *ColumnReferenceContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) ColumnReference() (localctx IColumnReferenceContext) { +func (p *StarRocksSQLParser) ColumnReference() (localctx IColumnReferenceContext) { localctx = NewColumnReferenceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 932, DorisSQLParserRULE_columnReference) + p.EnterRule(localctx, 932, StarRocksSQLParserRULE_columnReference) p.EnterOuterAlt(localctx, 1) { p.SetState(7518) @@ -130510,13 +130510,13 @@ type InformationFunctionExpressionContext struct { func NewEmptyInformationFunctionExpressionContext() *InformationFunctionExpressionContext { var p = new(InformationFunctionExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_informationFunctionExpression + p.RuleIndex = StarRocksSQLParserRULE_informationFunctionExpression return p } func InitEmptyInformationFunctionExpressionContext(p *InformationFunctionExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_informationFunctionExpression + p.RuleIndex = StarRocksSQLParserRULE_informationFunctionExpression } func (*InformationFunctionExpressionContext) IsInformationFunctionExpressionContext() {} @@ -130527,7 +130527,7 @@ func NewInformationFunctionExpressionContext(parser antlr.Parser, parent antlr.P antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_informationFunctionExpression + p.RuleIndex = StarRocksSQLParserRULE_informationFunctionExpression return p } @@ -130539,31 +130539,31 @@ func (s *InformationFunctionExpressionContext) GetName() antlr.Token { return s. func (s *InformationFunctionExpressionContext) SetName(v antlr.Token) { s.name = v } func (s *InformationFunctionExpressionContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *InformationFunctionExpressionContext) DATABASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATABASE, 0) + return s.GetToken(StarRocksSQLParserDATABASE, 0) } func (s *InformationFunctionExpressionContext) SCHEMA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEMA, 0) + return s.GetToken(StarRocksSQLParserSCHEMA, 0) } func (s *InformationFunctionExpressionContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *InformationFunctionExpressionContext) CURRENT_USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_USER, 0) + return s.GetToken(StarRocksSQLParserCURRENT_USER, 0) } func (s *InformationFunctionExpressionContext) CURRENT_ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_ROLE, 0) + return s.GetToken(StarRocksSQLParserCURRENT_ROLE, 0) } func (s *InformationFunctionExpressionContext) CURRENT_GROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_GROUP, 0) + return s.GetToken(StarRocksSQLParserCURRENT_GROUP, 0) } func (s *InformationFunctionExpressionContext) GetRuleContext() antlr.RuleContext { @@ -130575,20 +130575,20 @@ func (s *InformationFunctionExpressionContext) ToStringTree(ruleNames []string, } func (s *InformationFunctionExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInformationFunctionExpression(s) } } func (s *InformationFunctionExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInformationFunctionExpression(s) } } func (s *InformationFunctionExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInformationFunctionExpression(s) default: @@ -130596,9 +130596,9 @@ func (s *InformationFunctionExpressionContext) Accept(visitor antlr.ParseTreeVis } } -func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationFunctionExpressionContext) { +func (p *StarRocksSQLParser) InformationFunctionExpression() (localctx IInformationFunctionExpressionContext) { localctx = NewInformationFunctionExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 934, DorisSQLParserRULE_informationFunctionExpression) + p.EnterRule(localctx, 934, StarRocksSQLParserRULE_informationFunctionExpression) p.SetState(7547) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -130606,12 +130606,12 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCATALOG: + case StarRocksSQLParserCATALOG: p.EnterOuterAlt(localctx, 1) { p.SetState(7520) - var _m = p.Match(DorisSQLParserCATALOG) + var _m = p.Match(StarRocksSQLParserCATALOG) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130621,7 +130621,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7521) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130629,19 +130629,19 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7522) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDATABASE: + case StarRocksSQLParserDATABASE: p.EnterOuterAlt(localctx, 2) { p.SetState(7523) - var _m = p.Match(DorisSQLParserDATABASE) + var _m = p.Match(StarRocksSQLParserDATABASE) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130651,7 +130651,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7524) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130659,19 +130659,19 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7525) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserSCHEMA: + case StarRocksSQLParserSCHEMA: p.EnterOuterAlt(localctx, 3) { p.SetState(7526) - var _m = p.Match(DorisSQLParserSCHEMA) + var _m = p.Match(StarRocksSQLParserSCHEMA) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130681,7 +130681,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7527) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130689,19 +130689,19 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7528) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserUSER: + case StarRocksSQLParserUSER: p.EnterOuterAlt(localctx, 4) { p.SetState(7529) - var _m = p.Match(DorisSQLParserUSER) + var _m = p.Match(StarRocksSQLParserUSER) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130711,7 +130711,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7530) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130719,19 +130719,19 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7531) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCURRENT_USER: + case StarRocksSQLParserCURRENT_USER: p.EnterOuterAlt(localctx, 5) { p.SetState(7532) - var _m = p.Match(DorisSQLParserCURRENT_USER) + var _m = p.Match(StarRocksSQLParserCURRENT_USER) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130745,7 +130745,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 867, p.GetParserRuleContext()) == 1 { { p.SetState(7533) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130753,7 +130753,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7534) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130764,12 +130764,12 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF goto errorExit } - case DorisSQLParserCURRENT_ROLE: + case StarRocksSQLParserCURRENT_ROLE: p.EnterOuterAlt(localctx, 6) { p.SetState(7537) - var _m = p.Match(DorisSQLParserCURRENT_ROLE) + var _m = p.Match(StarRocksSQLParserCURRENT_ROLE) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130783,7 +130783,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 868, p.GetParserRuleContext()) == 1 { { p.SetState(7538) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130791,7 +130791,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7539) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130802,12 +130802,12 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF goto errorExit } - case DorisSQLParserCURRENT_GROUP: + case StarRocksSQLParserCURRENT_GROUP: p.EnterOuterAlt(localctx, 7) { p.SetState(7542) - var _m = p.Match(DorisSQLParserCURRENT_GROUP) + var _m = p.Match(StarRocksSQLParserCURRENT_GROUP) localctx.(*InformationFunctionExpressionContext).name = _m if p.HasError() { @@ -130821,7 +130821,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 869, p.GetParserRuleContext()) == 1 { { p.SetState(7543) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130829,7 +130829,7 @@ func (p *DorisSQLParser) InformationFunctionExpression() (localctx IInformationF } { p.SetState(7544) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -130892,13 +130892,13 @@ type SpecialDateTimeExpressionContext struct { func NewEmptySpecialDateTimeExpressionContext() *SpecialDateTimeExpressionContext { var p = new(SpecialDateTimeExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_specialDateTimeExpression + p.RuleIndex = StarRocksSQLParserRULE_specialDateTimeExpression return p } func InitEmptySpecialDateTimeExpressionContext(p *SpecialDateTimeExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_specialDateTimeExpression + p.RuleIndex = StarRocksSQLParserRULE_specialDateTimeExpression } func (*SpecialDateTimeExpressionContext) IsSpecialDateTimeExpressionContext() {} @@ -130909,7 +130909,7 @@ func NewSpecialDateTimeExpressionContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_specialDateTimeExpression + p.RuleIndex = StarRocksSQLParserRULE_specialDateTimeExpression return p } @@ -130921,27 +130921,27 @@ func (s *SpecialDateTimeExpressionContext) GetName() antlr.Token { return s.name func (s *SpecialDateTimeExpressionContext) SetName(v antlr.Token) { s.name = v } func (s *SpecialDateTimeExpressionContext) CURRENT_DATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_DATE, 0) + return s.GetToken(StarRocksSQLParserCURRENT_DATE, 0) } func (s *SpecialDateTimeExpressionContext) CURRENT_TIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_TIME, 0) + return s.GetToken(StarRocksSQLParserCURRENT_TIME, 0) } func (s *SpecialDateTimeExpressionContext) CURRENT_TIMESTAMP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT_TIMESTAMP, 0) + return s.GetToken(StarRocksSQLParserCURRENT_TIMESTAMP, 0) } func (s *SpecialDateTimeExpressionContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *SpecialDateTimeExpressionContext) LOCALTIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCALTIME, 0) + return s.GetToken(StarRocksSQLParserLOCALTIME, 0) } func (s *SpecialDateTimeExpressionContext) LOCALTIMESTAMP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCALTIMESTAMP, 0) + return s.GetToken(StarRocksSQLParserLOCALTIMESTAMP, 0) } func (s *SpecialDateTimeExpressionContext) GetRuleContext() antlr.RuleContext { @@ -130953,20 +130953,20 @@ func (s *SpecialDateTimeExpressionContext) ToStringTree(ruleNames []string, reco } func (s *SpecialDateTimeExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSpecialDateTimeExpression(s) } } func (s *SpecialDateTimeExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSpecialDateTimeExpression(s) } } func (s *SpecialDateTimeExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSpecialDateTimeExpression(s) default: @@ -130974,9 +130974,9 @@ func (s *SpecialDateTimeExpressionContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeExpressionContext) { +func (p *StarRocksSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeExpressionContext) { localctx = NewSpecialDateTimeExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 936, DorisSQLParserRULE_specialDateTimeExpression) + p.EnterRule(localctx, 936, StarRocksSQLParserRULE_specialDateTimeExpression) var _la int p.SetState(7577) @@ -130986,12 +130986,12 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCURRENT_DATE: + case StarRocksSQLParserCURRENT_DATE: p.EnterOuterAlt(localctx, 1) { p.SetState(7549) - var _m = p.Match(DorisSQLParserCURRENT_DATE) + var _m = p.Match(StarRocksSQLParserCURRENT_DATE) localctx.(*SpecialDateTimeExpressionContext).name = _m if p.HasError() { @@ -131005,7 +131005,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 871, p.GetParserRuleContext()) == 1 { { p.SetState(7550) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131013,7 +131013,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } { p.SetState(7551) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131024,12 +131024,12 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE goto errorExit } - case DorisSQLParserCURRENT_TIME: + case StarRocksSQLParserCURRENT_TIME: p.EnterOuterAlt(localctx, 2) { p.SetState(7554) - var _m = p.Match(DorisSQLParserCURRENT_TIME) + var _m = p.Match(StarRocksSQLParserCURRENT_TIME) localctx.(*SpecialDateTimeExpressionContext).name = _m if p.HasError() { @@ -131043,7 +131043,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 872, p.GetParserRuleContext()) == 1 { { p.SetState(7555) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131051,7 +131051,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } { p.SetState(7556) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131062,12 +131062,12 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE goto errorExit } - case DorisSQLParserCURRENT_TIMESTAMP: + case StarRocksSQLParserCURRENT_TIMESTAMP: p.EnterOuterAlt(localctx, 3) { p.SetState(7559) - var _m = p.Match(DorisSQLParserCURRENT_TIMESTAMP) + var _m = p.Match(StarRocksSQLParserCURRENT_TIMESTAMP) localctx.(*SpecialDateTimeExpressionContext).name = _m if p.HasError() { @@ -131081,7 +131081,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 874, p.GetParserRuleContext()) == 1 { { p.SetState(7560) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131094,10 +131094,10 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTEGER_VALUE { + if _la == StarRocksSQLParserINTEGER_VALUE { { p.SetState(7561) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131107,7 +131107,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } { p.SetState(7564) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131118,12 +131118,12 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE goto errorExit } - case DorisSQLParserLOCALTIME: + case StarRocksSQLParserLOCALTIME: p.EnterOuterAlt(localctx, 4) { p.SetState(7567) - var _m = p.Match(DorisSQLParserLOCALTIME) + var _m = p.Match(StarRocksSQLParserLOCALTIME) localctx.(*SpecialDateTimeExpressionContext).name = _m if p.HasError() { @@ -131137,7 +131137,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 875, p.GetParserRuleContext()) == 1 { { p.SetState(7568) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131145,7 +131145,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } { p.SetState(7569) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131156,12 +131156,12 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE goto errorExit } - case DorisSQLParserLOCALTIMESTAMP: + case StarRocksSQLParserLOCALTIMESTAMP: p.EnterOuterAlt(localctx, 5) { p.SetState(7572) - var _m = p.Match(DorisSQLParserLOCALTIMESTAMP) + var _m = p.Match(StarRocksSQLParserLOCALTIMESTAMP) localctx.(*SpecialDateTimeExpressionContext).name = _m if p.HasError() { @@ -131175,7 +131175,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 876, p.GetParserRuleContext()) == 1 { { p.SetState(7573) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131183,7 +131183,7 @@ func (p *DorisSQLParser) SpecialDateTimeExpression() (localctx ISpecialDateTimeE } { p.SetState(7574) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131258,13 +131258,13 @@ type SpecialFunctionExpressionContext struct { func NewEmptySpecialFunctionExpressionContext() *SpecialFunctionExpressionContext { var p = new(SpecialFunctionExpressionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_specialFunctionExpression + p.RuleIndex = StarRocksSQLParserRULE_specialFunctionExpression return p } func InitEmptySpecialFunctionExpressionContext(p *SpecialFunctionExpressionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_specialFunctionExpression + p.RuleIndex = StarRocksSQLParserRULE_specialFunctionExpression } func (*SpecialFunctionExpressionContext) IsSpecialFunctionExpressionContext() {} @@ -131275,7 +131275,7 @@ func NewSpecialFunctionExpressionContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_specialFunctionExpression + p.RuleIndex = StarRocksSQLParserRULE_specialFunctionExpression return p } @@ -131283,7 +131283,7 @@ func NewSpecialFunctionExpressionContext(parser antlr.Parser, parent antlr.Parse func (s *SpecialFunctionExpressionContext) GetParser() antlr.Parser { return s.parser } func (s *SpecialFunctionExpressionContext) CHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAR, 0) + return s.GetToken(StarRocksSQLParserCHAR, 0) } func (s *SpecialFunctionExpressionContext) AllExpression() []IExpressionContext { @@ -131328,63 +131328,63 @@ func (s *SpecialFunctionExpressionContext) Expression(i int) IExpressionContext } func (s *SpecialFunctionExpressionContext) DAY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDAY, 0) + return s.GetToken(StarRocksSQLParserDAY, 0) } func (s *SpecialFunctionExpressionContext) HOUR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOUR, 0) + return s.GetToken(StarRocksSQLParserHOUR, 0) } func (s *SpecialFunctionExpressionContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *SpecialFunctionExpressionContext) LEFT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLEFT, 0) + return s.GetToken(StarRocksSQLParserLEFT, 0) } func (s *SpecialFunctionExpressionContext) LIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIKE, 0) + return s.GetToken(StarRocksSQLParserLIKE, 0) } func (s *SpecialFunctionExpressionContext) MINUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUTE, 0) + return s.GetToken(StarRocksSQLParserMINUTE, 0) } func (s *SpecialFunctionExpressionContext) MOD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMOD, 0) + return s.GetToken(StarRocksSQLParserMOD, 0) } func (s *SpecialFunctionExpressionContext) MONTH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMONTH, 0) + return s.GetToken(StarRocksSQLParserMONTH, 0) } func (s *SpecialFunctionExpressionContext) QUARTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUARTER, 0) + return s.GetToken(StarRocksSQLParserQUARTER, 0) } func (s *SpecialFunctionExpressionContext) REGEXP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREGEXP, 0) + return s.GetToken(StarRocksSQLParserREGEXP, 0) } func (s *SpecialFunctionExpressionContext) REPLACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE, 0) + return s.GetToken(StarRocksSQLParserREPLACE, 0) } func (s *SpecialFunctionExpressionContext) RIGHT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRIGHT, 0) + return s.GetToken(StarRocksSQLParserRIGHT, 0) } func (s *SpecialFunctionExpressionContext) RLIKE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRLIKE, 0) + return s.GetToken(StarRocksSQLParserRLIKE, 0) } func (s *SpecialFunctionExpressionContext) SECOND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECOND, 0) + return s.GetToken(StarRocksSQLParserSECOND, 0) } func (s *SpecialFunctionExpressionContext) TIMESTAMPADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMESTAMPADD, 0) + return s.GetToken(StarRocksSQLParserTIMESTAMPADD, 0) } func (s *SpecialFunctionExpressionContext) UnitIdentifier() IUnitIdentifierContext { @@ -131404,15 +131404,15 @@ func (s *SpecialFunctionExpressionContext) UnitIdentifier() IUnitIdentifierConte } func (s *SpecialFunctionExpressionContext) TIMESTAMPDIFF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMESTAMPDIFF, 0) + return s.GetToken(StarRocksSQLParserTIMESTAMPDIFF, 0) } func (s *SpecialFunctionExpressionContext) YEAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserYEAR, 0) + return s.GetToken(StarRocksSQLParserYEAR, 0) } func (s *SpecialFunctionExpressionContext) PASSWORD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPASSWORD, 0) + return s.GetToken(StarRocksSQLParserPASSWORD, 0) } func (s *SpecialFunctionExpressionContext) String_() IStringContext { @@ -131432,11 +131432,11 @@ func (s *SpecialFunctionExpressionContext) String_() IStringContext { } func (s *SpecialFunctionExpressionContext) FLOOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFLOOR, 0) + return s.GetToken(StarRocksSQLParserFLOOR, 0) } func (s *SpecialFunctionExpressionContext) CEIL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCEIL, 0) + return s.GetToken(StarRocksSQLParserCEIL, 0) } func (s *SpecialFunctionExpressionContext) GetRuleContext() antlr.RuleContext { @@ -131448,20 +131448,20 @@ func (s *SpecialFunctionExpressionContext) ToStringTree(ruleNames []string, reco } func (s *SpecialFunctionExpressionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSpecialFunctionExpression(s) } } func (s *SpecialFunctionExpressionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSpecialFunctionExpression(s) } } func (s *SpecialFunctionExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSpecialFunctionExpression(s) default: @@ -131469,9 +131469,9 @@ func (s *SpecialFunctionExpressionContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionExpressionContext) { +func (p *StarRocksSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionExpressionContext) { localctx = NewSpecialFunctionExpressionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 938, DorisSQLParserRULE_specialFunctionExpression) + p.EnterRule(localctx, 938, StarRocksSQLParserRULE_specialFunctionExpression) var _la int p.SetState(7720) @@ -131481,11 +131481,11 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } switch p.GetTokenStream().LA(1) { - case DorisSQLParserCHAR: + case StarRocksSQLParserCHAR: p.EnterOuterAlt(localctx, 1) { p.SetState(7579) - p.Match(DorisSQLParserCHAR) + p.Match(StarRocksSQLParserCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131493,7 +131493,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7580) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131505,18 +131505,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7582) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDAY: + case StarRocksSQLParserDAY: p.EnterOuterAlt(localctx, 2) { p.SetState(7584) - p.Match(DorisSQLParserDAY) + p.Match(StarRocksSQLParserDAY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131524,7 +131524,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7585) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131536,18 +131536,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7587) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserHOUR: + case StarRocksSQLParserHOUR: p.EnterOuterAlt(localctx, 3) { p.SetState(7589) - p.Match(DorisSQLParserHOUR) + p.Match(StarRocksSQLParserHOUR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131555,7 +131555,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7590) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131567,18 +131567,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7592) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserIF: + case StarRocksSQLParserIF: p.EnterOuterAlt(localctx, 4) { p.SetState(7594) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131586,7 +131586,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7595) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131611,10 +131611,10 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7597) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131636,18 +131636,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7606) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserLEFT: + case StarRocksSQLParserLEFT: p.EnterOuterAlt(localctx, 5) { p.SetState(7607) - p.Match(DorisSQLParserLEFT) + p.Match(StarRocksSQLParserLEFT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131655,7 +131655,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7608) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131667,7 +131667,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7610) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131679,18 +131679,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7612) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserLIKE: + case StarRocksSQLParserLIKE: p.EnterOuterAlt(localctx, 6) { p.SetState(7614) - p.Match(DorisSQLParserLIKE) + p.Match(StarRocksSQLParserLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131698,7 +131698,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7615) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131710,7 +131710,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7617) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131722,18 +131722,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7619) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserMINUTE: + case StarRocksSQLParserMINUTE: p.EnterOuterAlt(localctx, 7) { p.SetState(7621) - p.Match(DorisSQLParserMINUTE) + p.Match(StarRocksSQLParserMINUTE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131741,7 +131741,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7622) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131753,18 +131753,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7624) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserMOD: + case StarRocksSQLParserMOD: p.EnterOuterAlt(localctx, 8) { p.SetState(7626) - p.Match(DorisSQLParserMOD) + p.Match(StarRocksSQLParserMOD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131772,7 +131772,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7627) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131784,7 +131784,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7629) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131796,18 +131796,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7631) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserMONTH: + case StarRocksSQLParserMONTH: p.EnterOuterAlt(localctx, 9) { p.SetState(7633) - p.Match(DorisSQLParserMONTH) + p.Match(StarRocksSQLParserMONTH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131815,7 +131815,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7634) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131827,18 +131827,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7636) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserQUARTER: + case StarRocksSQLParserQUARTER: p.EnterOuterAlt(localctx, 10) { p.SetState(7638) - p.Match(DorisSQLParserQUARTER) + p.Match(StarRocksSQLParserQUARTER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131846,7 +131846,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7639) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131858,18 +131858,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7641) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserREGEXP: + case StarRocksSQLParserREGEXP: p.EnterOuterAlt(localctx, 11) { p.SetState(7643) - p.Match(DorisSQLParserREGEXP) + p.Match(StarRocksSQLParserREGEXP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131877,7 +131877,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7644) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131889,7 +131889,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7646) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131901,18 +131901,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7648) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserREPLACE: + case StarRocksSQLParserREPLACE: p.EnterOuterAlt(localctx, 12) { p.SetState(7650) - p.Match(DorisSQLParserREPLACE) + p.Match(StarRocksSQLParserREPLACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131920,7 +131920,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7651) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131945,10 +131945,10 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7653) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131970,18 +131970,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7662) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserRIGHT: + case StarRocksSQLParserRIGHT: p.EnterOuterAlt(localctx, 13) { p.SetState(7663) - p.Match(DorisSQLParserRIGHT) + p.Match(StarRocksSQLParserRIGHT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -131989,7 +131989,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7664) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132001,7 +132001,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7666) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132013,18 +132013,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7668) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserRLIKE: + case StarRocksSQLParserRLIKE: p.EnterOuterAlt(localctx, 14) { p.SetState(7670) - p.Match(DorisSQLParserRLIKE) + p.Match(StarRocksSQLParserRLIKE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132032,7 +132032,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7671) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132044,7 +132044,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7673) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132056,18 +132056,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7675) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserSECOND: + case StarRocksSQLParserSECOND: p.EnterOuterAlt(localctx, 15) { p.SetState(7677) - p.Match(DorisSQLParserSECOND) + p.Match(StarRocksSQLParserSECOND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132075,7 +132075,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7678) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132087,18 +132087,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7680) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserTIMESTAMPADD: + case StarRocksSQLParserTIMESTAMPADD: p.EnterOuterAlt(localctx, 16) { p.SetState(7682) - p.Match(DorisSQLParserTIMESTAMPADD) + p.Match(StarRocksSQLParserTIMESTAMPADD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132106,7 +132106,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7683) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132118,7 +132118,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7685) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132130,7 +132130,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7687) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132142,18 +132142,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7689) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserTIMESTAMPDIFF: + case StarRocksSQLParserTIMESTAMPDIFF: p.EnterOuterAlt(localctx, 17) { p.SetState(7691) - p.Match(DorisSQLParserTIMESTAMPDIFF) + p.Match(StarRocksSQLParserTIMESTAMPDIFF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132161,7 +132161,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7692) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132173,7 +132173,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7694) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132185,7 +132185,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7696) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132197,18 +132197,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7698) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserYEAR: + case StarRocksSQLParserYEAR: p.EnterOuterAlt(localctx, 18) { p.SetState(7700) - p.Match(DorisSQLParserYEAR) + p.Match(StarRocksSQLParserYEAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132216,7 +132216,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7701) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132228,18 +132228,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7703) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserPASSWORD: + case StarRocksSQLParserPASSWORD: p.EnterOuterAlt(localctx, 19) { p.SetState(7705) - p.Match(DorisSQLParserPASSWORD) + p.Match(StarRocksSQLParserPASSWORD) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132247,7 +132247,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7706) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132259,18 +132259,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7708) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserFLOOR: + case StarRocksSQLParserFLOOR: p.EnterOuterAlt(localctx, 20) { p.SetState(7710) - p.Match(DorisSQLParserFLOOR) + p.Match(StarRocksSQLParserFLOOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132278,7 +132278,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7711) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132290,18 +132290,18 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7713) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCEIL: + case StarRocksSQLParserCEIL: p.EnterOuterAlt(localctx, 21) { p.SetState(7715) - p.Match(DorisSQLParserCEIL) + p.Match(StarRocksSQLParserCEIL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132309,7 +132309,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7716) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132321,7 +132321,7 @@ func (p *DorisSQLParser) SpecialFunctionExpression() (localctx ISpecialFunctionE } { p.SetState(7718) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132388,13 +132388,13 @@ type WindowFunctionContext struct { func NewEmptyWindowFunctionContext() *WindowFunctionContext { var p = new(WindowFunctionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_windowFunction + p.RuleIndex = StarRocksSQLParserRULE_windowFunction return p } func InitEmptyWindowFunctionContext(p *WindowFunctionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_windowFunction + p.RuleIndex = StarRocksSQLParserRULE_windowFunction } func (*WindowFunctionContext) IsWindowFunctionContext() {} @@ -132405,7 +132405,7 @@ func NewWindowFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_windowFunction + p.RuleIndex = StarRocksSQLParserRULE_windowFunction return p } @@ -132417,27 +132417,27 @@ func (s *WindowFunctionContext) GetName() antlr.Token { return s.name } func (s *WindowFunctionContext) SetName(v antlr.Token) { s.name = v } func (s *WindowFunctionContext) ROW_NUMBER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROW_NUMBER, 0) + return s.GetToken(StarRocksSQLParserROW_NUMBER, 0) } func (s *WindowFunctionContext) RANK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRANK, 0) + return s.GetToken(StarRocksSQLParserRANK, 0) } func (s *WindowFunctionContext) DENSE_RANK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDENSE_RANK, 0) + return s.GetToken(StarRocksSQLParserDENSE_RANK, 0) } func (s *WindowFunctionContext) CUME_DIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCUME_DIST, 0) + return s.GetToken(StarRocksSQLParserCUME_DIST, 0) } func (s *WindowFunctionContext) PERCENT_RANK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERCENT_RANK, 0) + return s.GetToken(StarRocksSQLParserPERCENT_RANK, 0) } func (s *WindowFunctionContext) NTILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNTILE, 0) + return s.GetToken(StarRocksSQLParserNTILE, 0) } func (s *WindowFunctionContext) AllExpression() []IExpressionContext { @@ -132482,7 +132482,7 @@ func (s *WindowFunctionContext) Expression(i int) IExpressionContext { } func (s *WindowFunctionContext) LEAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLEAD, 0) + return s.GetToken(StarRocksSQLParserLEAD, 0) } func (s *WindowFunctionContext) AllIgnoreNulls() []IIgnoreNullsContext { @@ -132527,15 +132527,15 @@ func (s *WindowFunctionContext) IgnoreNulls(i int) IIgnoreNullsContext { } func (s *WindowFunctionContext) LAG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLAG, 0) + return s.GetToken(StarRocksSQLParserLAG, 0) } func (s *WindowFunctionContext) FIRST_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIRST_VALUE, 0) + return s.GetToken(StarRocksSQLParserFIRST_VALUE, 0) } func (s *WindowFunctionContext) LAST_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLAST_VALUE, 0) + return s.GetToken(StarRocksSQLParserLAST_VALUE, 0) } func (s *WindowFunctionContext) GetRuleContext() antlr.RuleContext { @@ -132547,20 +132547,20 @@ func (s *WindowFunctionContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *WindowFunctionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterWindowFunction(s) } } func (s *WindowFunctionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitWindowFunction(s) } } func (s *WindowFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitWindowFunction(s) default: @@ -132568,9 +132568,9 @@ func (s *WindowFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { +func (p *StarRocksSQLParser) WindowFunction() (localctx IWindowFunctionContext) { localctx = NewWindowFunctionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 940, DorisSQLParserRULE_windowFunction) + p.EnterRule(localctx, 940, StarRocksSQLParserRULE_windowFunction) var _la int p.SetState(7819) @@ -132580,12 +132580,12 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserROW_NUMBER: + case StarRocksSQLParserROW_NUMBER: p.EnterOuterAlt(localctx, 1) { p.SetState(7722) - var _m = p.Match(DorisSQLParserROW_NUMBER) + var _m = p.Match(StarRocksSQLParserROW_NUMBER) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132595,7 +132595,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7723) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132603,19 +132603,19 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7724) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserRANK: + case StarRocksSQLParserRANK: p.EnterOuterAlt(localctx, 2) { p.SetState(7725) - var _m = p.Match(DorisSQLParserRANK) + var _m = p.Match(StarRocksSQLParserRANK) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132625,7 +132625,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7726) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132633,19 +132633,19 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7727) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDENSE_RANK: + case StarRocksSQLParserDENSE_RANK: p.EnterOuterAlt(localctx, 3) { p.SetState(7728) - var _m = p.Match(DorisSQLParserDENSE_RANK) + var _m = p.Match(StarRocksSQLParserDENSE_RANK) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132655,7 +132655,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7729) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132663,19 +132663,19 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7730) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserCUME_DIST: + case StarRocksSQLParserCUME_DIST: p.EnterOuterAlt(localctx, 4) { p.SetState(7731) - var _m = p.Match(DorisSQLParserCUME_DIST) + var _m = p.Match(StarRocksSQLParserCUME_DIST) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132685,7 +132685,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7732) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132693,19 +132693,19 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7733) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserPERCENT_RANK: + case StarRocksSQLParserPERCENT_RANK: p.EnterOuterAlt(localctx, 5) { p.SetState(7734) - var _m = p.Match(DorisSQLParserPERCENT_RANK) + var _m = p.Match(StarRocksSQLParserPERCENT_RANK) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132715,7 +132715,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7735) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132723,19 +132723,19 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7736) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserNTILE: + case StarRocksSQLParserNTILE: p.EnterOuterAlt(localctx, 6) { p.SetState(7737) - var _m = p.Match(DorisSQLParserNTILE) + var _m = p.Match(StarRocksSQLParserNTILE) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132745,7 +132745,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7738) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132767,19 +132767,19 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7742) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserLEAD: + case StarRocksSQLParserLEAD: p.EnterOuterAlt(localctx, 7) { p.SetState(7743) - var _m = p.Match(DorisSQLParserLEAD) + var _m = p.Match(StarRocksSQLParserLEAD) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132789,7 +132789,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7744) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132814,7 +132814,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7746) p.IgnoreNulls() @@ -132828,10 +132828,10 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7749) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132853,7 +132853,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7758) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132866,7 +132866,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7759) p.IgnoreNulls() @@ -132874,12 +132874,12 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } - case DorisSQLParserLAG: + case StarRocksSQLParserLAG: p.EnterOuterAlt(localctx, 8) { p.SetState(7762) - var _m = p.Match(DorisSQLParserLAG) + var _m = p.Match(StarRocksSQLParserLAG) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132889,7 +132889,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7763) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132914,7 +132914,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7765) p.IgnoreNulls() @@ -132928,10 +132928,10 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7768) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132953,7 +132953,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7777) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -132966,7 +132966,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7778) p.IgnoreNulls() @@ -132974,12 +132974,12 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } - case DorisSQLParserFIRST_VALUE: + case StarRocksSQLParserFIRST_VALUE: p.EnterOuterAlt(localctx, 9) { p.SetState(7781) - var _m = p.Match(DorisSQLParserFIRST_VALUE) + var _m = p.Match(StarRocksSQLParserFIRST_VALUE) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -132989,7 +132989,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7782) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133014,7 +133014,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7784) p.IgnoreNulls() @@ -133028,10 +133028,10 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7787) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133053,7 +133053,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7796) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133066,7 +133066,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7797) p.IgnoreNulls() @@ -133074,12 +133074,12 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } - case DorisSQLParserLAST_VALUE: + case StarRocksSQLParserLAST_VALUE: p.EnterOuterAlt(localctx, 10) { p.SetState(7800) - var _m = p.Match(DorisSQLParserLAST_VALUE) + var _m = p.Match(StarRocksSQLParserLAST_VALUE) localctx.(*WindowFunctionContext).name = _m if p.HasError() { @@ -133089,7 +133089,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7801) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133114,7 +133114,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7803) p.IgnoreNulls() @@ -133128,10 +133128,10 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7806) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133153,7 +133153,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } { p.SetState(7815) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133166,7 +133166,7 @@ func (p *DorisSQLParser) WindowFunction() (localctx IWindowFunctionContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIGNORE { + if _la == StarRocksSQLParserIGNORE { { p.SetState(7816) p.IgnoreNulls() @@ -133231,13 +133231,13 @@ type WhenClauseContext struct { func NewEmptyWhenClauseContext() *WhenClauseContext { var p = new(WhenClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_whenClause + p.RuleIndex = StarRocksSQLParserRULE_whenClause return p } func InitEmptyWhenClauseContext(p *WhenClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_whenClause + p.RuleIndex = StarRocksSQLParserRULE_whenClause } func (*WhenClauseContext) IsWhenClauseContext() {} @@ -133248,7 +133248,7 @@ func NewWhenClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_whenClause + p.RuleIndex = StarRocksSQLParserRULE_whenClause return p } @@ -133264,11 +133264,11 @@ func (s *WhenClauseContext) SetCondition(v IExpressionContext) { s.condition = v func (s *WhenClauseContext) SetResult(v IExpressionContext) { s.result = v } func (s *WhenClauseContext) WHEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHEN, 0) + return s.GetToken(StarRocksSQLParserWHEN, 0) } func (s *WhenClauseContext) THEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTHEN, 0) + return s.GetToken(StarRocksSQLParserTHEN, 0) } func (s *WhenClauseContext) AllExpression() []IExpressionContext { @@ -133321,20 +133321,20 @@ func (s *WhenClauseContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *WhenClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterWhenClause(s) } } func (s *WhenClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitWhenClause(s) } } func (s *WhenClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitWhenClause(s) default: @@ -133342,13 +133342,13 @@ func (s *WhenClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) WhenClause() (localctx IWhenClauseContext) { +func (p *StarRocksSQLParser) WhenClause() (localctx IWhenClauseContext) { localctx = NewWhenClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 942, DorisSQLParserRULE_whenClause) + p.EnterRule(localctx, 942, StarRocksSQLParserRULE_whenClause) p.EnterOuterAlt(localctx, 1) { p.SetState(7821) - p.Match(DorisSQLParserWHEN) + p.Match(StarRocksSQLParserWHEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133363,7 +133363,7 @@ func (p *DorisSQLParser) WhenClause() (localctx IWhenClauseContext) { } { p.SetState(7823) - p.Match(DorisSQLParserTHEN) + p.Match(StarRocksSQLParserTHEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133436,13 +133436,13 @@ type OverContext struct { func NewEmptyOverContext() *OverContext { var p = new(OverContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_over + p.RuleIndex = StarRocksSQLParserRULE_over return p } func InitEmptyOverContext(p *OverContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_over + p.RuleIndex = StarRocksSQLParserRULE_over } func (*OverContext) IsOverContext() {} @@ -133453,7 +133453,7 @@ func NewOverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_over + p.RuleIndex = StarRocksSQLParserRULE_over return p } @@ -133469,23 +133469,23 @@ func (s *OverContext) GetPartition() []IExpressionContext { return s.partition } func (s *OverContext) SetPartition(v []IExpressionContext) { s.partition = v } func (s *OverContext) OVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOVER, 0) + return s.GetToken(StarRocksSQLParserOVER, 0) } func (s *OverContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *OverContext) AllBY() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserBY) + return s.GetTokens(StarRocksSQLParserBY) } func (s *OverContext) BY(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, i) + return s.GetToken(StarRocksSQLParserBY, i) } func (s *OverContext) ORDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserORDER, 0) + return s.GetToken(StarRocksSQLParserORDER, 0) } func (s *OverContext) AllSortItem() []ISortItemContext { @@ -133611,20 +133611,20 @@ func (s *OverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) s } func (s *OverContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOver(s) } } func (s *OverContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOver(s) } } func (s *OverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOver(s) default: @@ -133632,15 +133632,15 @@ func (s *OverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Over() (localctx IOverContext) { +func (p *StarRocksSQLParser) Over() (localctx IOverContext) { localctx = NewOverContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 944, DorisSQLParserRULE_over) + p.EnterRule(localctx, 944, StarRocksSQLParserRULE_over) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7826) - p.Match(DorisSQLParserOVER) + p.Match(StarRocksSQLParserOVER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133648,7 +133648,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } { p.SetState(7827) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133661,7 +133661,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__5 || _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserT__5 || _la == StarRocksSQLParserPARTITION { p.SetState(7829) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -133669,7 +133669,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__5 { + if _la == StarRocksSQLParserT__5 { { p.SetState(7828) p.BracketHint() @@ -133678,7 +133678,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } { p.SetState(7831) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133686,7 +133686,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } { p.SetState(7832) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133707,10 +133707,10 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7834) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133741,10 +133741,10 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserORDER { + if _la == StarRocksSQLParserORDER { { p.SetState(7843) - p.Match(DorisSQLParserORDER) + p.Match(StarRocksSQLParserORDER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133752,7 +133752,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } { p.SetState(7844) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133769,10 +133769,10 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7846) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133799,7 +133799,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserRANGE || _la == DorisSQLParserROWS { + if _la == StarRocksSQLParserRANGE || _la == StarRocksSQLParserROWS { { p.SetState(7855) p.WindowFrame() @@ -133808,7 +133808,7 @@ func (p *DorisSQLParser) Over() (localctx IOverContext) { } { p.SetState(7858) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133851,13 +133851,13 @@ type IgnoreNullsContext struct { func NewEmptyIgnoreNullsContext() *IgnoreNullsContext { var p = new(IgnoreNullsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_ignoreNulls + p.RuleIndex = StarRocksSQLParserRULE_ignoreNulls return p } func InitEmptyIgnoreNullsContext(p *IgnoreNullsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_ignoreNulls + p.RuleIndex = StarRocksSQLParserRULE_ignoreNulls } func (*IgnoreNullsContext) IsIgnoreNullsContext() {} @@ -133868,7 +133868,7 @@ func NewIgnoreNullsContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_ignoreNulls + p.RuleIndex = StarRocksSQLParserRULE_ignoreNulls return p } @@ -133876,11 +133876,11 @@ func NewIgnoreNullsContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *IgnoreNullsContext) GetParser() antlr.Parser { return s.parser } func (s *IgnoreNullsContext) IGNORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIGNORE, 0) + return s.GetToken(StarRocksSQLParserIGNORE, 0) } func (s *IgnoreNullsContext) NULLS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULLS, 0) + return s.GetToken(StarRocksSQLParserNULLS, 0) } func (s *IgnoreNullsContext) GetRuleContext() antlr.RuleContext { @@ -133892,20 +133892,20 @@ func (s *IgnoreNullsContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *IgnoreNullsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIgnoreNulls(s) } } func (s *IgnoreNullsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIgnoreNulls(s) } } func (s *IgnoreNullsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIgnoreNulls(s) default: @@ -133913,13 +133913,13 @@ func (s *IgnoreNullsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) IgnoreNulls() (localctx IIgnoreNullsContext) { +func (p *StarRocksSQLParser) IgnoreNulls() (localctx IIgnoreNullsContext) { localctx = NewIgnoreNullsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 946, DorisSQLParserRULE_ignoreNulls) + p.EnterRule(localctx, 946, StarRocksSQLParserRULE_ignoreNulls) p.EnterOuterAlt(localctx, 1) { p.SetState(7860) - p.Match(DorisSQLParserIGNORE) + p.Match(StarRocksSQLParserIGNORE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133927,7 +133927,7 @@ func (p *DorisSQLParser) IgnoreNulls() (localctx IIgnoreNullsContext) { } { p.SetState(7861) - p.Match(DorisSQLParserNULLS) + p.Match(StarRocksSQLParserNULLS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -133995,13 +133995,13 @@ type WindowFrameContext struct { func NewEmptyWindowFrameContext() *WindowFrameContext { var p = new(WindowFrameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_windowFrame + p.RuleIndex = StarRocksSQLParserRULE_windowFrame return p } func InitEmptyWindowFrameContext(p *WindowFrameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_windowFrame + p.RuleIndex = StarRocksSQLParserRULE_windowFrame } func (*WindowFrameContext) IsWindowFrameContext() {} @@ -134012,7 +134012,7 @@ func NewWindowFrameContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_windowFrame + p.RuleIndex = StarRocksSQLParserRULE_windowFrame return p } @@ -134032,7 +134032,7 @@ func (s *WindowFrameContext) SetStart_(v IFrameBoundContext) { s.start_ = v } func (s *WindowFrameContext) SetEnd(v IFrameBoundContext) { s.end = v } func (s *WindowFrameContext) RANGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRANGE, 0) + return s.GetToken(StarRocksSQLParserRANGE, 0) } func (s *WindowFrameContext) AllFrameBound() []IFrameBoundContext { @@ -134077,15 +134077,15 @@ func (s *WindowFrameContext) FrameBound(i int) IFrameBoundContext { } func (s *WindowFrameContext) ROWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROWS, 0) + return s.GetToken(StarRocksSQLParserROWS, 0) } func (s *WindowFrameContext) BETWEEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBETWEEN, 0) + return s.GetToken(StarRocksSQLParserBETWEEN, 0) } func (s *WindowFrameContext) AND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAND, 0) + return s.GetToken(StarRocksSQLParserAND, 0) } func (s *WindowFrameContext) GetRuleContext() antlr.RuleContext { @@ -134097,20 +134097,20 @@ func (s *WindowFrameContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *WindowFrameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterWindowFrame(s) } } func (s *WindowFrameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitWindowFrame(s) } } func (s *WindowFrameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitWindowFrame(s) default: @@ -134118,9 +134118,9 @@ func (s *WindowFrameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { +func (p *StarRocksSQLParser) WindowFrame() (localctx IWindowFrameContext) { localctx = NewWindowFrameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 948, DorisSQLParserRULE_windowFrame) + p.EnterRule(localctx, 948, StarRocksSQLParserRULE_windowFrame) p.SetState(7879) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -134133,7 +134133,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { { p.SetState(7863) - var _m = p.Match(DorisSQLParserRANGE) + var _m = p.Match(StarRocksSQLParserRANGE) localctx.(*WindowFrameContext).frameType = _m if p.HasError() { @@ -134154,7 +134154,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { { p.SetState(7865) - var _m = p.Match(DorisSQLParserROWS) + var _m = p.Match(StarRocksSQLParserROWS) localctx.(*WindowFrameContext).frameType = _m if p.HasError() { @@ -134175,7 +134175,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { { p.SetState(7867) - var _m = p.Match(DorisSQLParserRANGE) + var _m = p.Match(StarRocksSQLParserRANGE) localctx.(*WindowFrameContext).frameType = _m if p.HasError() { @@ -134185,7 +134185,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { } { p.SetState(7868) - p.Match(DorisSQLParserBETWEEN) + p.Match(StarRocksSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134200,7 +134200,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { } { p.SetState(7870) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134219,7 +134219,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { { p.SetState(7873) - var _m = p.Match(DorisSQLParserROWS) + var _m = p.Match(StarRocksSQLParserROWS) localctx.(*WindowFrameContext).frameType = _m if p.HasError() { @@ -134229,7 +134229,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { } { p.SetState(7874) - p.Match(DorisSQLParserBETWEEN) + p.Match(StarRocksSQLParserBETWEEN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134244,7 +134244,7 @@ func (p *DorisSQLParser) WindowFrame() (localctx IWindowFrameContext) { } { p.SetState(7876) - p.Match(DorisSQLParserAND) + p.Match(StarRocksSQLParserAND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134293,13 +134293,13 @@ type FrameBoundContext struct { func NewEmptyFrameBoundContext() *FrameBoundContext { var p = new(FrameBoundContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_frameBound + p.RuleIndex = StarRocksSQLParserRULE_frameBound return p } func InitEmptyFrameBoundContext(p *FrameBoundContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_frameBound + p.RuleIndex = StarRocksSQLParserRULE_frameBound } func (*FrameBoundContext) IsFrameBoundContext() {} @@ -134310,7 +134310,7 @@ func NewFrameBoundContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_frameBound + p.RuleIndex = StarRocksSQLParserRULE_frameBound return p } @@ -134369,28 +134369,28 @@ func (s *BoundedFrameContext) Expression() IExpressionContext { } func (s *BoundedFrameContext) PRECEDING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRECEDING, 0) + return s.GetToken(StarRocksSQLParserPRECEDING, 0) } func (s *BoundedFrameContext) FOLLOWING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOLLOWING, 0) + return s.GetToken(StarRocksSQLParserFOLLOWING, 0) } func (s *BoundedFrameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBoundedFrame(s) } } func (s *BoundedFrameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBoundedFrame(s) } } func (s *BoundedFrameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBoundedFrame(s) default: @@ -134422,32 +134422,32 @@ func (s *UnboundedFrameContext) GetRuleContext() antlr.RuleContext { } func (s *UnboundedFrameContext) UNBOUNDED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNBOUNDED, 0) + return s.GetToken(StarRocksSQLParserUNBOUNDED, 0) } func (s *UnboundedFrameContext) PRECEDING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRECEDING, 0) + return s.GetToken(StarRocksSQLParserPRECEDING, 0) } func (s *UnboundedFrameContext) FOLLOWING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOLLOWING, 0) + return s.GetToken(StarRocksSQLParserFOLLOWING, 0) } func (s *UnboundedFrameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUnboundedFrame(s) } } func (s *UnboundedFrameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUnboundedFrame(s) } } func (s *UnboundedFrameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUnboundedFrame(s) default: @@ -134474,28 +134474,28 @@ func (s *CurrentRowBoundContext) GetRuleContext() antlr.RuleContext { } func (s *CurrentRowBoundContext) CURRENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT, 0) + return s.GetToken(StarRocksSQLParserCURRENT, 0) } func (s *CurrentRowBoundContext) ROW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROW, 0) + return s.GetToken(StarRocksSQLParserROW, 0) } func (s *CurrentRowBoundContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterCurrentRowBound(s) } } func (s *CurrentRowBoundContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitCurrentRowBound(s) } } func (s *CurrentRowBoundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitCurrentRowBound(s) default: @@ -134503,9 +134503,9 @@ func (s *CurrentRowBoundContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { +func (p *StarRocksSQLParser) FrameBound() (localctx IFrameBoundContext) { localctx = NewFrameBoundContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 950, DorisSQLParserRULE_frameBound) + p.EnterRule(localctx, 950, StarRocksSQLParserRULE_frameBound) var _la int p.SetState(7890) @@ -134520,7 +134520,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(7881) - p.Match(DorisSQLParserUNBOUNDED) + p.Match(StarRocksSQLParserUNBOUNDED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134529,7 +134529,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { { p.SetState(7882) - var _m = p.Match(DorisSQLParserPRECEDING) + var _m = p.Match(StarRocksSQLParserPRECEDING) localctx.(*UnboundedFrameContext).boundType = _m if p.HasError() { @@ -134543,7 +134543,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(7883) - p.Match(DorisSQLParserUNBOUNDED) + p.Match(StarRocksSQLParserUNBOUNDED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134552,7 +134552,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { { p.SetState(7884) - var _m = p.Match(DorisSQLParserFOLLOWING) + var _m = p.Match(StarRocksSQLParserFOLLOWING) localctx.(*UnboundedFrameContext).boundType = _m if p.HasError() { @@ -134566,7 +134566,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(7885) - p.Match(DorisSQLParserCURRENT) + p.Match(StarRocksSQLParserCURRENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134574,7 +134574,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { } { p.SetState(7886) - p.Match(DorisSQLParserROW) + p.Match(StarRocksSQLParserROW) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134597,7 +134597,7 @@ func (p *DorisSQLParser) FrameBound() (localctx IFrameBoundContext) { _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFOLLOWING || _la == DorisSQLParserPRECEDING) { + if !(_la == StarRocksSQLParserFOLLOWING || _la == StarRocksSQLParserPRECEDING) { var _ri = p.GetErrorHandler().RecoverInline(p) localctx.(*BoundedFrameContext).boundType = _ri @@ -134657,13 +134657,13 @@ type BackupRestoreObjectDescContext struct { func NewEmptyBackupRestoreObjectDescContext() *BackupRestoreObjectDescContext { var p = new(BackupRestoreObjectDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_backupRestoreObjectDesc + p.RuleIndex = StarRocksSQLParserRULE_backupRestoreObjectDesc return p } func InitEmptyBackupRestoreObjectDescContext(p *BackupRestoreObjectDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_backupRestoreObjectDesc + p.RuleIndex = StarRocksSQLParserRULE_backupRestoreObjectDesc } func (*BackupRestoreObjectDescContext) IsBackupRestoreObjectDescContext() {} @@ -134674,7 +134674,7 @@ func NewBackupRestoreObjectDescContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_backupRestoreObjectDesc + p.RuleIndex = StarRocksSQLParserRULE_backupRestoreObjectDesc return p } @@ -134698,7 +134698,7 @@ func (s *BackupRestoreObjectDescContext) BackupRestoreTableDesc() IBackupRestore } func (s *BackupRestoreObjectDescContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *BackupRestoreObjectDescContext) QualifiedName() IQualifiedNameContext { @@ -134718,15 +134718,15 @@ func (s *BackupRestoreObjectDescContext) QualifiedName() IQualifiedNameContext { } func (s *BackupRestoreObjectDescContext) FUNCTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTION, 0) + return s.GetToken(StarRocksSQLParserFUNCTION, 0) } func (s *BackupRestoreObjectDescContext) FUNCTIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTIONS, 0) + return s.GetToken(StarRocksSQLParserFUNCTIONS, 0) } func (s *BackupRestoreObjectDescContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *BackupRestoreObjectDescContext) Identifier() IIdentifierContext { @@ -134746,23 +134746,23 @@ func (s *BackupRestoreObjectDescContext) Identifier() IIdentifierContext { } func (s *BackupRestoreObjectDescContext) TABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLE, 0) + return s.GetToken(StarRocksSQLParserTABLE, 0) } func (s *BackupRestoreObjectDescContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *BackupRestoreObjectDescContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *BackupRestoreObjectDescContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *BackupRestoreObjectDescContext) VIEWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEWS, 0) + return s.GetToken(StarRocksSQLParserVIEWS, 0) } func (s *BackupRestoreObjectDescContext) GetRuleContext() antlr.RuleContext { @@ -134774,20 +134774,20 @@ func (s *BackupRestoreObjectDescContext) ToStringTree(ruleNames []string, recog } func (s *BackupRestoreObjectDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBackupRestoreObjectDesc(s) } } func (s *BackupRestoreObjectDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBackupRestoreObjectDesc(s) } } func (s *BackupRestoreObjectDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBackupRestoreObjectDesc(s) default: @@ -134795,9 +134795,9 @@ func (s *BackupRestoreObjectDescContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjectDescContext) { +func (p *StarRocksSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjectDescContext) { localctx = NewBackupRestoreObjectDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 952, DorisSQLParserRULE_backupRestoreObjectDesc) + p.EnterRule(localctx, 952, StarRocksSQLParserRULE_backupRestoreObjectDesc) var _la int p.SetState(7931) @@ -134823,10 +134823,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: { p.SetState(7893) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134836,7 +134836,7 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec p.SetState(7894) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFUNCTION || _la == DorisSQLParserFUNCTIONS) { + if !(_la == StarRocksSQLParserFUNCTION || _la == StarRocksSQLParserFUNCTIONS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -134844,12 +134844,12 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } } - case DorisSQLParserFUNCTION, DorisSQLParserFUNCTIONS: + case StarRocksSQLParserFUNCTION, StarRocksSQLParserFUNCTIONS: { p.SetState(7895) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFUNCTION || _la == DorisSQLParserFUNCTIONS) { + if !(_la == StarRocksSQLParserFUNCTION || _la == StarRocksSQLParserFUNCTIONS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -134867,10 +134867,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(7897) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134897,10 +134897,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: { p.SetState(7903) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134910,7 +134910,7 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec p.SetState(7904) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserTABLE || _la == DorisSQLParserTABLES) { + if !(_la == StarRocksSQLParserTABLE || _la == StarRocksSQLParserTABLES) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -134918,12 +134918,12 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } } - case DorisSQLParserTABLE, DorisSQLParserTABLES: + case StarRocksSQLParserTABLE, StarRocksSQLParserTABLES: { p.SetState(7905) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserTABLE || _la == DorisSQLParserTABLES) { + if !(_la == StarRocksSQLParserTABLE || _la == StarRocksSQLParserTABLES) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -134949,10 +134949,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: { p.SetState(7909) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134960,7 +134960,7 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } { p.SetState(7910) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134970,7 +134970,7 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec p.SetState(7911) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserVIEW || _la == DorisSQLParserVIEWS) { + if !(_la == StarRocksSQLParserVIEW || _la == StarRocksSQLParserVIEWS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -134978,10 +134978,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } } - case DorisSQLParserMATERIALIZED: + case StarRocksSQLParserMATERIALIZED: { p.SetState(7912) - p.Match(DorisSQLParserMATERIALIZED) + p.Match(StarRocksSQLParserMATERIALIZED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -134991,7 +134991,7 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec p.SetState(7913) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserVIEW || _la == DorisSQLParserVIEWS) { + if !(_la == StarRocksSQLParserVIEW || _la == StarRocksSQLParserVIEWS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -135009,10 +135009,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(7915) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -135039,10 +135039,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } switch p.GetTokenStream().LA(1) { - case DorisSQLParserALL: + case StarRocksSQLParserALL: { p.SetState(7921) - p.Match(DorisSQLParserALL) + p.Match(StarRocksSQLParserALL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -135052,7 +135052,7 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec p.SetState(7922) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserVIEW || _la == DorisSQLParserVIEWS) { + if !(_la == StarRocksSQLParserVIEW || _la == StarRocksSQLParserVIEWS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -135060,12 +135060,12 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } } - case DorisSQLParserVIEW, DorisSQLParserVIEWS: + case StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS: { p.SetState(7923) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserVIEW || _la == DorisSQLParserVIEWS) { + if !(_la == StarRocksSQLParserVIEW || _la == StarRocksSQLParserVIEWS) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -135083,10 +135083,10 @@ func (p *DorisSQLParser) BackupRestoreObjectDesc() (localctx IBackupRestoreObjec } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(7925) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -135144,13 +135144,13 @@ type TableDescContext struct { func NewEmptyTableDescContext() *TableDescContext { var p = new(TableDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableDesc + p.RuleIndex = StarRocksSQLParserRULE_tableDesc return p } func InitEmptyTableDescContext(p *TableDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableDesc + p.RuleIndex = StarRocksSQLParserRULE_tableDesc } func (*TableDescContext) IsTableDescContext() {} @@ -135161,7 +135161,7 @@ func NewTableDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tableDesc + p.RuleIndex = StarRocksSQLParserRULE_tableDesc return p } @@ -135209,20 +135209,20 @@ func (s *TableDescContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *TableDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTableDesc(s) } } func (s *TableDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTableDesc(s) } } func (s *TableDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTableDesc(s) default: @@ -135230,9 +135230,9 @@ func (s *TableDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TableDesc() (localctx ITableDescContext) { +func (p *StarRocksSQLParser) TableDesc() (localctx ITableDescContext) { localctx = NewTableDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 954, DorisSQLParserRULE_tableDesc) + p.EnterRule(localctx, 954, StarRocksSQLParserRULE_tableDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -135247,7 +135247,7 @@ func (p *DorisSQLParser) TableDesc() (localctx ITableDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(7934) p.PartitionNames() @@ -135293,13 +135293,13 @@ type BackupRestoreTableDescContext struct { func NewEmptyBackupRestoreTableDescContext() *BackupRestoreTableDescContext { var p = new(BackupRestoreTableDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_backupRestoreTableDesc + p.RuleIndex = StarRocksSQLParserRULE_backupRestoreTableDesc return p } func InitEmptyBackupRestoreTableDescContext(p *BackupRestoreTableDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_backupRestoreTableDesc + p.RuleIndex = StarRocksSQLParserRULE_backupRestoreTableDesc } func (*BackupRestoreTableDescContext) IsBackupRestoreTableDescContext() {} @@ -135310,7 +135310,7 @@ func NewBackupRestoreTableDescContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_backupRestoreTableDesc + p.RuleIndex = StarRocksSQLParserRULE_backupRestoreTableDesc return p } @@ -135350,7 +135350,7 @@ func (s *BackupRestoreTableDescContext) PartitionNames() IPartitionNamesContext } func (s *BackupRestoreTableDescContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *BackupRestoreTableDescContext) Identifier() IIdentifierContext { @@ -135378,20 +135378,20 @@ func (s *BackupRestoreTableDescContext) ToStringTree(ruleNames []string, recog a } func (s *BackupRestoreTableDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBackupRestoreTableDesc(s) } } func (s *BackupRestoreTableDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBackupRestoreTableDesc(s) } } func (s *BackupRestoreTableDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBackupRestoreTableDesc(s) default: @@ -135399,9 +135399,9 @@ func (s *BackupRestoreTableDescContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) BackupRestoreTableDesc() (localctx IBackupRestoreTableDescContext) { +func (p *StarRocksSQLParser) BackupRestoreTableDesc() (localctx IBackupRestoreTableDescContext) { localctx = NewBackupRestoreTableDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 956, DorisSQLParserRULE_backupRestoreTableDesc) + p.EnterRule(localctx, 956, StarRocksSQLParserRULE_backupRestoreTableDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -135416,7 +135416,7 @@ func (p *DorisSQLParser) BackupRestoreTableDesc() (localctx IBackupRestoreTableD } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserPARTITIONS || _la == DorisSQLParserTEMPORARY { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserPARTITIONS || _la == StarRocksSQLParserTEMPORARY { { p.SetState(7938) p.PartitionNames() @@ -135430,10 +135430,10 @@ func (p *DorisSQLParser) BackupRestoreTableDesc() (localctx IBackupRestoreTableD } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(7941) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -135488,13 +135488,13 @@ type ExplainDescContext struct { func NewEmptyExplainDescContext() *ExplainDescContext { var p = new(ExplainDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_explainDesc + p.RuleIndex = StarRocksSQLParserRULE_explainDesc return p } func InitEmptyExplainDescContext(p *ExplainDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_explainDesc + p.RuleIndex = StarRocksSQLParserRULE_explainDesc } func (*ExplainDescContext) IsExplainDescContext() {} @@ -135505,7 +135505,7 @@ func NewExplainDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_explainDesc + p.RuleIndex = StarRocksSQLParserRULE_explainDesc return p } @@ -135513,35 +135513,35 @@ func NewExplainDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *ExplainDescContext) GetParser() antlr.Parser { return s.parser } func (s *ExplainDescContext) DESC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESC, 0) + return s.GetToken(StarRocksSQLParserDESC, 0) } func (s *ExplainDescContext) DESCRIBE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDESCRIBE, 0) + return s.GetToken(StarRocksSQLParserDESCRIBE, 0) } func (s *ExplainDescContext) EXPLAIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPLAIN, 0) + return s.GetToken(StarRocksSQLParserEXPLAIN, 0) } func (s *ExplainDescContext) LOGICAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGICAL, 0) + return s.GetToken(StarRocksSQLParserLOGICAL, 0) } func (s *ExplainDescContext) ANALYZE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANALYZE, 0) + return s.GetToken(StarRocksSQLParserANALYZE, 0) } func (s *ExplainDescContext) VERBOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERBOSE, 0) + return s.GetToken(StarRocksSQLParserVERBOSE, 0) } func (s *ExplainDescContext) COSTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOSTS, 0) + return s.GetToken(StarRocksSQLParserCOSTS, 0) } func (s *ExplainDescContext) SCHEDULER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEDULER, 0) + return s.GetToken(StarRocksSQLParserSCHEDULER, 0) } func (s *ExplainDescContext) GetRuleContext() antlr.RuleContext { @@ -135553,20 +135553,20 @@ func (s *ExplainDescContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *ExplainDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExplainDesc(s) } } func (s *ExplainDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExplainDesc(s) } } func (s *ExplainDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExplainDesc(s) default: @@ -135574,9 +135574,9 @@ func (s *ExplainDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) ExplainDesc() (localctx IExplainDescContext) { +func (p *StarRocksSQLParser) ExplainDesc() (localctx IExplainDescContext) { localctx = NewExplainDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 958, DorisSQLParserRULE_explainDesc) + p.EnterRule(localctx, 958, StarRocksSQLParserRULE_explainDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -135598,12 +135598,12 @@ func (p *DorisSQLParser) ExplainDesc() (localctx IExplainDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserANALYZE || _la == DorisSQLParserCOSTS || _la == DorisSQLParserLOGICAL || _la == DorisSQLParserSCHEDULER || _la == DorisSQLParserVERBOSE { + if _la == StarRocksSQLParserANALYZE || _la == StarRocksSQLParserCOSTS || _la == StarRocksSQLParserLOGICAL || _la == StarRocksSQLParserSCHEDULER || _la == StarRocksSQLParserVERBOSE { { p.SetState(7946) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserANALYZE || _la == DorisSQLParserCOSTS || _la == DorisSQLParserLOGICAL || _la == DorisSQLParserSCHEDULER || _la == DorisSQLParserVERBOSE) { + if !(_la == StarRocksSQLParserANALYZE || _la == StarRocksSQLParserCOSTS || _la == StarRocksSQLParserLOGICAL || _la == StarRocksSQLParserSCHEDULER || _la == StarRocksSQLParserVERBOSE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -135654,13 +135654,13 @@ type OptimizerTraceContext struct { func NewEmptyOptimizerTraceContext() *OptimizerTraceContext { var p = new(OptimizerTraceContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_optimizerTrace + p.RuleIndex = StarRocksSQLParserRULE_optimizerTrace return p } func InitEmptyOptimizerTraceContext(p *OptimizerTraceContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_optimizerTrace + p.RuleIndex = StarRocksSQLParserRULE_optimizerTrace } func (*OptimizerTraceContext) IsOptimizerTraceContext() {} @@ -135671,7 +135671,7 @@ func NewOptimizerTraceContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_optimizerTrace + p.RuleIndex = StarRocksSQLParserRULE_optimizerTrace return p } @@ -135679,27 +135679,27 @@ func NewOptimizerTraceContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *OptimizerTraceContext) GetParser() antlr.Parser { return s.parser } func (s *OptimizerTraceContext) TRACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRACE, 0) + return s.GetToken(StarRocksSQLParserTRACE, 0) } func (s *OptimizerTraceContext) ALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserALL, 0) + return s.GetToken(StarRocksSQLParserALL, 0) } func (s *OptimizerTraceContext) LOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGS, 0) + return s.GetToken(StarRocksSQLParserLOGS, 0) } func (s *OptimizerTraceContext) TIMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMES, 0) + return s.GetToken(StarRocksSQLParserTIMES, 0) } func (s *OptimizerTraceContext) VALUES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUES, 0) + return s.GetToken(StarRocksSQLParserVALUES, 0) } func (s *OptimizerTraceContext) REASON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREASON, 0) + return s.GetToken(StarRocksSQLParserREASON, 0) } func (s *OptimizerTraceContext) Identifier() IIdentifierContext { @@ -135727,20 +135727,20 @@ func (s *OptimizerTraceContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *OptimizerTraceContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOptimizerTrace(s) } } func (s *OptimizerTraceContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOptimizerTrace(s) } } func (s *OptimizerTraceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOptimizerTrace(s) default: @@ -135748,15 +135748,15 @@ func (s *OptimizerTraceContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) OptimizerTrace() (localctx IOptimizerTraceContext) { +func (p *StarRocksSQLParser) OptimizerTrace() (localctx IOptimizerTraceContext) { localctx = NewOptimizerTraceContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 960, DorisSQLParserRULE_optimizerTrace) + p.EnterRule(localctx, 960, StarRocksSQLParserRULE_optimizerTrace) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(7949) - p.Match(DorisSQLParserTRACE) + p.Match(StarRocksSQLParserTRACE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -135766,7 +135766,7 @@ func (p *DorisSQLParser) OptimizerTrace() (localctx IOptimizerTraceContext) { p.SetState(7950) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserALL || _la == DorisSQLParserLOGS || _la == DorisSQLParserREASON || _la == DorisSQLParserTIMES || _la == DorisSQLParserVALUES) { + if !(_la == StarRocksSQLParserALL || _la == StarRocksSQLParserLOGS || _la == StarRocksSQLParserREASON || _la == StarRocksSQLParserTIMES || _la == StarRocksSQLParserVALUES) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -135824,13 +135824,13 @@ type PartitionExprContext struct { func NewEmptyPartitionExprContext() *PartitionExprContext { var p = new(PartitionExprContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionExpr + p.RuleIndex = StarRocksSQLParserRULE_partitionExpr return p } func InitEmptyPartitionExprContext(p *PartitionExprContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionExpr + p.RuleIndex = StarRocksSQLParserRULE_partitionExpr } func (*PartitionExprContext) IsPartitionExprContext() {} @@ -135841,7 +135841,7 @@ func NewPartitionExprContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionExpr + p.RuleIndex = StarRocksSQLParserRULE_partitionExpr return p } @@ -135889,20 +135889,20 @@ func (s *PartitionExprContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *PartitionExprContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionExpr(s) } } func (s *PartitionExprContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionExpr(s) } } func (s *PartitionExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionExpr(s) default: @@ -135910,9 +135910,9 @@ func (s *PartitionExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) PartitionExpr() (localctx IPartitionExprContext) { +func (p *StarRocksSQLParser) PartitionExpr() (localctx IPartitionExprContext) { localctx = NewPartitionExprContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 962, DorisSQLParserRULE_partitionExpr) + p.EnterRule(localctx, 962, StarRocksSQLParserRULE_partitionExpr) p.SetState(7956) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -135985,13 +135985,13 @@ type PartitionDescContext struct { func NewEmptyPartitionDescContext() *PartitionDescContext { var p = new(PartitionDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionDesc return p } func InitEmptyPartitionDescContext(p *PartitionDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionDesc } func (*PartitionDescContext) IsPartitionDescContext() {} @@ -136002,7 +136002,7 @@ func NewPartitionDescContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionDesc return p } @@ -136010,15 +136010,15 @@ func NewPartitionDescContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *PartitionDescContext) GetParser() antlr.Parser { return s.parser } func (s *PartitionDescContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *PartitionDescContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *PartitionDescContext) RANGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRANGE, 0) + return s.GetToken(StarRocksSQLParserRANGE, 0) } func (s *PartitionDescContext) IdentifierList() IIdentifierListContext { @@ -136095,7 +136095,7 @@ func (s *PartitionDescContext) PrimaryExpression() IPrimaryExpressionContext { } func (s *PartitionDescContext) LIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIST, 0) + return s.GetToken(StarRocksSQLParserLIST, 0) } func (s *PartitionDescContext) AllListPartitionDesc() []IListPartitionDescContext { @@ -136205,20 +136205,20 @@ func (s *PartitionDescContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *PartitionDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionDesc(s) } } func (s *PartitionDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionDesc(s) } } func (s *PartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionDesc(s) default: @@ -136226,9 +136226,9 @@ func (s *PartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { +func (p *StarRocksSQLParser) PartitionDesc() (localctx IPartitionDescContext) { localctx = NewPartitionDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 964, DorisSQLParserRULE_partitionDesc) + p.EnterRule(localctx, 964, StarRocksSQLParserRULE_partitionDesc) var _la int var _alt int @@ -136244,7 +136244,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(7958) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136252,7 +136252,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7959) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136260,7 +136260,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7960) - p.Match(DorisSQLParserRANGE) + p.Match(StarRocksSQLParserRANGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136272,7 +136272,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7962) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136285,7 +136285,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserSTART { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserSTART { { p.SetState(7963) p.RangePartitionDesc() @@ -136297,10 +136297,10 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7964) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136322,7 +136322,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7973) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136333,7 +136333,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(7975) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136341,7 +136341,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7976) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136349,7 +136349,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7977) - p.Match(DorisSQLParserRANGE) + p.Match(StarRocksSQLParserRANGE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136361,7 +136361,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7979) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136374,7 +136374,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserSTART { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserSTART { { p.SetState(7980) p.RangePartitionDesc() @@ -136386,10 +136386,10 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(7981) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136411,7 +136411,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7990) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136422,7 +136422,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(7992) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136430,7 +136430,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7993) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136443,10 +136443,10 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIST { + if _la == StarRocksSQLParserLIST { { p.SetState(7994) - p.Match(DorisSQLParserLIST) + p.Match(StarRocksSQLParserLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136460,7 +136460,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(7998) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136473,7 +136473,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION { + if _la == StarRocksSQLParserPARTITION { { p.SetState(7999) p.ListPartitionDesc() @@ -136485,10 +136485,10 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8000) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136510,7 +136510,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8009) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136521,7 +136521,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(8011) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136529,7 +136529,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8012) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136542,10 +136542,10 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserLIST { + if _la == StarRocksSQLParserLIST { { p.SetState(8013) - p.Match(DorisSQLParserLIST) + p.Match(StarRocksSQLParserLIST) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136562,7 +136562,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 5) { p.SetState(8017) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136570,7 +136570,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8018) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136582,7 +136582,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8020) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136595,7 +136595,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPARTITION || _la == DorisSQLParserSTART { + if _la == StarRocksSQLParserPARTITION || _la == StarRocksSQLParserSTART { { p.SetState(8021) p.RangePartitionDesc() @@ -136607,10 +136607,10 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8022) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136632,7 +136632,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8031) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136643,7 +136643,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 6) { p.SetState(8033) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136651,7 +136651,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8034) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136666,7 +136666,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { p.EnterOuterAlt(localctx, 7) { p.SetState(8036) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136674,7 +136674,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { } { p.SetState(8037) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136697,7 +136697,7 @@ func (p *DorisSQLParser) PartitionDesc() (localctx IPartitionDescContext) { if _alt == 1 { { p.SetState(8039) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -136760,13 +136760,13 @@ type ListPartitionDescContext struct { func NewEmptyListPartitionDescContext() *ListPartitionDescContext { var p = new(ListPartitionDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_listPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_listPartitionDesc return p } func InitEmptyListPartitionDescContext(p *ListPartitionDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_listPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_listPartitionDesc } func (*ListPartitionDescContext) IsListPartitionDescContext() {} @@ -136777,7 +136777,7 @@ func NewListPartitionDescContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_listPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_listPartitionDesc return p } @@ -136825,20 +136825,20 @@ func (s *ListPartitionDescContext) ToStringTree(ruleNames []string, recog antlr. } func (s *ListPartitionDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterListPartitionDesc(s) } } func (s *ListPartitionDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitListPartitionDesc(s) } } func (s *ListPartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitListPartitionDesc(s) default: @@ -136846,9 +136846,9 @@ func (s *ListPartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) ListPartitionDesc() (localctx IListPartitionDescContext) { +func (p *StarRocksSQLParser) ListPartitionDesc() (localctx IListPartitionDescContext) { localctx = NewListPartitionDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 966, DorisSQLParserRULE_listPartitionDesc) + p.EnterRule(localctx, 966, StarRocksSQLParserRULE_listPartitionDesc) p.SetState(8050) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -136917,13 +136917,13 @@ type SingleItemListPartitionDescContext struct { func NewEmptySingleItemListPartitionDescContext() *SingleItemListPartitionDescContext { var p = new(SingleItemListPartitionDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleItemListPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_singleItemListPartitionDesc return p } func InitEmptySingleItemListPartitionDescContext(p *SingleItemListPartitionDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleItemListPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_singleItemListPartitionDesc } func (*SingleItemListPartitionDescContext) IsSingleItemListPartitionDescContext() {} @@ -136934,7 +136934,7 @@ func NewSingleItemListPartitionDescContext(parser antlr.Parser, parent antlr.Par antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_singleItemListPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_singleItemListPartitionDesc return p } @@ -136942,7 +136942,7 @@ func NewSingleItemListPartitionDescContext(parser antlr.Parser, parent antlr.Par func (s *SingleItemListPartitionDescContext) GetParser() antlr.Parser { return s.parser } func (s *SingleItemListPartitionDescContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *SingleItemListPartitionDescContext) Identifier() IIdentifierContext { @@ -136962,11 +136962,11 @@ func (s *SingleItemListPartitionDescContext) Identifier() IIdentifierContext { } func (s *SingleItemListPartitionDescContext) VALUES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUES, 0) + return s.GetToken(StarRocksSQLParserVALUES, 0) } func (s *SingleItemListPartitionDescContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *SingleItemListPartitionDescContext) SingleListPartitionValues() ISingleListPartitionValuesContext { @@ -136986,15 +136986,15 @@ func (s *SingleItemListPartitionDescContext) SingleListPartitionValues() ISingle } func (s *SingleItemListPartitionDescContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *SingleItemListPartitionDescContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *SingleItemListPartitionDescContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *SingleItemListPartitionDescContext) PropertyList() IPropertyListContext { @@ -137022,20 +137022,20 @@ func (s *SingleItemListPartitionDescContext) ToStringTree(ruleNames []string, re } func (s *SingleItemListPartitionDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSingleItemListPartitionDesc(s) } } func (s *SingleItemListPartitionDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSingleItemListPartitionDesc(s) } } func (s *SingleItemListPartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSingleItemListPartitionDesc(s) default: @@ -137043,15 +137043,15 @@ func (s *SingleItemListPartitionDescContext) Accept(visitor antlr.ParseTreeVisit } } -func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemListPartitionDescContext) { +func (p *StarRocksSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemListPartitionDescContext) { localctx = NewSingleItemListPartitionDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 968, DorisSQLParserRULE_singleItemListPartitionDesc) + p.EnterRule(localctx, 968, StarRocksSQLParserRULE_singleItemListPartitionDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8052) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137064,10 +137064,10 @@ func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemList } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(8053) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137075,7 +137075,7 @@ func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemList } { p.SetState(8054) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137083,7 +137083,7 @@ func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemList } { p.SetState(8055) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137097,7 +137097,7 @@ func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemList } { p.SetState(8059) - p.Match(DorisSQLParserVALUES) + p.Match(StarRocksSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137105,7 +137105,7 @@ func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemList } { p.SetState(8060) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137122,7 +137122,7 @@ func (p *DorisSQLParser) SingleItemListPartitionDesc() (localctx ISingleItemList } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8062) p.PropertyList() @@ -137173,13 +137173,13 @@ type MultiItemListPartitionDescContext struct { func NewEmptyMultiItemListPartitionDescContext() *MultiItemListPartitionDescContext { var p = new(MultiItemListPartitionDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_multiItemListPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_multiItemListPartitionDesc return p } func InitEmptyMultiItemListPartitionDescContext(p *MultiItemListPartitionDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_multiItemListPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_multiItemListPartitionDesc } func (*MultiItemListPartitionDescContext) IsMultiItemListPartitionDescContext() {} @@ -137190,7 +137190,7 @@ func NewMultiItemListPartitionDescContext(parser antlr.Parser, parent antlr.Pars antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_multiItemListPartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_multiItemListPartitionDesc return p } @@ -137198,7 +137198,7 @@ func NewMultiItemListPartitionDescContext(parser antlr.Parser, parent antlr.Pars func (s *MultiItemListPartitionDescContext) GetParser() antlr.Parser { return s.parser } func (s *MultiItemListPartitionDescContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *MultiItemListPartitionDescContext) Identifier() IIdentifierContext { @@ -137218,11 +137218,11 @@ func (s *MultiItemListPartitionDescContext) Identifier() IIdentifierContext { } func (s *MultiItemListPartitionDescContext) VALUES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUES, 0) + return s.GetToken(StarRocksSQLParserVALUES, 0) } func (s *MultiItemListPartitionDescContext) IN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIN, 0) + return s.GetToken(StarRocksSQLParserIN, 0) } func (s *MultiItemListPartitionDescContext) MultiListPartitionValues() IMultiListPartitionValuesContext { @@ -137242,15 +137242,15 @@ func (s *MultiItemListPartitionDescContext) MultiListPartitionValues() IMultiLis } func (s *MultiItemListPartitionDescContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *MultiItemListPartitionDescContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *MultiItemListPartitionDescContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *MultiItemListPartitionDescContext) PropertyList() IPropertyListContext { @@ -137278,20 +137278,20 @@ func (s *MultiItemListPartitionDescContext) ToStringTree(ruleNames []string, rec } func (s *MultiItemListPartitionDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMultiItemListPartitionDesc(s) } } func (s *MultiItemListPartitionDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMultiItemListPartitionDesc(s) } } func (s *MultiItemListPartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMultiItemListPartitionDesc(s) default: @@ -137299,15 +137299,15 @@ func (s *MultiItemListPartitionDescContext) Accept(visitor antlr.ParseTreeVisito } } -func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPartitionDescContext) { +func (p *StarRocksSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPartitionDescContext) { localctx = NewMultiItemListPartitionDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 970, DorisSQLParserRULE_multiItemListPartitionDesc) + p.EnterRule(localctx, 970, StarRocksSQLParserRULE_multiItemListPartitionDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8065) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137320,10 +137320,10 @@ func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(8066) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137331,7 +137331,7 @@ func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPa } { p.SetState(8067) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137339,7 +137339,7 @@ func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPa } { p.SetState(8068) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137353,7 +137353,7 @@ func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPa } { p.SetState(8072) - p.Match(DorisSQLParserVALUES) + p.Match(StarRocksSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137361,7 +137361,7 @@ func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPa } { p.SetState(8073) - p.Match(DorisSQLParserIN) + p.Match(StarRocksSQLParserIN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137378,7 +137378,7 @@ func (p *DorisSQLParser) MultiItemListPartitionDesc() (localctx IMultiItemListPa } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8075) p.PropertyList() @@ -137422,13 +137422,13 @@ type MultiListPartitionValuesContext struct { func NewEmptyMultiListPartitionValuesContext() *MultiListPartitionValuesContext { var p = new(MultiListPartitionValuesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_multiListPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_multiListPartitionValues return p } func InitEmptyMultiListPartitionValuesContext(p *MultiListPartitionValuesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_multiListPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_multiListPartitionValues } func (*MultiListPartitionValuesContext) IsMultiListPartitionValuesContext() {} @@ -137439,7 +137439,7 @@ func NewMultiListPartitionValuesContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_multiListPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_multiListPartitionValues return p } @@ -137496,20 +137496,20 @@ func (s *MultiListPartitionValuesContext) ToStringTree(ruleNames []string, recog } func (s *MultiListPartitionValuesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMultiListPartitionValues(s) } } func (s *MultiListPartitionValuesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMultiListPartitionValues(s) } } func (s *MultiListPartitionValuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMultiListPartitionValues(s) default: @@ -137517,15 +137517,15 @@ func (s *MultiListPartitionValuesContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) MultiListPartitionValues() (localctx IMultiListPartitionValuesContext) { +func (p *StarRocksSQLParser) MultiListPartitionValues() (localctx IMultiListPartitionValuesContext) { localctx = NewMultiListPartitionValuesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 972, DorisSQLParserRULE_multiListPartitionValues) + p.EnterRule(localctx, 972, StarRocksSQLParserRULE_multiListPartitionValues) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8078) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137542,10 +137542,10 @@ func (p *DorisSQLParser) MultiListPartitionValues() (localctx IMultiListPartitio } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8080) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137565,7 +137565,7 @@ func (p *DorisSQLParser) MultiListPartitionValues() (localctx IMultiListPartitio } { p.SetState(8087) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137608,13 +137608,13 @@ type SingleListPartitionValuesContext struct { func NewEmptySingleListPartitionValuesContext() *SingleListPartitionValuesContext { var p = new(SingleListPartitionValuesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleListPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_singleListPartitionValues return p } func InitEmptySingleListPartitionValuesContext(p *SingleListPartitionValuesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleListPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_singleListPartitionValues } func (*SingleListPartitionValuesContext) IsSingleListPartitionValuesContext() {} @@ -137625,7 +137625,7 @@ func NewSingleListPartitionValuesContext(parser antlr.Parser, parent antlr.Parse antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_singleListPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_singleListPartitionValues return p } @@ -137682,20 +137682,20 @@ func (s *SingleListPartitionValuesContext) ToStringTree(ruleNames []string, reco } func (s *SingleListPartitionValuesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSingleListPartitionValues(s) } } func (s *SingleListPartitionValuesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSingleListPartitionValues(s) } } func (s *SingleListPartitionValuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSingleListPartitionValues(s) default: @@ -137703,15 +137703,15 @@ func (s *SingleListPartitionValuesContext) Accept(visitor antlr.ParseTreeVisitor } } -func (p *DorisSQLParser) SingleListPartitionValues() (localctx ISingleListPartitionValuesContext) { +func (p *StarRocksSQLParser) SingleListPartitionValues() (localctx ISingleListPartitionValuesContext) { localctx = NewSingleListPartitionValuesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 974, DorisSQLParserRULE_singleListPartitionValues) + p.EnterRule(localctx, 974, StarRocksSQLParserRULE_singleListPartitionValues) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8089) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137728,10 +137728,10 @@ func (p *DorisSQLParser) SingleListPartitionValues() (localctx ISingleListPartit } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8091) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137751,7 +137751,7 @@ func (p *DorisSQLParser) SingleListPartitionValues() (localctx ISingleListPartit } { p.SetState(8098) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -137794,13 +137794,13 @@ type ListPartitionValuesContext struct { func NewEmptyListPartitionValuesContext() *ListPartitionValuesContext { var p = new(ListPartitionValuesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_listPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_listPartitionValues return p } func InitEmptyListPartitionValuesContext(p *ListPartitionValuesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_listPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_listPartitionValues } func (*ListPartitionValuesContext) IsListPartitionValuesContext() {} @@ -137811,7 +137811,7 @@ func NewListPartitionValuesContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_listPartitionValues + p.RuleIndex = StarRocksSQLParserRULE_listPartitionValues return p } @@ -137859,20 +137859,20 @@ func (s *ListPartitionValuesContext) ToStringTree(ruleNames []string, recog antl } func (s *ListPartitionValuesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterListPartitionValues(s) } } func (s *ListPartitionValuesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitListPartitionValues(s) } } func (s *ListPartitionValuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitListPartitionValues(s) default: @@ -137880,9 +137880,9 @@ func (s *ListPartitionValuesContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) ListPartitionValues() (localctx IListPartitionValuesContext) { +func (p *StarRocksSQLParser) ListPartitionValues() (localctx IListPartitionValuesContext) { localctx = NewListPartitionValuesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 976, DorisSQLParserRULE_listPartitionValues) + p.EnterRule(localctx, 976, StarRocksSQLParserRULE_listPartitionValues) p.SetState(8102) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -137944,13 +137944,13 @@ type ListPartitionValueContext struct { func NewEmptyListPartitionValueContext() *ListPartitionValueContext { var p = new(ListPartitionValueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_listPartitionValue + p.RuleIndex = StarRocksSQLParserRULE_listPartitionValue return p } func InitEmptyListPartitionValueContext(p *ListPartitionValueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_listPartitionValue + p.RuleIndex = StarRocksSQLParserRULE_listPartitionValue } func (*ListPartitionValueContext) IsListPartitionValueContext() {} @@ -137961,7 +137961,7 @@ func NewListPartitionValueContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_listPartitionValue + p.RuleIndex = StarRocksSQLParserRULE_listPartitionValue return p } @@ -137969,7 +137969,7 @@ func NewListPartitionValueContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *ListPartitionValueContext) GetParser() antlr.Parser { return s.parser } func (s *ListPartitionValueContext) NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULL, 0) + return s.GetToken(StarRocksSQLParserNULL, 0) } func (s *ListPartitionValueContext) String_() IStringContext { @@ -137997,20 +137997,20 @@ func (s *ListPartitionValueContext) ToStringTree(ruleNames []string, recog antlr } func (s *ListPartitionValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterListPartitionValue(s) } } func (s *ListPartitionValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitListPartitionValue(s) } } func (s *ListPartitionValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitListPartitionValue(s) default: @@ -138018,9 +138018,9 @@ func (s *ListPartitionValueContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ListPartitionValue() (localctx IListPartitionValueContext) { +func (p *StarRocksSQLParser) ListPartitionValue() (localctx IListPartitionValueContext) { localctx = NewListPartitionValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 978, DorisSQLParserRULE_listPartitionValue) + p.EnterRule(localctx, 978, StarRocksSQLParserRULE_listPartitionValue) p.SetState(8106) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -138028,18 +138028,18 @@ func (p *DorisSQLParser) ListPartitionValue() (localctx IListPartitionValueConte } switch p.GetTokenStream().LA(1) { - case DorisSQLParserNULL: + case StarRocksSQLParserNULL: p.EnterOuterAlt(localctx, 1) { p.SetState(8104) - p.Match(DorisSQLParserNULL) + p.Match(StarRocksSQLParserNULL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: p.EnterOuterAlt(localctx, 2) { p.SetState(8105) @@ -138087,13 +138087,13 @@ type StringListContext struct { func NewEmptyStringListContext() *StringListContext { var p = new(StringListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_stringList + p.RuleIndex = StarRocksSQLParserRULE_stringList return p } func InitEmptyStringListContext(p *StringListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_stringList + p.RuleIndex = StarRocksSQLParserRULE_stringList } func (*StringListContext) IsStringListContext() {} @@ -138104,7 +138104,7 @@ func NewStringListContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_stringList + p.RuleIndex = StarRocksSQLParserRULE_stringList return p } @@ -138161,20 +138161,20 @@ func (s *StringListContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *StringListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterStringList(s) } } func (s *StringListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitStringList(s) } } func (s *StringListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitStringList(s) default: @@ -138182,15 +138182,15 @@ func (s *StringListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) StringList() (localctx IStringListContext) { +func (p *StarRocksSQLParser) StringList() (localctx IStringListContext) { localctx = NewStringListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 980, DorisSQLParserRULE_stringList) + p.EnterRule(localctx, 980, StarRocksSQLParserRULE_stringList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8108) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138207,10 +138207,10 @@ func (p *DorisSQLParser) StringList() (localctx IStringListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8110) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138230,7 +138230,7 @@ func (p *DorisSQLParser) StringList() (localctx IStringListContext) { } { p.SetState(8117) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138273,13 +138273,13 @@ type LiteralExpressionListContext struct { func NewEmptyLiteralExpressionListContext() *LiteralExpressionListContext { var p = new(LiteralExpressionListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_literalExpressionList + p.RuleIndex = StarRocksSQLParserRULE_literalExpressionList return p } func InitEmptyLiteralExpressionListContext(p *LiteralExpressionListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_literalExpressionList + p.RuleIndex = StarRocksSQLParserRULE_literalExpressionList } func (*LiteralExpressionListContext) IsLiteralExpressionListContext() {} @@ -138290,7 +138290,7 @@ func NewLiteralExpressionListContext(parser antlr.Parser, parent antlr.ParserRul antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_literalExpressionList + p.RuleIndex = StarRocksSQLParserRULE_literalExpressionList return p } @@ -138347,20 +138347,20 @@ func (s *LiteralExpressionListContext) ToStringTree(ruleNames []string, recog an } func (s *LiteralExpressionListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterLiteralExpressionList(s) } } func (s *LiteralExpressionListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitLiteralExpressionList(s) } } func (s *LiteralExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitLiteralExpressionList(s) default: @@ -138368,15 +138368,15 @@ func (s *LiteralExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) in } } -func (p *DorisSQLParser) LiteralExpressionList() (localctx ILiteralExpressionListContext) { +func (p *StarRocksSQLParser) LiteralExpressionList() (localctx ILiteralExpressionListContext) { localctx = NewLiteralExpressionListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 982, DorisSQLParserRULE_literalExpressionList) + p.EnterRule(localctx, 982, StarRocksSQLParserRULE_literalExpressionList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8119) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138393,10 +138393,10 @@ func (p *DorisSQLParser) LiteralExpressionList() (localctx ILiteralExpressionLis } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8121) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138416,7 +138416,7 @@ func (p *DorisSQLParser) LiteralExpressionList() (localctx ILiteralExpressionLis } { p.SetState(8128) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138459,13 +138459,13 @@ type RangePartitionDescContext struct { func NewEmptyRangePartitionDescContext() *RangePartitionDescContext { var p = new(RangePartitionDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rangePartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_rangePartitionDesc return p } func InitEmptyRangePartitionDescContext(p *RangePartitionDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_rangePartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_rangePartitionDesc } func (*RangePartitionDescContext) IsRangePartitionDescContext() {} @@ -138476,7 +138476,7 @@ func NewRangePartitionDescContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_rangePartitionDesc + p.RuleIndex = StarRocksSQLParserRULE_rangePartitionDesc return p } @@ -138524,20 +138524,20 @@ func (s *RangePartitionDescContext) ToStringTree(ruleNames []string, recog antlr } func (s *RangePartitionDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRangePartitionDesc(s) } } func (s *RangePartitionDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRangePartitionDesc(s) } } func (s *RangePartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRangePartitionDesc(s) default: @@ -138545,9 +138545,9 @@ func (s *RangePartitionDescContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) RangePartitionDesc() (localctx IRangePartitionDescContext) { +func (p *StarRocksSQLParser) RangePartitionDesc() (localctx IRangePartitionDescContext) { localctx = NewRangePartitionDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 984, DorisSQLParserRULE_rangePartitionDesc) + p.EnterRule(localctx, 984, StarRocksSQLParserRULE_rangePartitionDesc) p.SetState(8132) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -138555,14 +138555,14 @@ func (p *DorisSQLParser) RangePartitionDesc() (localctx IRangePartitionDescConte } switch p.GetTokenStream().LA(1) { - case DorisSQLParserPARTITION: + case StarRocksSQLParserPARTITION: p.EnterOuterAlt(localctx, 1) { p.SetState(8130) p.SingleRangePartition() } - case DorisSQLParserSTART: + case StarRocksSQLParserSTART: p.EnterOuterAlt(localctx, 2) { p.SetState(8131) @@ -138616,13 +138616,13 @@ type SingleRangePartitionContext struct { func NewEmptySingleRangePartitionContext() *SingleRangePartitionContext { var p = new(SingleRangePartitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleRangePartition + p.RuleIndex = StarRocksSQLParserRULE_singleRangePartition return p } func InitEmptySingleRangePartitionContext(p *SingleRangePartitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_singleRangePartition + p.RuleIndex = StarRocksSQLParserRULE_singleRangePartition } func (*SingleRangePartitionContext) IsSingleRangePartitionContext() {} @@ -138633,7 +138633,7 @@ func NewSingleRangePartitionContext(parser antlr.Parser, parent antlr.ParserRule antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_singleRangePartition + p.RuleIndex = StarRocksSQLParserRULE_singleRangePartition return p } @@ -138641,7 +138641,7 @@ func NewSingleRangePartitionContext(parser antlr.Parser, parent antlr.ParserRule func (s *SingleRangePartitionContext) GetParser() antlr.Parser { return s.parser } func (s *SingleRangePartitionContext) PARTITION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITION, 0) + return s.GetToken(StarRocksSQLParserPARTITION, 0) } func (s *SingleRangePartitionContext) Identifier() IIdentifierContext { @@ -138661,7 +138661,7 @@ func (s *SingleRangePartitionContext) Identifier() IIdentifierContext { } func (s *SingleRangePartitionContext) VALUES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUES, 0) + return s.GetToken(StarRocksSQLParserVALUES, 0) } func (s *SingleRangePartitionContext) PartitionKeyDesc() IPartitionKeyDescContext { @@ -138681,15 +138681,15 @@ func (s *SingleRangePartitionContext) PartitionKeyDesc() IPartitionKeyDescContex } func (s *SingleRangePartitionContext) IF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIF, 0) + return s.GetToken(StarRocksSQLParserIF, 0) } func (s *SingleRangePartitionContext) NOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNOT, 0) + return s.GetToken(StarRocksSQLParserNOT, 0) } func (s *SingleRangePartitionContext) EXISTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXISTS, 0) + return s.GetToken(StarRocksSQLParserEXISTS, 0) } func (s *SingleRangePartitionContext) PropertyList() IPropertyListContext { @@ -138717,20 +138717,20 @@ func (s *SingleRangePartitionContext) ToStringTree(ruleNames []string, recog ant } func (s *SingleRangePartitionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSingleRangePartition(s) } } func (s *SingleRangePartitionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSingleRangePartition(s) } } func (s *SingleRangePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSingleRangePartition(s) default: @@ -138738,15 +138738,15 @@ func (s *SingleRangePartitionContext) Accept(visitor antlr.ParseTreeVisitor) int } } -func (p *DorisSQLParser) SingleRangePartition() (localctx ISingleRangePartitionContext) { +func (p *StarRocksSQLParser) SingleRangePartition() (localctx ISingleRangePartitionContext) { localctx = NewSingleRangePartitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 986, DorisSQLParserRULE_singleRangePartition) + p.EnterRule(localctx, 986, StarRocksSQLParserRULE_singleRangePartition) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8134) - p.Match(DorisSQLParserPARTITION) + p.Match(StarRocksSQLParserPARTITION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138759,10 +138759,10 @@ func (p *DorisSQLParser) SingleRangePartition() (localctx ISingleRangePartitionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserIF { + if _la == StarRocksSQLParserIF { { p.SetState(8135) - p.Match(DorisSQLParserIF) + p.Match(StarRocksSQLParserIF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138770,7 +138770,7 @@ func (p *DorisSQLParser) SingleRangePartition() (localctx ISingleRangePartitionC } { p.SetState(8136) - p.Match(DorisSQLParserNOT) + p.Match(StarRocksSQLParserNOT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138778,7 +138778,7 @@ func (p *DorisSQLParser) SingleRangePartition() (localctx ISingleRangePartitionC } { p.SetState(8137) - p.Match(DorisSQLParserEXISTS) + p.Match(StarRocksSQLParserEXISTS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138792,7 +138792,7 @@ func (p *DorisSQLParser) SingleRangePartition() (localctx ISingleRangePartitionC } { p.SetState(8141) - p.Match(DorisSQLParserVALUES) + p.Match(StarRocksSQLParserVALUES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -138809,7 +138809,7 @@ func (p *DorisSQLParser) SingleRangePartition() (localctx ISingleRangePartitionC } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8143) p.PropertyList() @@ -138858,13 +138858,13 @@ type MultiRangePartitionContext struct { func NewEmptyMultiRangePartitionContext() *MultiRangePartitionContext { var p = new(MultiRangePartitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_multiRangePartition + p.RuleIndex = StarRocksSQLParserRULE_multiRangePartition return p } func InitEmptyMultiRangePartitionContext(p *MultiRangePartitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_multiRangePartition + p.RuleIndex = StarRocksSQLParserRULE_multiRangePartition } func (*MultiRangePartitionContext) IsMultiRangePartitionContext() {} @@ -138875,7 +138875,7 @@ func NewMultiRangePartitionContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_multiRangePartition + p.RuleIndex = StarRocksSQLParserRULE_multiRangePartition return p } @@ -138883,7 +138883,7 @@ func NewMultiRangePartitionContext(parser antlr.Parser, parent antlr.ParserRuleC func (s *MultiRangePartitionContext) GetParser() antlr.Parser { return s.parser } func (s *MultiRangePartitionContext) START() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTART, 0) + return s.GetToken(StarRocksSQLParserSTART, 0) } func (s *MultiRangePartitionContext) AllString_() []IStringContext { @@ -138928,11 +138928,11 @@ func (s *MultiRangePartitionContext) String_(i int) IStringContext { } func (s *MultiRangePartitionContext) END() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEND, 0) + return s.GetToken(StarRocksSQLParserEND, 0) } func (s *MultiRangePartitionContext) EVERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEVERY, 0) + return s.GetToken(StarRocksSQLParserEVERY, 0) } func (s *MultiRangePartitionContext) Interval() IIntervalContext { @@ -138952,7 +138952,7 @@ func (s *MultiRangePartitionContext) Interval() IIntervalContext { } func (s *MultiRangePartitionContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *MultiRangePartitionContext) GetRuleContext() antlr.RuleContext { @@ -138964,20 +138964,20 @@ func (s *MultiRangePartitionContext) ToStringTree(ruleNames []string, recog antl } func (s *MultiRangePartitionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMultiRangePartition(s) } } func (s *MultiRangePartitionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMultiRangePartition(s) } } func (s *MultiRangePartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMultiRangePartition(s) default: @@ -138985,9 +138985,9 @@ func (s *MultiRangePartitionContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionContext) { +func (p *StarRocksSQLParser) MultiRangePartition() (localctx IMultiRangePartitionContext) { localctx = NewMultiRangePartitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 988, DorisSQLParserRULE_multiRangePartition) + p.EnterRule(localctx, 988, StarRocksSQLParserRULE_multiRangePartition) p.SetState(8172) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -138999,7 +138999,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon p.EnterOuterAlt(localctx, 1) { p.SetState(8146) - p.Match(DorisSQLParserSTART) + p.Match(StarRocksSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139007,7 +139007,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8147) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139019,7 +139019,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8149) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139027,7 +139027,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8150) - p.Match(DorisSQLParserEND) + p.Match(StarRocksSQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139035,7 +139035,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8151) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139047,7 +139047,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8153) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139055,7 +139055,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8154) - p.Match(DorisSQLParserEVERY) + p.Match(StarRocksSQLParserEVERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139063,7 +139063,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8155) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139075,7 +139075,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8157) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139086,7 +139086,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon p.EnterOuterAlt(localctx, 2) { p.SetState(8159) - p.Match(DorisSQLParserSTART) + p.Match(StarRocksSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139094,7 +139094,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8160) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139106,7 +139106,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8162) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139114,7 +139114,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8163) - p.Match(DorisSQLParserEND) + p.Match(StarRocksSQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139122,7 +139122,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8164) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139134,7 +139134,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8166) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139142,7 +139142,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8167) - p.Match(DorisSQLParserEVERY) + p.Match(StarRocksSQLParserEVERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139150,7 +139150,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8168) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139158,7 +139158,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8169) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139166,7 +139166,7 @@ func (p *DorisSQLParser) MultiRangePartition() (localctx IMultiRangePartitionCon } { p.SetState(8170) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139215,13 +139215,13 @@ type PartitionRangeDescContext struct { func NewEmptyPartitionRangeDescContext() *PartitionRangeDescContext { var p = new(PartitionRangeDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionRangeDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionRangeDesc return p } func InitEmptyPartitionRangeDescContext(p *PartitionRangeDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionRangeDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionRangeDesc } func (*PartitionRangeDescContext) IsPartitionRangeDescContext() {} @@ -139232,7 +139232,7 @@ func NewPartitionRangeDescContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionRangeDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionRangeDesc return p } @@ -139240,7 +139240,7 @@ func NewPartitionRangeDescContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *PartitionRangeDescContext) GetParser() antlr.Parser { return s.parser } func (s *PartitionRangeDescContext) START() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTART, 0) + return s.GetToken(StarRocksSQLParserSTART, 0) } func (s *PartitionRangeDescContext) AllString_() []IStringContext { @@ -139285,7 +139285,7 @@ func (s *PartitionRangeDescContext) String_(i int) IStringContext { } func (s *PartitionRangeDescContext) END() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEND, 0) + return s.GetToken(StarRocksSQLParserEND, 0) } func (s *PartitionRangeDescContext) GetRuleContext() antlr.RuleContext { @@ -139297,20 +139297,20 @@ func (s *PartitionRangeDescContext) ToStringTree(ruleNames []string, recog antlr } func (s *PartitionRangeDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionRangeDesc(s) } } func (s *PartitionRangeDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionRangeDesc(s) } } func (s *PartitionRangeDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionRangeDesc(s) default: @@ -139318,13 +139318,13 @@ func (s *PartitionRangeDescContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescContext) { +func (p *StarRocksSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescContext) { localctx = NewPartitionRangeDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 990, DorisSQLParserRULE_partitionRangeDesc) + p.EnterRule(localctx, 990, StarRocksSQLParserRULE_partitionRangeDesc) p.EnterOuterAlt(localctx, 1) { p.SetState(8174) - p.Match(DorisSQLParserSTART) + p.Match(StarRocksSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139332,7 +139332,7 @@ func (p *DorisSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescConte } { p.SetState(8175) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139344,7 +139344,7 @@ func (p *DorisSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescConte } { p.SetState(8177) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139352,7 +139352,7 @@ func (p *DorisSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescConte } { p.SetState(8178) - p.Match(DorisSQLParserEND) + p.Match(StarRocksSQLParserEND) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139360,7 +139360,7 @@ func (p *DorisSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescConte } { p.SetState(8179) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139372,7 +139372,7 @@ func (p *DorisSQLParser) PartitionRangeDesc() (localctx IPartitionRangeDescConte } { p.SetState(8181) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139418,13 +139418,13 @@ type PartitionKeyDescContext struct { func NewEmptyPartitionKeyDescContext() *PartitionKeyDescContext { var p = new(PartitionKeyDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionKeyDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionKeyDesc return p } func InitEmptyPartitionKeyDescContext(p *PartitionKeyDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionKeyDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionKeyDesc } func (*PartitionKeyDescContext) IsPartitionKeyDescContext() {} @@ -139435,7 +139435,7 @@ func NewPartitionKeyDescContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionKeyDesc + p.RuleIndex = StarRocksSQLParserRULE_partitionKeyDesc return p } @@ -139443,15 +139443,15 @@ func NewPartitionKeyDescContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *PartitionKeyDescContext) GetParser() antlr.Parser { return s.parser } func (s *PartitionKeyDescContext) LESS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLESS, 0) + return s.GetToken(StarRocksSQLParserLESS, 0) } func (s *PartitionKeyDescContext) THAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTHAN, 0) + return s.GetToken(StarRocksSQLParserTHAN, 0) } func (s *PartitionKeyDescContext) MAXVALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAXVALUE, 0) + return s.GetToken(StarRocksSQLParserMAXVALUE, 0) } func (s *PartitionKeyDescContext) AllPartitionValueList() []IPartitionValueListContext { @@ -139504,20 +139504,20 @@ func (s *PartitionKeyDescContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *PartitionKeyDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionKeyDesc(s) } } func (s *PartitionKeyDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionKeyDesc(s) } } func (s *PartitionKeyDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionKeyDesc(s) default: @@ -139525,9 +139525,9 @@ func (s *PartitionKeyDescContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) { +func (p *StarRocksSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) { localctx = NewPartitionKeyDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 992, DorisSQLParserRULE_partitionKeyDesc) + p.EnterRule(localctx, 992, StarRocksSQLParserRULE_partitionKeyDesc) p.SetState(8195) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -139535,11 +139535,11 @@ func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLESS: + case StarRocksSQLParserLESS: p.EnterOuterAlt(localctx, 1) { p.SetState(8183) - p.Match(DorisSQLParserLESS) + p.Match(StarRocksSQLParserLESS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139547,7 +139547,7 @@ func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) } { p.SetState(8184) - p.Match(DorisSQLParserTHAN) + p.Match(StarRocksSQLParserTHAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139560,17 +139560,17 @@ func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) } switch p.GetTokenStream().LA(1) { - case DorisSQLParserMAXVALUE: + case StarRocksSQLParserMAXVALUE: { p.SetState(8185) - p.Match(DorisSQLParserMAXVALUE) + p.Match(StarRocksSQLParserMAXVALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserT__1: + case StarRocksSQLParserT__1: { p.SetState(8186) p.PartitionValueList() @@ -139581,11 +139581,11 @@ func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) goto errorExit } - case DorisSQLParserT__5: + case StarRocksSQLParserT__5: p.EnterOuterAlt(localctx, 2) { p.SetState(8189) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139597,7 +139597,7 @@ func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) } { p.SetState(8191) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139609,7 +139609,7 @@ func (p *DorisSQLParser) PartitionKeyDesc() (localctx IPartitionKeyDescContext) } { p.SetState(8193) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139657,13 +139657,13 @@ type PartitionValueListContext struct { func NewEmptyPartitionValueListContext() *PartitionValueListContext { var p = new(PartitionValueListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionValueList + p.RuleIndex = StarRocksSQLParserRULE_partitionValueList return p } func InitEmptyPartitionValueListContext(p *PartitionValueListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionValueList + p.RuleIndex = StarRocksSQLParserRULE_partitionValueList } func (*PartitionValueListContext) IsPartitionValueListContext() {} @@ -139674,7 +139674,7 @@ func NewPartitionValueListContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionValueList + p.RuleIndex = StarRocksSQLParserRULE_partitionValueList return p } @@ -139731,20 +139731,20 @@ func (s *PartitionValueListContext) ToStringTree(ruleNames []string, recog antlr } func (s *PartitionValueListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionValueList(s) } } func (s *PartitionValueListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionValueList(s) } } func (s *PartitionValueListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionValueList(s) default: @@ -139752,15 +139752,15 @@ func (s *PartitionValueListContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) PartitionValueList() (localctx IPartitionValueListContext) { +func (p *StarRocksSQLParser) PartitionValueList() (localctx IPartitionValueListContext) { localctx = NewPartitionValueListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 994, DorisSQLParserRULE_partitionValueList) + p.EnterRule(localctx, 994, StarRocksSQLParserRULE_partitionValueList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8197) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139777,10 +139777,10 @@ func (p *DorisSQLParser) PartitionValueList() (localctx IPartitionValueListConte } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8199) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139800,7 +139800,7 @@ func (p *DorisSQLParser) PartitionValueList() (localctx IPartitionValueListConte } { p.SetState(8206) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -139858,13 +139858,13 @@ type KeyPartitionContext struct { func NewEmptyKeyPartitionContext() *KeyPartitionContext { var p = new(KeyPartitionContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_keyPartition + p.RuleIndex = StarRocksSQLParserRULE_keyPartition return p } func InitEmptyKeyPartitionContext(p *KeyPartitionContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_keyPartition + p.RuleIndex = StarRocksSQLParserRULE_keyPartition } func (*KeyPartitionContext) IsKeyPartitionContext() {} @@ -139875,7 +139875,7 @@ func NewKeyPartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_keyPartition + p.RuleIndex = StarRocksSQLParserRULE_keyPartition return p } @@ -139895,7 +139895,7 @@ func (s *KeyPartitionContext) SetPartitionColValue(v ILiteralExpressionContext) } func (s *KeyPartitionContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *KeyPartitionContext) Identifier() IIdentifierContext { @@ -139939,20 +139939,20 @@ func (s *KeyPartitionContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *KeyPartitionContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterKeyPartition(s) } } func (s *KeyPartitionContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitKeyPartition(s) } } func (s *KeyPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitKeyPartition(s) default: @@ -139960,9 +139960,9 @@ func (s *KeyPartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) KeyPartition() (localctx IKeyPartitionContext) { +func (p *StarRocksSQLParser) KeyPartition() (localctx IKeyPartitionContext) { localctx = NewKeyPartitionContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 996, DorisSQLParserRULE_keyPartition) + p.EnterRule(localctx, 996, StarRocksSQLParserRULE_keyPartition) p.EnterOuterAlt(localctx, 1) { p.SetState(8208) @@ -139973,7 +139973,7 @@ func (p *DorisSQLParser) KeyPartition() (localctx IKeyPartitionContext) { } { p.SetState(8209) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140023,13 +140023,13 @@ type PartitionValueContext struct { func NewEmptyPartitionValueContext() *PartitionValueContext { var p = new(PartitionValueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionValue + p.RuleIndex = StarRocksSQLParserRULE_partitionValue return p } func InitEmptyPartitionValueContext(p *PartitionValueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_partitionValue + p.RuleIndex = StarRocksSQLParserRULE_partitionValue } func (*PartitionValueContext) IsPartitionValueContext() {} @@ -140040,7 +140040,7 @@ func NewPartitionValueContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_partitionValue + p.RuleIndex = StarRocksSQLParserRULE_partitionValue return p } @@ -140048,7 +140048,7 @@ func NewPartitionValueContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *PartitionValueContext) GetParser() antlr.Parser { return s.parser } func (s *PartitionValueContext) MAXVALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAXVALUE, 0) + return s.GetToken(StarRocksSQLParserMAXVALUE, 0) } func (s *PartitionValueContext) String_() IStringContext { @@ -140076,20 +140076,20 @@ func (s *PartitionValueContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *PartitionValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPartitionValue(s) } } func (s *PartitionValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPartitionValue(s) } } func (s *PartitionValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPartitionValue(s) default: @@ -140097,9 +140097,9 @@ func (s *PartitionValueContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) PartitionValue() (localctx IPartitionValueContext) { +func (p *StarRocksSQLParser) PartitionValue() (localctx IPartitionValueContext) { localctx = NewPartitionValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 998, DorisSQLParserRULE_partitionValue) + p.EnterRule(localctx, 998, StarRocksSQLParserRULE_partitionValue) p.SetState(8214) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -140107,18 +140107,18 @@ func (p *DorisSQLParser) PartitionValue() (localctx IPartitionValueContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserMAXVALUE: + case StarRocksSQLParserMAXVALUE: p.EnterOuterAlt(localctx, 1) { p.SetState(8212) - p.Match(DorisSQLParserMAXVALUE) + p.Match(StarRocksSQLParserMAXVALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: p.EnterOuterAlt(localctx, 2) { p.SetState(8213) @@ -140170,13 +140170,13 @@ type DistributionClauseContext struct { func NewEmptyDistributionClauseContext() *DistributionClauseContext { var p = new(DistributionClauseContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_distributionClause + p.RuleIndex = StarRocksSQLParserRULE_distributionClause return p } func InitEmptyDistributionClauseContext(p *DistributionClauseContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_distributionClause + p.RuleIndex = StarRocksSQLParserRULE_distributionClause } func (*DistributionClauseContext) IsDistributionClauseContext() {} @@ -140187,7 +140187,7 @@ func NewDistributionClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_distributionClause + p.RuleIndex = StarRocksSQLParserRULE_distributionClause return p } @@ -140195,15 +140195,15 @@ func NewDistributionClauseContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *DistributionClauseContext) GetParser() antlr.Parser { return s.parser } func (s *DistributionClauseContext) DISTRIBUTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTRIBUTED, 0) + return s.GetToken(StarRocksSQLParserDISTRIBUTED, 0) } func (s *DistributionClauseContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *DistributionClauseContext) HASH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHASH, 0) + return s.GetToken(StarRocksSQLParserHASH, 0) } func (s *DistributionClauseContext) IdentifierList() IIdentifierListContext { @@ -140223,11 +140223,11 @@ func (s *DistributionClauseContext) IdentifierList() IIdentifierListContext { } func (s *DistributionClauseContext) BUCKETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBUCKETS, 0) + return s.GetToken(StarRocksSQLParserBUCKETS, 0) } func (s *DistributionClauseContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *DistributionClauseContext) GetRuleContext() antlr.RuleContext { @@ -140239,20 +140239,20 @@ func (s *DistributionClauseContext) ToStringTree(ruleNames []string, recog antlr } func (s *DistributionClauseContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDistributionClause(s) } } func (s *DistributionClauseContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDistributionClause(s) } } func (s *DistributionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDistributionClause(s) default: @@ -140260,9 +140260,9 @@ func (s *DistributionClauseContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseContext) { +func (p *StarRocksSQLParser) DistributionClause() (localctx IDistributionClauseContext) { localctx = NewDistributionClauseContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1000, DorisSQLParserRULE_distributionClause) + p.EnterRule(localctx, 1000, StarRocksSQLParserRULE_distributionClause) var _la int p.SetState(8228) @@ -140276,7 +140276,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte p.EnterOuterAlt(localctx, 1) { p.SetState(8216) - p.Match(DorisSQLParserDISTRIBUTED) + p.Match(StarRocksSQLParserDISTRIBUTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140284,7 +140284,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte } { p.SetState(8217) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140292,7 +140292,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte } { p.SetState(8218) - p.Match(DorisSQLParserHASH) + p.Match(StarRocksSQLParserHASH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140309,10 +140309,10 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBUCKETS { + if _la == StarRocksSQLParserBUCKETS { { p.SetState(8220) - p.Match(DorisSQLParserBUCKETS) + p.Match(StarRocksSQLParserBUCKETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140320,7 +140320,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte } { p.SetState(8221) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140333,7 +140333,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte p.EnterOuterAlt(localctx, 2) { p.SetState(8224) - p.Match(DorisSQLParserDISTRIBUTED) + p.Match(StarRocksSQLParserDISTRIBUTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140341,7 +140341,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte } { p.SetState(8225) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140349,7 +140349,7 @@ func (p *DorisSQLParser) DistributionClause() (localctx IDistributionClauseConte } { p.SetState(8226) - p.Match(DorisSQLParserHASH) + p.Match(StarRocksSQLParserHASH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140405,13 +140405,13 @@ type DistributionDescContext struct { func NewEmptyDistributionDescContext() *DistributionDescContext { var p = new(DistributionDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_distributionDesc + p.RuleIndex = StarRocksSQLParserRULE_distributionDesc return p } func InitEmptyDistributionDescContext(p *DistributionDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_distributionDesc + p.RuleIndex = StarRocksSQLParserRULE_distributionDesc } func (*DistributionDescContext) IsDistributionDescContext() {} @@ -140422,7 +140422,7 @@ func NewDistributionDescContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_distributionDesc + p.RuleIndex = StarRocksSQLParserRULE_distributionDesc return p } @@ -140430,15 +140430,15 @@ func NewDistributionDescContext(parser antlr.Parser, parent antlr.ParserRuleCont func (s *DistributionDescContext) GetParser() antlr.Parser { return s.parser } func (s *DistributionDescContext) DISTRIBUTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTRIBUTED, 0) + return s.GetToken(StarRocksSQLParserDISTRIBUTED, 0) } func (s *DistributionDescContext) BY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBY, 0) + return s.GetToken(StarRocksSQLParserBY, 0) } func (s *DistributionDescContext) HASH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHASH, 0) + return s.GetToken(StarRocksSQLParserHASH, 0) } func (s *DistributionDescContext) IdentifierList() IIdentifierListContext { @@ -140458,15 +140458,15 @@ func (s *DistributionDescContext) IdentifierList() IIdentifierListContext { } func (s *DistributionDescContext) BUCKETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBUCKETS, 0) + return s.GetToken(StarRocksSQLParserBUCKETS, 0) } func (s *DistributionDescContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *DistributionDescContext) RANDOM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRANDOM, 0) + return s.GetToken(StarRocksSQLParserRANDOM, 0) } func (s *DistributionDescContext) GetRuleContext() antlr.RuleContext { @@ -140478,20 +140478,20 @@ func (s *DistributionDescContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *DistributionDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDistributionDesc(s) } } func (s *DistributionDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDistributionDesc(s) } } func (s *DistributionDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDistributionDesc(s) default: @@ -140499,9 +140499,9 @@ func (s *DistributionDescContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) { +func (p *StarRocksSQLParser) DistributionDesc() (localctx IDistributionDescContext) { localctx = NewDistributionDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1002, DorisSQLParserRULE_distributionDesc) + p.EnterRule(localctx, 1002, StarRocksSQLParserRULE_distributionDesc) var _la int p.SetState(8249) @@ -140515,7 +140515,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) p.EnterOuterAlt(localctx, 1) { p.SetState(8230) - p.Match(DorisSQLParserDISTRIBUTED) + p.Match(StarRocksSQLParserDISTRIBUTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140523,7 +140523,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8231) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140531,7 +140531,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8232) - p.Match(DorisSQLParserHASH) + p.Match(StarRocksSQLParserHASH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140548,10 +140548,10 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBUCKETS { + if _la == StarRocksSQLParserBUCKETS { { p.SetState(8234) - p.Match(DorisSQLParserBUCKETS) + p.Match(StarRocksSQLParserBUCKETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140559,7 +140559,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8235) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140572,7 +140572,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) p.EnterOuterAlt(localctx, 2) { p.SetState(8238) - p.Match(DorisSQLParserDISTRIBUTED) + p.Match(StarRocksSQLParserDISTRIBUTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140580,7 +140580,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8239) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140588,7 +140588,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8240) - p.Match(DorisSQLParserHASH) + p.Match(StarRocksSQLParserHASH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140603,7 +140603,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) p.EnterOuterAlt(localctx, 3) { p.SetState(8242) - p.Match(DorisSQLParserDISTRIBUTED) + p.Match(StarRocksSQLParserDISTRIBUTED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140611,7 +140611,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8243) - p.Match(DorisSQLParserBY) + p.Match(StarRocksSQLParserBY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140619,7 +140619,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8244) - p.Match(DorisSQLParserRANDOM) + p.Match(StarRocksSQLParserRANDOM) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140632,10 +140632,10 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserBUCKETS { + if _la == StarRocksSQLParserBUCKETS { { p.SetState(8245) - p.Match(DorisSQLParserBUCKETS) + p.Match(StarRocksSQLParserBUCKETS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140643,7 +140643,7 @@ func (p *DorisSQLParser) DistributionDesc() (localctx IDistributionDescContext) } { p.SetState(8246) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140700,13 +140700,13 @@ type RefreshSchemeDescContext struct { func NewEmptyRefreshSchemeDescContext() *RefreshSchemeDescContext { var p = new(RefreshSchemeDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshSchemeDesc + p.RuleIndex = StarRocksSQLParserRULE_refreshSchemeDesc return p } func InitEmptyRefreshSchemeDescContext(p *RefreshSchemeDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_refreshSchemeDesc + p.RuleIndex = StarRocksSQLParserRULE_refreshSchemeDesc } func (*RefreshSchemeDescContext) IsRefreshSchemeDescContext() {} @@ -140717,7 +140717,7 @@ func NewRefreshSchemeDescContext(parser antlr.Parser, parent antlr.ParserRuleCon antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_refreshSchemeDesc + p.RuleIndex = StarRocksSQLParserRULE_refreshSchemeDesc return p } @@ -140725,15 +140725,15 @@ func NewRefreshSchemeDescContext(parser antlr.Parser, parent antlr.ParserRuleCon func (s *RefreshSchemeDescContext) GetParser() antlr.Parser { return s.parser } func (s *RefreshSchemeDescContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *RefreshSchemeDescContext) ASYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASYNC, 0) + return s.GetToken(StarRocksSQLParserASYNC, 0) } func (s *RefreshSchemeDescContext) EVERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEVERY, 0) + return s.GetToken(StarRocksSQLParserEVERY, 0) } func (s *RefreshSchemeDescContext) Interval() IIntervalContext { @@ -140753,23 +140753,23 @@ func (s *RefreshSchemeDescContext) Interval() IIntervalContext { } func (s *RefreshSchemeDescContext) INCREMENTAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINCREMENTAL, 0) + return s.GetToken(StarRocksSQLParserINCREMENTAL, 0) } func (s *RefreshSchemeDescContext) MANUAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMANUAL, 0) + return s.GetToken(StarRocksSQLParserMANUAL, 0) } func (s *RefreshSchemeDescContext) IMMEDIATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMMEDIATE, 0) + return s.GetToken(StarRocksSQLParserIMMEDIATE, 0) } func (s *RefreshSchemeDescContext) DEFERRED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEFERRED, 0) + return s.GetToken(StarRocksSQLParserDEFERRED, 0) } func (s *RefreshSchemeDescContext) START() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTART, 0) + return s.GetToken(StarRocksSQLParserSTART, 0) } func (s *RefreshSchemeDescContext) String_() IStringContext { @@ -140797,20 +140797,20 @@ func (s *RefreshSchemeDescContext) ToStringTree(ruleNames []string, recog antlr. } func (s *RefreshSchemeDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterRefreshSchemeDesc(s) } } func (s *RefreshSchemeDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitRefreshSchemeDesc(s) } } func (s *RefreshSchemeDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitRefreshSchemeDesc(s) default: @@ -140818,15 +140818,15 @@ func (s *RefreshSchemeDescContext) Accept(visitor antlr.ParseTreeVisitor) interf } } -func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext) { +func (p *StarRocksSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext) { localctx = NewRefreshSchemeDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1004, DorisSQLParserRULE_refreshSchemeDesc) + p.EnterRule(localctx, 1004, StarRocksSQLParserRULE_refreshSchemeDesc) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8251) - p.Match(DorisSQLParserREFRESH) + p.Match(StarRocksSQLParserREFRESH) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140839,12 +140839,12 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserDEFERRED || _la == DorisSQLParserIMMEDIATE { + if _la == StarRocksSQLParserDEFERRED || _la == StarRocksSQLParserIMMEDIATE { { p.SetState(8252) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDEFERRED || _la == DorisSQLParserIMMEDIATE) { + if !(_la == StarRocksSQLParserDEFERRED || _la == StarRocksSQLParserIMMEDIATE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -140863,7 +140863,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext case 1: { p.SetState(8255) - p.Match(DorisSQLParserASYNC) + p.Match(StarRocksSQLParserASYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140873,7 +140873,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext case 2: { p.SetState(8256) - p.Match(DorisSQLParserASYNC) + p.Match(StarRocksSQLParserASYNC) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140886,10 +140886,10 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserSTART { + if _la == StarRocksSQLParserSTART { { p.SetState(8257) - p.Match(DorisSQLParserSTART) + p.Match(StarRocksSQLParserSTART) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140897,7 +140897,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } { p.SetState(8258) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140909,7 +140909,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } { p.SetState(8260) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140919,7 +140919,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } { p.SetState(8264) - p.Match(DorisSQLParserEVERY) + p.Match(StarRocksSQLParserEVERY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140927,7 +140927,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } { p.SetState(8265) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140939,7 +140939,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext } { p.SetState(8267) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140949,7 +140949,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext case 3: { p.SetState(8269) - p.Match(DorisSQLParserINCREMENTAL) + p.Match(StarRocksSQLParserINCREMENTAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -140959,7 +140959,7 @@ func (p *DorisSQLParser) RefreshSchemeDesc() (localctx IRefreshSchemeDescContext case 4: { p.SetState(8270) - p.Match(DorisSQLParserMANUAL) + p.Match(StarRocksSQLParserMANUAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141006,13 +141006,13 @@ type StatusDescContext struct { func NewEmptyStatusDescContext() *StatusDescContext { var p = new(StatusDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_statusDesc + p.RuleIndex = StarRocksSQLParserRULE_statusDesc return p } func InitEmptyStatusDescContext(p *StatusDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_statusDesc + p.RuleIndex = StarRocksSQLParserRULE_statusDesc } func (*StatusDescContext) IsStatusDescContext() {} @@ -141023,7 +141023,7 @@ func NewStatusDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_statusDesc + p.RuleIndex = StarRocksSQLParserRULE_statusDesc return p } @@ -141031,11 +141031,11 @@ func NewStatusDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *StatusDescContext) GetParser() antlr.Parser { return s.parser } func (s *StatusDescContext) ACTIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserACTIVE, 0) + return s.GetToken(StarRocksSQLParserACTIVE, 0) } func (s *StatusDescContext) INACTIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINACTIVE, 0) + return s.GetToken(StarRocksSQLParserINACTIVE, 0) } func (s *StatusDescContext) GetRuleContext() antlr.RuleContext { @@ -141047,20 +141047,20 @@ func (s *StatusDescContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *StatusDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterStatusDesc(s) } } func (s *StatusDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitStatusDesc(s) } } func (s *StatusDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitStatusDesc(s) default: @@ -141068,9 +141068,9 @@ func (s *StatusDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) StatusDesc() (localctx IStatusDescContext) { +func (p *StarRocksSQLParser) StatusDesc() (localctx IStatusDescContext) { localctx = NewStatusDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1006, DorisSQLParserRULE_statusDesc) + p.EnterRule(localctx, 1006, StarRocksSQLParserRULE_statusDesc) var _la int p.EnterOuterAlt(localctx, 1) @@ -141078,7 +141078,7 @@ func (p *DorisSQLParser) StatusDesc() (localctx IStatusDescContext) { p.SetState(8273) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserACTIVE || _la == DorisSQLParserINACTIVE) { + if !(_la == StarRocksSQLParserACTIVE || _la == StarRocksSQLParserINACTIVE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -141123,13 +141123,13 @@ type PropertiesContext struct { func NewEmptyPropertiesContext() *PropertiesContext { var p = new(PropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_properties + p.RuleIndex = StarRocksSQLParserRULE_properties return p } func InitEmptyPropertiesContext(p *PropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_properties + p.RuleIndex = StarRocksSQLParserRULE_properties } func (*PropertiesContext) IsPropertiesContext() {} @@ -141140,7 +141140,7 @@ func NewPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_properties + p.RuleIndex = StarRocksSQLParserRULE_properties return p } @@ -141148,7 +141148,7 @@ func NewPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *PropertiesContext) GetParser() antlr.Parser { return s.parser } func (s *PropertiesContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *PropertiesContext) AllProperty() []IPropertyContext { @@ -141201,20 +141201,20 @@ func (s *PropertiesContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *PropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterProperties(s) } } func (s *PropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitProperties(s) } } func (s *PropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitProperties(s) default: @@ -141222,15 +141222,15 @@ func (s *PropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Properties() (localctx IPropertiesContext) { +func (p *StarRocksSQLParser) Properties() (localctx IPropertiesContext) { localctx = NewPropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1008, DorisSQLParserRULE_properties) + p.EnterRule(localctx, 1008, StarRocksSQLParserRULE_properties) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8275) - p.Match(DorisSQLParserPROPERTIES) + p.Match(StarRocksSQLParserPROPERTIES) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141238,7 +141238,7 @@ func (p *DorisSQLParser) Properties() (localctx IPropertiesContext) { } { p.SetState(8276) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141255,10 +141255,10 @@ func (p *DorisSQLParser) Properties() (localctx IPropertiesContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8278) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141278,7 +141278,7 @@ func (p *DorisSQLParser) Properties() (localctx IPropertiesContext) { } { p.SetState(8285) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141321,13 +141321,13 @@ type ExtPropertiesContext struct { func NewEmptyExtPropertiesContext() *ExtPropertiesContext { var p = new(ExtPropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_extProperties + p.RuleIndex = StarRocksSQLParserRULE_extProperties return p } func InitEmptyExtPropertiesContext(p *ExtPropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_extProperties + p.RuleIndex = StarRocksSQLParserRULE_extProperties } func (*ExtPropertiesContext) IsExtPropertiesContext() {} @@ -141338,7 +141338,7 @@ func NewExtPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_extProperties + p.RuleIndex = StarRocksSQLParserRULE_extProperties return p } @@ -141346,7 +141346,7 @@ func NewExtPropertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *ExtPropertiesContext) GetParser() antlr.Parser { return s.parser } func (s *ExtPropertiesContext) BROKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBROKER, 0) + return s.GetToken(StarRocksSQLParserBROKER, 0) } func (s *ExtPropertiesContext) Properties() IPropertiesContext { @@ -141374,20 +141374,20 @@ func (s *ExtPropertiesContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *ExtPropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterExtProperties(s) } } func (s *ExtPropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitExtProperties(s) } } func (s *ExtPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitExtProperties(s) default: @@ -141395,13 +141395,13 @@ func (s *ExtPropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) ExtProperties() (localctx IExtPropertiesContext) { +func (p *StarRocksSQLParser) ExtProperties() (localctx IExtPropertiesContext) { localctx = NewExtPropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1010, DorisSQLParserRULE_extProperties) + p.EnterRule(localctx, 1010, StarRocksSQLParserRULE_extProperties) p.EnterOuterAlt(localctx, 1) { p.SetState(8287) - p.Match(DorisSQLParserBROKER) + p.Match(StarRocksSQLParserBROKER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141448,13 +141448,13 @@ type PropertyListContext struct { func NewEmptyPropertyListContext() *PropertyListContext { var p = new(PropertyListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_propertyList + p.RuleIndex = StarRocksSQLParserRULE_propertyList return p } func InitEmptyPropertyListContext(p *PropertyListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_propertyList + p.RuleIndex = StarRocksSQLParserRULE_propertyList } func (*PropertyListContext) IsPropertyListContext() {} @@ -141465,7 +141465,7 @@ func NewPropertyListContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_propertyList + p.RuleIndex = StarRocksSQLParserRULE_propertyList return p } @@ -141522,20 +141522,20 @@ func (s *PropertyListContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *PropertyListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterPropertyList(s) } } func (s *PropertyListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitPropertyList(s) } } func (s *PropertyListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitPropertyList(s) default: @@ -141543,15 +141543,15 @@ func (s *PropertyListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) PropertyList() (localctx IPropertyListContext) { +func (p *StarRocksSQLParser) PropertyList() (localctx IPropertyListContext) { localctx = NewPropertyListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1012, DorisSQLParserRULE_propertyList) + p.EnterRule(localctx, 1012, StarRocksSQLParserRULE_propertyList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8290) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141568,10 +141568,10 @@ func (p *DorisSQLParser) PropertyList() (localctx IPropertyListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8292) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141591,7 +141591,7 @@ func (p *DorisSQLParser) PropertyList() (localctx IPropertyListContext) { } { p.SetState(8299) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141634,13 +141634,13 @@ type UserPropertyListContext struct { func NewEmptyUserPropertyListContext() *UserPropertyListContext { var p = new(UserPropertyListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_userPropertyList + p.RuleIndex = StarRocksSQLParserRULE_userPropertyList return p } func InitEmptyUserPropertyListContext(p *UserPropertyListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_userPropertyList + p.RuleIndex = StarRocksSQLParserRULE_userPropertyList } func (*UserPropertyListContext) IsUserPropertyListContext() {} @@ -141651,7 +141651,7 @@ func NewUserPropertyListContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_userPropertyList + p.RuleIndex = StarRocksSQLParserRULE_userPropertyList return p } @@ -141708,20 +141708,20 @@ func (s *UserPropertyListContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *UserPropertyListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUserPropertyList(s) } } func (s *UserPropertyListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUserPropertyList(s) } } func (s *UserPropertyListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUserPropertyList(s) default: @@ -141729,9 +141729,9 @@ func (s *UserPropertyListContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) UserPropertyList() (localctx IUserPropertyListContext) { +func (p *StarRocksSQLParser) UserPropertyList() (localctx IUserPropertyListContext) { localctx = NewUserPropertyListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1014, DorisSQLParserRULE_userPropertyList) + p.EnterRule(localctx, 1014, StarRocksSQLParserRULE_userPropertyList) var _la int p.EnterOuterAlt(localctx, 1) @@ -141746,10 +141746,10 @@ func (p *DorisSQLParser) UserPropertyList() (localctx IUserPropertyListContext) } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8302) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141819,13 +141819,13 @@ type PropertyContext struct { func NewEmptyPropertyContext() *PropertyContext { var p = new(PropertyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_property + p.RuleIndex = StarRocksSQLParserRULE_property return p } func InitEmptyPropertyContext(p *PropertyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_property + p.RuleIndex = StarRocksSQLParserRULE_property } func (*PropertyContext) IsPropertyContext() {} @@ -141836,7 +141836,7 @@ func NewPropertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_property + p.RuleIndex = StarRocksSQLParserRULE_property return p } @@ -141852,7 +141852,7 @@ func (s *PropertyContext) SetKey(v IStringContext) { s.key = v } func (s *PropertyContext) SetValue(v IStringContext) { s.value = v } func (s *PropertyContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *PropertyContext) AllString_() []IStringContext { @@ -141905,20 +141905,20 @@ func (s *PropertyContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *PropertyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterProperty(s) } } func (s *PropertyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitProperty(s) } } func (s *PropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitProperty(s) default: @@ -141926,9 +141926,9 @@ func (s *PropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Property() (localctx IPropertyContext) { +func (p *StarRocksSQLParser) Property() (localctx IPropertyContext) { localctx = NewPropertyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1016, DorisSQLParserRULE_property) + p.EnterRule(localctx, 1016, StarRocksSQLParserRULE_property) p.EnterOuterAlt(localctx, 1) { p.SetState(8309) @@ -141939,7 +141939,7 @@ func (p *DorisSQLParser) Property() (localctx IPropertyContext) { } { p.SetState(8310) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -141989,13 +141989,13 @@ type InlinePropertiesContext struct { func NewEmptyInlinePropertiesContext() *InlinePropertiesContext { var p = new(InlinePropertiesContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_inlineProperties + p.RuleIndex = StarRocksSQLParserRULE_inlineProperties return p } func InitEmptyInlinePropertiesContext(p *InlinePropertiesContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_inlineProperties + p.RuleIndex = StarRocksSQLParserRULE_inlineProperties } func (*InlinePropertiesContext) IsInlinePropertiesContext() {} @@ -142006,7 +142006,7 @@ func NewInlinePropertiesContext(parser antlr.Parser, parent antlr.ParserRuleCont antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_inlineProperties + p.RuleIndex = StarRocksSQLParserRULE_inlineProperties return p } @@ -142063,20 +142063,20 @@ func (s *InlinePropertiesContext) ToStringTree(ruleNames []string, recog antlr.R } func (s *InlinePropertiesContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInlineProperties(s) } } func (s *InlinePropertiesContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInlineProperties(s) } } func (s *InlinePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInlineProperties(s) default: @@ -142084,9 +142084,9 @@ func (s *InlinePropertiesContext) Accept(visitor antlr.ParseTreeVisitor) interfa } } -func (p *DorisSQLParser) InlineProperties() (localctx IInlinePropertiesContext) { +func (p *StarRocksSQLParser) InlineProperties() (localctx IInlinePropertiesContext) { localctx = NewInlinePropertiesContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1018, DorisSQLParserRULE_inlineProperties) + p.EnterRule(localctx, 1018, StarRocksSQLParserRULE_inlineProperties) var _la int p.EnterOuterAlt(localctx, 1) @@ -142166,13 +142166,13 @@ type InlinePropertyContext struct { func NewEmptyInlinePropertyContext() *InlinePropertyContext { var p = new(InlinePropertyContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_inlineProperty + p.RuleIndex = StarRocksSQLParserRULE_inlineProperty return p } func InitEmptyInlinePropertyContext(p *InlinePropertyContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_inlineProperty + p.RuleIndex = StarRocksSQLParserRULE_inlineProperty } func (*InlinePropertyContext) IsInlinePropertyContext() {} @@ -142183,7 +142183,7 @@ func NewInlinePropertyContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_inlineProperty + p.RuleIndex = StarRocksSQLParserRULE_inlineProperty return p } @@ -142199,7 +142199,7 @@ func (s *InlinePropertyContext) SetKey(v IIdentifierContext) { s.key = v } func (s *InlinePropertyContext) SetValue(v IStringContext) { s.value = v } func (s *InlinePropertyContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *InlinePropertyContext) Identifier() IIdentifierContext { @@ -142243,20 +142243,20 @@ func (s *InlinePropertyContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *InlinePropertyContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInlineProperty(s) } } func (s *InlinePropertyContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInlineProperty(s) } } func (s *InlinePropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInlineProperty(s) default: @@ -142264,9 +142264,9 @@ func (s *InlinePropertyContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) InlineProperty() (localctx IInlinePropertyContext) { +func (p *StarRocksSQLParser) InlineProperty() (localctx IInlinePropertyContext) { localctx = NewInlinePropertyContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1020, DorisSQLParserRULE_inlineProperty) + p.EnterRule(localctx, 1020, StarRocksSQLParserRULE_inlineProperty) p.EnterOuterAlt(localctx, 1) { p.SetState(8320) @@ -142277,7 +142277,7 @@ func (p *DorisSQLParser) InlineProperty() (localctx IInlinePropertyContext) { } { p.SetState(8321) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -142329,13 +142329,13 @@ type VarTypeContext struct { func NewEmptyVarTypeContext() *VarTypeContext { var p = new(VarTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_varType + p.RuleIndex = StarRocksSQLParserRULE_varType return p } func InitEmptyVarTypeContext(p *VarTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_varType + p.RuleIndex = StarRocksSQLParserRULE_varType } func (*VarTypeContext) IsVarTypeContext() {} @@ -142346,7 +142346,7 @@ func NewVarTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_varType + p.RuleIndex = StarRocksSQLParserRULE_varType return p } @@ -142354,19 +142354,19 @@ func NewVarTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *VarTypeContext) GetParser() antlr.Parser { return s.parser } func (s *VarTypeContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *VarTypeContext) LOCAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCAL, 0) + return s.GetToken(StarRocksSQLParserLOCAL, 0) } func (s *VarTypeContext) SESSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSESSION, 0) + return s.GetToken(StarRocksSQLParserSESSION, 0) } func (s *VarTypeContext) VERBOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERBOSE, 0) + return s.GetToken(StarRocksSQLParserVERBOSE, 0) } func (s *VarTypeContext) GetRuleContext() antlr.RuleContext { @@ -142378,20 +142378,20 @@ func (s *VarTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *VarTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterVarType(s) } } func (s *VarTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitVarType(s) } } func (s *VarTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitVarType(s) default: @@ -142399,9 +142399,9 @@ func (s *VarTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) VarType() (localctx IVarTypeContext) { +func (p *StarRocksSQLParser) VarType() (localctx IVarTypeContext) { localctx = NewVarTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1022, DorisSQLParserRULE_varType) + p.EnterRule(localctx, 1022, StarRocksSQLParserRULE_varType) var _la int p.EnterOuterAlt(localctx, 1) @@ -142409,7 +142409,7 @@ func (p *DorisSQLParser) VarType() (localctx IVarTypeContext) { p.SetState(8324) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserGLOBAL || _la == DorisSQLParserLOCAL || _la == DorisSQLParserSESSION || _la == DorisSQLParserVERBOSE) { + if !(_la == StarRocksSQLParserGLOBAL || _la == StarRocksSQLParserLOCAL || _la == StarRocksSQLParserSESSION || _la == StarRocksSQLParserVERBOSE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -142453,13 +142453,13 @@ type CommentContext struct { func NewEmptyCommentContext() *CommentContext { var p = new(CommentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_comment + p.RuleIndex = StarRocksSQLParserRULE_comment return p } func InitEmptyCommentContext(p *CommentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_comment + p.RuleIndex = StarRocksSQLParserRULE_comment } func (*CommentContext) IsCommentContext() {} @@ -142470,7 +142470,7 @@ func NewCommentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_comment + p.RuleIndex = StarRocksSQLParserRULE_comment return p } @@ -142478,7 +142478,7 @@ func NewCommentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *CommentContext) GetParser() antlr.Parser { return s.parser } func (s *CommentContext) COMMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMENT, 0) + return s.GetToken(StarRocksSQLParserCOMMENT, 0) } func (s *CommentContext) String_() IStringContext { @@ -142506,20 +142506,20 @@ func (s *CommentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *CommentContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterComment(s) } } func (s *CommentContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitComment(s) } } func (s *CommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitComment(s) default: @@ -142527,13 +142527,13 @@ func (s *CommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Comment() (localctx ICommentContext) { +func (p *StarRocksSQLParser) Comment() (localctx ICommentContext) { localctx = NewCommentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1024, DorisSQLParserRULE_comment) + p.EnterRule(localctx, 1024, StarRocksSQLParserRULE_comment) p.EnterOuterAlt(localctx, 1) { p.SetState(8326) - p.Match(DorisSQLParserCOMMENT) + p.Match(StarRocksSQLParserCOMMENT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -142590,13 +142590,13 @@ type OutfileContext struct { func NewEmptyOutfileContext() *OutfileContext { var p = new(OutfileContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_outfile + p.RuleIndex = StarRocksSQLParserRULE_outfile return p } func InitEmptyOutfileContext(p *OutfileContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_outfile + p.RuleIndex = StarRocksSQLParserRULE_outfile } func (*OutfileContext) IsOutfileContext() {} @@ -142607,7 +142607,7 @@ func NewOutfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_outfile + p.RuleIndex = StarRocksSQLParserRULE_outfile return p } @@ -142619,11 +142619,11 @@ func (s *OutfileContext) GetFile() IStringContext { return s.file } func (s *OutfileContext) SetFile(v IStringContext) { s.file = v } func (s *OutfileContext) INTO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTO, 0) + return s.GetToken(StarRocksSQLParserINTO, 0) } func (s *OutfileContext) OUTFILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOUTFILE, 0) + return s.GetToken(StarRocksSQLParserOUTFILE, 0) } func (s *OutfileContext) String_() IStringContext { @@ -142683,20 +142683,20 @@ func (s *OutfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *OutfileContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterOutfile(s) } } func (s *OutfileContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitOutfile(s) } } func (s *OutfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitOutfile(s) default: @@ -142704,15 +142704,15 @@ func (s *OutfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Outfile() (localctx IOutfileContext) { +func (p *StarRocksSQLParser) Outfile() (localctx IOutfileContext) { localctx = NewOutfileContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1026, DorisSQLParserRULE_outfile) + p.EnterRule(localctx, 1026, StarRocksSQLParserRULE_outfile) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8329) - p.Match(DorisSQLParserINTO) + p.Match(StarRocksSQLParserINTO) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -142720,7 +142720,7 @@ func (p *DorisSQLParser) Outfile() (localctx IOutfileContext) { } { p.SetState(8330) - p.Match(DorisSQLParserOUTFILE) + p.Match(StarRocksSQLParserOUTFILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -142740,7 +142740,7 @@ func (p *DorisSQLParser) Outfile() (localctx IOutfileContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFORMAT { + if _la == StarRocksSQLParserFORMAT { { p.SetState(8332) p.FileFormat() @@ -142754,7 +142754,7 @@ func (p *DorisSQLParser) Outfile() (localctx IOutfileContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserPROPERTIES { + if _la == StarRocksSQLParserPROPERTIES { { p.SetState(8335) p.Properties() @@ -142800,13 +142800,13 @@ type FileFormatContext struct { func NewEmptyFileFormatContext() *FileFormatContext { var p = new(FileFormatContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_fileFormat + p.RuleIndex = StarRocksSQLParserRULE_fileFormat return p } func InitEmptyFileFormatContext(p *FileFormatContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_fileFormat + p.RuleIndex = StarRocksSQLParserRULE_fileFormat } func (*FileFormatContext) IsFileFormatContext() {} @@ -142817,7 +142817,7 @@ func NewFileFormatContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_fileFormat + p.RuleIndex = StarRocksSQLParserRULE_fileFormat return p } @@ -142825,11 +142825,11 @@ func NewFileFormatContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *FileFormatContext) GetParser() antlr.Parser { return s.parser } func (s *FileFormatContext) FORMAT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORMAT, 0) + return s.GetToken(StarRocksSQLParserFORMAT, 0) } func (s *FileFormatContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *FileFormatContext) Identifier() IIdentifierContext { @@ -142873,20 +142873,20 @@ func (s *FileFormatContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *FileFormatContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterFileFormat(s) } } func (s *FileFormatContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitFileFormat(s) } } func (s *FileFormatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitFileFormat(s) default: @@ -142894,13 +142894,13 @@ func (s *FileFormatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) FileFormat() (localctx IFileFormatContext) { +func (p *StarRocksSQLParser) FileFormat() (localctx IFileFormatContext) { localctx = NewFileFormatContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1028, DorisSQLParserRULE_fileFormat) + p.EnterRule(localctx, 1028, StarRocksSQLParserRULE_fileFormat) p.EnterOuterAlt(localctx, 1) { p.SetState(8338) - p.Match(DorisSQLParserFORMAT) + p.Match(StarRocksSQLParserFORMAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -142908,7 +142908,7 @@ func (p *DorisSQLParser) FileFormat() (localctx IFileFormatContext) { } { p.SetState(8339) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -142921,13 +142921,13 @@ func (p *DorisSQLParser) FileFormat() (localctx IFileFormatContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: { p.SetState(8340) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: { p.SetState(8341) p.String_() @@ -142974,13 +142974,13 @@ type StringContext struct { func NewEmptyStringContext() *StringContext { var p = new(StringContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_string + p.RuleIndex = StarRocksSQLParserRULE_string return p } func InitEmptyStringContext(p *StringContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_string + p.RuleIndex = StarRocksSQLParserRULE_string } func (*StringContext) IsStringContext() {} @@ -142991,7 +142991,7 @@ func NewStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_string + p.RuleIndex = StarRocksSQLParserRULE_string return p } @@ -142999,11 +142999,11 @@ func NewStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok func (s *StringContext) GetParser() antlr.Parser { return s.parser } func (s *StringContext) SINGLE_QUOTED_TEXT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSINGLE_QUOTED_TEXT, 0) + return s.GetToken(StarRocksSQLParserSINGLE_QUOTED_TEXT, 0) } func (s *StringContext) DOUBLE_QUOTED_TEXT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOUBLE_QUOTED_TEXT, 0) + return s.GetToken(StarRocksSQLParserDOUBLE_QUOTED_TEXT, 0) } func (s *StringContext) GetRuleContext() antlr.RuleContext { @@ -143015,20 +143015,20 @@ func (s *StringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) } func (s *StringContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterString(s) } } func (s *StringContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitString(s) } } func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitString(s) default: @@ -143036,9 +143036,9 @@ func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) String_() (localctx IStringContext) { +func (p *StarRocksSQLParser) String_() (localctx IStringContext) { localctx = NewStringContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1030, DorisSQLParserRULE_string) + p.EnterRule(localctx, 1030, StarRocksSQLParserRULE_string) var _la int p.EnterOuterAlt(localctx, 1) @@ -143046,7 +143046,7 @@ func (p *DorisSQLParser) String_() (localctx IStringContext) { p.SetState(8344) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserSINGLE_QUOTED_TEXT || _la == DorisSQLParserDOUBLE_QUOTED_TEXT) { + if !(_la == StarRocksSQLParserSINGLE_QUOTED_TEXT || _la == StarRocksSQLParserDOUBLE_QUOTED_TEXT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -143090,13 +143090,13 @@ type BinaryContext struct { func NewEmptyBinaryContext() *BinaryContext { var p = new(BinaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_binary + p.RuleIndex = StarRocksSQLParserRULE_binary return p } func InitEmptyBinaryContext(p *BinaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_binary + p.RuleIndex = StarRocksSQLParserRULE_binary } func (*BinaryContext) IsBinaryContext() {} @@ -143107,7 +143107,7 @@ func NewBinaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_binary + p.RuleIndex = StarRocksSQLParserRULE_binary return p } @@ -143115,11 +143115,11 @@ func NewBinaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok func (s *BinaryContext) GetParser() antlr.Parser { return s.parser } func (s *BinaryContext) BINARY_SINGLE_QUOTED_TEXT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBINARY_SINGLE_QUOTED_TEXT, 0) + return s.GetToken(StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT, 0) } func (s *BinaryContext) BINARY_DOUBLE_QUOTED_TEXT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT, 0) + return s.GetToken(StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT, 0) } func (s *BinaryContext) GetRuleContext() antlr.RuleContext { @@ -143131,20 +143131,20 @@ func (s *BinaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) } func (s *BinaryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBinary(s) } } func (s *BinaryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBinary(s) } } func (s *BinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBinary(s) default: @@ -143152,9 +143152,9 @@ func (s *BinaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Binary() (localctx IBinaryContext) { +func (p *StarRocksSQLParser) Binary() (localctx IBinaryContext) { localctx = NewBinaryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1032, DorisSQLParserRULE_binary) + p.EnterRule(localctx, 1032, StarRocksSQLParserRULE_binary) var _la int p.EnterOuterAlt(localctx, 1) @@ -143162,7 +143162,7 @@ func (p *DorisSQLParser) Binary() (localctx IBinaryContext) { p.SetState(8346) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserBINARY_SINGLE_QUOTED_TEXT || _la == DorisSQLParserBINARY_DOUBLE_QUOTED_TEXT) { + if !(_la == StarRocksSQLParserBINARY_SINGLE_QUOTED_TEXT || _la == StarRocksSQLParserBINARY_DOUBLE_QUOTED_TEXT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -143211,13 +143211,13 @@ type ComparisonOperatorContext struct { func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext { var p = new(ComparisonOperatorContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_comparisonOperator + p.RuleIndex = StarRocksSQLParserRULE_comparisonOperator return p } func InitEmptyComparisonOperatorContext(p *ComparisonOperatorContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_comparisonOperator + p.RuleIndex = StarRocksSQLParserRULE_comparisonOperator } func (*ComparisonOperatorContext) IsComparisonOperatorContext() {} @@ -143228,7 +143228,7 @@ func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_comparisonOperator + p.RuleIndex = StarRocksSQLParserRULE_comparisonOperator return p } @@ -143236,31 +143236,31 @@ func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *ComparisonOperatorContext) GetParser() antlr.Parser { return s.parser } func (s *ComparisonOperatorContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *ComparisonOperatorContext) NEQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNEQ, 0) + return s.GetToken(StarRocksSQLParserNEQ, 0) } func (s *ComparisonOperatorContext) LT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLT, 0) + return s.GetToken(StarRocksSQLParserLT, 0) } func (s *ComparisonOperatorContext) LTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLTE, 0) + return s.GetToken(StarRocksSQLParserLTE, 0) } func (s *ComparisonOperatorContext) GT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGT, 0) + return s.GetToken(StarRocksSQLParserGT, 0) } func (s *ComparisonOperatorContext) GTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGTE, 0) + return s.GetToken(StarRocksSQLParserGTE, 0) } func (s *ComparisonOperatorContext) EQ_FOR_NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ_FOR_NULL, 0) + return s.GetToken(StarRocksSQLParserEQ_FOR_NULL, 0) } func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext { @@ -143272,20 +143272,20 @@ func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr } func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterComparisonOperator(s) } } func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitComparisonOperator(s) } } func (s *ComparisonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitComparisonOperator(s) default: @@ -143293,9 +143293,9 @@ func (s *ComparisonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) ComparisonOperator() (localctx IComparisonOperatorContext) { +func (p *StarRocksSQLParser) ComparisonOperator() (localctx IComparisonOperatorContext) { localctx = NewComparisonOperatorContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1034, DorisSQLParserRULE_comparisonOperator) + p.EnterRule(localctx, 1034, StarRocksSQLParserRULE_comparisonOperator) var _la int p.EnterOuterAlt(localctx, 1) @@ -143347,13 +143347,13 @@ type BooleanValueContext struct { func NewEmptyBooleanValueContext() *BooleanValueContext { var p = new(BooleanValueContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_booleanValue + p.RuleIndex = StarRocksSQLParserRULE_booleanValue return p } func InitEmptyBooleanValueContext(p *BooleanValueContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_booleanValue + p.RuleIndex = StarRocksSQLParserRULE_booleanValue } func (*BooleanValueContext) IsBooleanValueContext() {} @@ -143364,7 +143364,7 @@ func NewBooleanValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_booleanValue + p.RuleIndex = StarRocksSQLParserRULE_booleanValue return p } @@ -143372,11 +143372,11 @@ func NewBooleanValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *BooleanValueContext) GetParser() antlr.Parser { return s.parser } func (s *BooleanValueContext) TRUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRUE, 0) + return s.GetToken(StarRocksSQLParserTRUE, 0) } func (s *BooleanValueContext) FALSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFALSE, 0) + return s.GetToken(StarRocksSQLParserFALSE, 0) } func (s *BooleanValueContext) GetRuleContext() antlr.RuleContext { @@ -143388,20 +143388,20 @@ func (s *BooleanValueContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *BooleanValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBooleanValue(s) } } func (s *BooleanValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBooleanValue(s) } } func (s *BooleanValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBooleanValue(s) default: @@ -143409,9 +143409,9 @@ func (s *BooleanValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) BooleanValue() (localctx IBooleanValueContext) { +func (p *StarRocksSQLParser) BooleanValue() (localctx IBooleanValueContext) { localctx = NewBooleanValueContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1036, DorisSQLParserRULE_booleanValue) + p.EnterRule(localctx, 1036, StarRocksSQLParserRULE_booleanValue) var _la int p.EnterOuterAlt(localctx, 1) @@ -143419,7 +143419,7 @@ func (p *DorisSQLParser) BooleanValue() (localctx IBooleanValueContext) { p.SetState(8350) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserFALSE || _la == DorisSQLParserTRUE) { + if !(_la == StarRocksSQLParserFALSE || _la == StarRocksSQLParserTRUE) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -143478,13 +143478,13 @@ type IntervalContext struct { func NewEmptyIntervalContext() *IntervalContext { var p = new(IntervalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_interval + p.RuleIndex = StarRocksSQLParserRULE_interval return p } func InitEmptyIntervalContext(p *IntervalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_interval + p.RuleIndex = StarRocksSQLParserRULE_interval } func (*IntervalContext) IsIntervalContext() {} @@ -143495,7 +143495,7 @@ func NewIntervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_interval + p.RuleIndex = StarRocksSQLParserRULE_interval return p } @@ -143511,7 +143511,7 @@ func (s *IntervalContext) SetValue(v IExpressionContext) { s.value = v } func (s *IntervalContext) SetFrom(v IUnitIdentifierContext) { s.from = v } func (s *IntervalContext) INTERVAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTERVAL, 0) + return s.GetToken(StarRocksSQLParserINTERVAL, 0) } func (s *IntervalContext) Expression() IExpressionContext { @@ -143555,20 +143555,20 @@ func (s *IntervalContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *IntervalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterInterval(s) } } func (s *IntervalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitInterval(s) } } func (s *IntervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitInterval(s) default: @@ -143576,13 +143576,13 @@ func (s *IntervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Interval() (localctx IIntervalContext) { +func (p *StarRocksSQLParser) Interval() (localctx IIntervalContext) { localctx = NewIntervalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1038, DorisSQLParserRULE_interval) + p.EnterRule(localctx, 1038, StarRocksSQLParserRULE_interval) p.EnterOuterAlt(localctx, 1) { p.SetState(8352) - p.Match(DorisSQLParserINTERVAL) + p.Match(StarRocksSQLParserINTERVAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -143654,13 +143654,13 @@ type TaskIntervalContext struct { func NewEmptyTaskIntervalContext() *TaskIntervalContext { var p = new(TaskIntervalContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskInterval + p.RuleIndex = StarRocksSQLParserRULE_taskInterval return p } func InitEmptyTaskIntervalContext(p *TaskIntervalContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskInterval + p.RuleIndex = StarRocksSQLParserRULE_taskInterval } func (*TaskIntervalContext) IsTaskIntervalContext() {} @@ -143671,7 +143671,7 @@ func NewTaskIntervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_taskInterval + p.RuleIndex = StarRocksSQLParserRULE_taskInterval return p } @@ -143687,7 +143687,7 @@ func (s *TaskIntervalContext) SetValue(v IExpressionContext) { s.value = v } func (s *TaskIntervalContext) SetFrom(v ITaskUnitIdentifierContext) { s.from = v } func (s *TaskIntervalContext) INTERVAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTERVAL, 0) + return s.GetToken(StarRocksSQLParserINTERVAL, 0) } func (s *TaskIntervalContext) Expression() IExpressionContext { @@ -143731,20 +143731,20 @@ func (s *TaskIntervalContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *TaskIntervalContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTaskInterval(s) } } func (s *TaskIntervalContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTaskInterval(s) } } func (s *TaskIntervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTaskInterval(s) default: @@ -143752,13 +143752,13 @@ func (s *TaskIntervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) TaskInterval() (localctx ITaskIntervalContext) { +func (p *StarRocksSQLParser) TaskInterval() (localctx ITaskIntervalContext) { localctx = NewTaskIntervalContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1040, DorisSQLParserRULE_taskInterval) + p.EnterRule(localctx, 1040, StarRocksSQLParserRULE_taskInterval) p.EnterOuterAlt(localctx, 1) { p.SetState(8356) - p.Match(DorisSQLParserINTERVAL) + p.Match(StarRocksSQLParserINTERVAL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -143817,13 +143817,13 @@ type TaskUnitIdentifierContext struct { func NewEmptyTaskUnitIdentifierContext() *TaskUnitIdentifierContext { var p = new(TaskUnitIdentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskUnitIdentifier + p.RuleIndex = StarRocksSQLParserRULE_taskUnitIdentifier return p } func InitEmptyTaskUnitIdentifierContext(p *TaskUnitIdentifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_taskUnitIdentifier + p.RuleIndex = StarRocksSQLParserRULE_taskUnitIdentifier } func (*TaskUnitIdentifierContext) IsTaskUnitIdentifierContext() {} @@ -143834,7 +143834,7 @@ func NewTaskUnitIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_taskUnitIdentifier + p.RuleIndex = StarRocksSQLParserRULE_taskUnitIdentifier return p } @@ -143842,19 +143842,19 @@ func NewTaskUnitIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleCo func (s *TaskUnitIdentifierContext) GetParser() antlr.Parser { return s.parser } func (s *TaskUnitIdentifierContext) DAY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDAY, 0) + return s.GetToken(StarRocksSQLParserDAY, 0) } func (s *TaskUnitIdentifierContext) HOUR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOUR, 0) + return s.GetToken(StarRocksSQLParserHOUR, 0) } func (s *TaskUnitIdentifierContext) MINUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUTE, 0) + return s.GetToken(StarRocksSQLParserMINUTE, 0) } func (s *TaskUnitIdentifierContext) SECOND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECOND, 0) + return s.GetToken(StarRocksSQLParserSECOND, 0) } func (s *TaskUnitIdentifierContext) GetRuleContext() antlr.RuleContext { @@ -143866,20 +143866,20 @@ func (s *TaskUnitIdentifierContext) ToStringTree(ruleNames []string, recog antlr } func (s *TaskUnitIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTaskUnitIdentifier(s) } } func (s *TaskUnitIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTaskUnitIdentifier(s) } } func (s *TaskUnitIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTaskUnitIdentifier(s) default: @@ -143887,9 +143887,9 @@ func (s *TaskUnitIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) TaskUnitIdentifier() (localctx ITaskUnitIdentifierContext) { +func (p *StarRocksSQLParser) TaskUnitIdentifier() (localctx ITaskUnitIdentifierContext) { localctx = NewTaskUnitIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1042, DorisSQLParserRULE_taskUnitIdentifier) + p.EnterRule(localctx, 1042, StarRocksSQLParserRULE_taskUnitIdentifier) var _la int p.EnterOuterAlt(localctx, 1) @@ -143897,7 +143897,7 @@ func (p *DorisSQLParser) TaskUnitIdentifier() (localctx ITaskUnitIdentifierConte p.SetState(8360) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDAY || _la == DorisSQLParserHOUR || _la == DorisSQLParserMINUTE || _la == DorisSQLParserSECOND) { + if !(_la == StarRocksSQLParserDAY || _la == StarRocksSQLParserHOUR || _la == StarRocksSQLParserMINUTE || _la == StarRocksSQLParserSECOND) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -143949,13 +143949,13 @@ type UnitIdentifierContext struct { func NewEmptyUnitIdentifierContext() *UnitIdentifierContext { var p = new(UnitIdentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_unitIdentifier + p.RuleIndex = StarRocksSQLParserRULE_unitIdentifier return p } func InitEmptyUnitIdentifierContext(p *UnitIdentifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_unitIdentifier + p.RuleIndex = StarRocksSQLParserRULE_unitIdentifier } func (*UnitIdentifierContext) IsUnitIdentifierContext() {} @@ -143966,7 +143966,7 @@ func NewUnitIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_unitIdentifier + p.RuleIndex = StarRocksSQLParserRULE_unitIdentifier return p } @@ -143974,43 +143974,43 @@ func NewUnitIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContex func (s *UnitIdentifierContext) GetParser() antlr.Parser { return s.parser } func (s *UnitIdentifierContext) YEAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserYEAR, 0) + return s.GetToken(StarRocksSQLParserYEAR, 0) } func (s *UnitIdentifierContext) MONTH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMONTH, 0) + return s.GetToken(StarRocksSQLParserMONTH, 0) } func (s *UnitIdentifierContext) WEEK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWEEK, 0) + return s.GetToken(StarRocksSQLParserWEEK, 0) } func (s *UnitIdentifierContext) DAY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDAY, 0) + return s.GetToken(StarRocksSQLParserDAY, 0) } func (s *UnitIdentifierContext) HOUR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOUR, 0) + return s.GetToken(StarRocksSQLParserHOUR, 0) } func (s *UnitIdentifierContext) MINUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUTE, 0) + return s.GetToken(StarRocksSQLParserMINUTE, 0) } func (s *UnitIdentifierContext) SECOND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECOND, 0) + return s.GetToken(StarRocksSQLParserSECOND, 0) } func (s *UnitIdentifierContext) QUARTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUARTER, 0) + return s.GetToken(StarRocksSQLParserQUARTER, 0) } func (s *UnitIdentifierContext) MILLISECOND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMILLISECOND, 0) + return s.GetToken(StarRocksSQLParserMILLISECOND, 0) } func (s *UnitIdentifierContext) MICROSECOND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMICROSECOND, 0) + return s.GetToken(StarRocksSQLParserMICROSECOND, 0) } func (s *UnitIdentifierContext) GetRuleContext() antlr.RuleContext { @@ -144022,20 +144022,20 @@ func (s *UnitIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *UnitIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUnitIdentifier(s) } } func (s *UnitIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUnitIdentifier(s) } } func (s *UnitIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUnitIdentifier(s) default: @@ -144043,9 +144043,9 @@ func (s *UnitIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) UnitIdentifier() (localctx IUnitIdentifierContext) { +func (p *StarRocksSQLParser) UnitIdentifier() (localctx IUnitIdentifierContext) { localctx = NewUnitIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1044, DorisSQLParserRULE_unitIdentifier) + p.EnterRule(localctx, 1044, StarRocksSQLParserRULE_unitIdentifier) var _la int p.EnterOuterAlt(localctx, 1) @@ -144053,7 +144053,7 @@ func (p *DorisSQLParser) UnitIdentifier() (localctx IUnitIdentifierContext) { p.SetState(8362) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserDAY || _la == DorisSQLParserHOUR || ((int64((_la-263)) & ^0x3f) == 0 && ((int64(1)<<(_la-263))&1035) != 0) || _la == DorisSQLParserQUARTER || _la == DorisSQLParserSECOND || _la == DorisSQLParserWEEK || _la == DorisSQLParserYEAR) { + if !(_la == StarRocksSQLParserDAY || _la == StarRocksSQLParserHOUR || ((int64((_la-263)) & ^0x3f) == 0 && ((int64(1)<<(_la-263))&1035) != 0) || _la == StarRocksSQLParserQUARTER || _la == StarRocksSQLParserSECOND || _la == StarRocksSQLParserWEEK || _la == StarRocksSQLParserYEAR) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -144097,13 +144097,13 @@ type UnitBoundaryContext struct { func NewEmptyUnitBoundaryContext() *UnitBoundaryContext { var p = new(UnitBoundaryContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_unitBoundary + p.RuleIndex = StarRocksSQLParserRULE_unitBoundary return p } func InitEmptyUnitBoundaryContext(p *UnitBoundaryContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_unitBoundary + p.RuleIndex = StarRocksSQLParserRULE_unitBoundary } func (*UnitBoundaryContext) IsUnitBoundaryContext() {} @@ -144114,7 +144114,7 @@ func NewUnitBoundaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_unitBoundary + p.RuleIndex = StarRocksSQLParserRULE_unitBoundary return p } @@ -144122,11 +144122,11 @@ func NewUnitBoundaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *UnitBoundaryContext) GetParser() antlr.Parser { return s.parser } func (s *UnitBoundaryContext) FLOOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFLOOR, 0) + return s.GetToken(StarRocksSQLParserFLOOR, 0) } func (s *UnitBoundaryContext) CEIL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCEIL, 0) + return s.GetToken(StarRocksSQLParserCEIL, 0) } func (s *UnitBoundaryContext) GetRuleContext() antlr.RuleContext { @@ -144138,20 +144138,20 @@ func (s *UnitBoundaryContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *UnitBoundaryContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUnitBoundary(s) } } func (s *UnitBoundaryContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUnitBoundary(s) } } func (s *UnitBoundaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUnitBoundary(s) default: @@ -144159,9 +144159,9 @@ func (s *UnitBoundaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) UnitBoundary() (localctx IUnitBoundaryContext) { +func (p *StarRocksSQLParser) UnitBoundary() (localctx IUnitBoundaryContext) { localctx = NewUnitBoundaryContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1046, DorisSQLParserRULE_unitBoundary) + p.EnterRule(localctx, 1046, StarRocksSQLParserRULE_unitBoundary) var _la int p.EnterOuterAlt(localctx, 1) @@ -144169,7 +144169,7 @@ func (p *DorisSQLParser) UnitBoundary() (localctx IUnitBoundaryContext) { p.SetState(8364) _la = p.GetTokenStream().LA(1) - if !(_la == DorisSQLParserCEIL || _la == DorisSQLParserFLOOR) { + if !(_la == StarRocksSQLParserCEIL || _la == StarRocksSQLParserFLOOR) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -144216,13 +144216,13 @@ type TypeContext struct { func NewEmptyTypeContext() *TypeContext { var p = new(TypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_type + p.RuleIndex = StarRocksSQLParserRULE_type return p } func InitEmptyTypeContext(p *TypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_type + p.RuleIndex = StarRocksSQLParserRULE_type } func (*TypeContext) IsTypeContext() {} @@ -144233,7 +144233,7 @@ func NewTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_type + p.RuleIndex = StarRocksSQLParserRULE_type return p } @@ -144329,20 +144329,20 @@ func (s *TypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) s } func (s *TypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterType(s) } } func (s *TypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitType(s) } } func (s *TypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitType(s) default: @@ -144350,9 +144350,9 @@ func (s *TypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Type_() (localctx ITypeContext) { +func (p *StarRocksSQLParser) Type_() (localctx ITypeContext) { localctx = NewTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1048, DorisSQLParserRULE_type) + p.EnterRule(localctx, 1048, StarRocksSQLParserRULE_type) p.SetState(8371) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -144360,35 +144360,35 @@ func (p *DorisSQLParser) Type_() (localctx ITypeContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserBIGINT, DorisSQLParserBINARY, DorisSQLParserBITMAP, DorisSQLParserBOOLEAN, DorisSQLParserCHAR, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDOUBLE, DorisSQLParserFLOAT, DorisSQLParserHLL, DorisSQLParserINT, DorisSQLParserINTEGER, DorisSQLParserJSON, DorisSQLParserLARGEINT, DorisSQLParserPERCENTILE, DorisSQLParserSIGNED, DorisSQLParserSMALLINT, DorisSQLParserSTRING, DorisSQLParserTEXT, DorisSQLParserTIME, DorisSQLParserTINYINT, DorisSQLParserUNSIGNED, DorisSQLParserVARBINARY, DorisSQLParserVARCHAR: + case StarRocksSQLParserBIGINT, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP, StarRocksSQLParserBOOLEAN, StarRocksSQLParserCHAR, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDOUBLE, StarRocksSQLParserFLOAT, StarRocksSQLParserHLL, StarRocksSQLParserINT, StarRocksSQLParserINTEGER, StarRocksSQLParserJSON, StarRocksSQLParserLARGEINT, StarRocksSQLParserPERCENTILE, StarRocksSQLParserSIGNED, StarRocksSQLParserSMALLINT, StarRocksSQLParserSTRING, StarRocksSQLParserTEXT, StarRocksSQLParserTIME, StarRocksSQLParserTINYINT, StarRocksSQLParserUNSIGNED, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARCHAR: p.EnterOuterAlt(localctx, 1) { p.SetState(8366) p.BaseType() } - case DorisSQLParserDECIMAL, DorisSQLParserDECIMALV2, DorisSQLParserDECIMAL32, DorisSQLParserDECIMAL64, DorisSQLParserDECIMAL128, DorisSQLParserNUMBER, DorisSQLParserNUMERIC: + case StarRocksSQLParserDECIMAL, StarRocksSQLParserDECIMALV2, StarRocksSQLParserDECIMAL32, StarRocksSQLParserDECIMAL64, StarRocksSQLParserDECIMAL128, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC: p.EnterOuterAlt(localctx, 2) { p.SetState(8367) p.DecimalType() } - case DorisSQLParserARRAY: + case StarRocksSQLParserARRAY: p.EnterOuterAlt(localctx, 3) { p.SetState(8368) p.ArrayType() } - case DorisSQLParserSTRUCT: + case StarRocksSQLParserSTRUCT: p.EnterOuterAlt(localctx, 4) { p.SetState(8369) p.StructType() } - case DorisSQLParserMAP: + case StarRocksSQLParserMAP: p.EnterOuterAlt(localctx, 5) { p.SetState(8370) @@ -144438,13 +144438,13 @@ type ArrayTypeContext struct { func NewEmptyArrayTypeContext() *ArrayTypeContext { var p = new(ArrayTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_arrayType + p.RuleIndex = StarRocksSQLParserRULE_arrayType return p } func InitEmptyArrayTypeContext(p *ArrayTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_arrayType + p.RuleIndex = StarRocksSQLParserRULE_arrayType } func (*ArrayTypeContext) IsArrayTypeContext() {} @@ -144455,7 +144455,7 @@ func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_arrayType + p.RuleIndex = StarRocksSQLParserRULE_arrayType return p } @@ -144463,11 +144463,11 @@ func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, in func (s *ArrayTypeContext) GetParser() antlr.Parser { return s.parser } func (s *ArrayTypeContext) ARRAY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY, 0) + return s.GetToken(StarRocksSQLParserARRAY, 0) } func (s *ArrayTypeContext) LT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLT, 0) + return s.GetToken(StarRocksSQLParserLT, 0) } func (s *ArrayTypeContext) Type_() ITypeContext { @@ -144487,7 +144487,7 @@ func (s *ArrayTypeContext) Type_() ITypeContext { } func (s *ArrayTypeContext) GT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGT, 0) + return s.GetToken(StarRocksSQLParserGT, 0) } func (s *ArrayTypeContext) GetRuleContext() antlr.RuleContext { @@ -144499,20 +144499,20 @@ func (s *ArrayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *ArrayTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterArrayType(s) } } func (s *ArrayTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitArrayType(s) } } func (s *ArrayTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitArrayType(s) default: @@ -144520,13 +144520,13 @@ func (s *ArrayTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) ArrayType() (localctx IArrayTypeContext) { +func (p *StarRocksSQLParser) ArrayType() (localctx IArrayTypeContext) { localctx = NewArrayTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1050, DorisSQLParserRULE_arrayType) + p.EnterRule(localctx, 1050, StarRocksSQLParserRULE_arrayType) p.EnterOuterAlt(localctx, 1) { p.SetState(8373) - p.Match(DorisSQLParserARRAY) + p.Match(StarRocksSQLParserARRAY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144534,7 +144534,7 @@ func (p *DorisSQLParser) ArrayType() (localctx IArrayTypeContext) { } { p.SetState(8374) - p.Match(DorisSQLParserLT) + p.Match(StarRocksSQLParserLT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144546,7 +144546,7 @@ func (p *DorisSQLParser) ArrayType() (localctx IArrayTypeContext) { } { p.SetState(8376) - p.Match(DorisSQLParserGT) + p.Match(StarRocksSQLParserGT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144592,13 +144592,13 @@ type MapTypeContext struct { func NewEmptyMapTypeContext() *MapTypeContext { var p = new(MapTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mapType + p.RuleIndex = StarRocksSQLParserRULE_mapType return p } func InitEmptyMapTypeContext(p *MapTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_mapType + p.RuleIndex = StarRocksSQLParserRULE_mapType } func (*MapTypeContext) IsMapTypeContext() {} @@ -144609,7 +144609,7 @@ func NewMapTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_mapType + p.RuleIndex = StarRocksSQLParserRULE_mapType return p } @@ -144617,11 +144617,11 @@ func NewMapTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invo func (s *MapTypeContext) GetParser() antlr.Parser { return s.parser } func (s *MapTypeContext) MAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAP, 0) + return s.GetToken(StarRocksSQLParserMAP, 0) } func (s *MapTypeContext) LT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLT, 0) + return s.GetToken(StarRocksSQLParserLT, 0) } func (s *MapTypeContext) AllType_() []ITypeContext { @@ -144666,7 +144666,7 @@ func (s *MapTypeContext) Type_(i int) ITypeContext { } func (s *MapTypeContext) GT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGT, 0) + return s.GetToken(StarRocksSQLParserGT, 0) } func (s *MapTypeContext) GetRuleContext() antlr.RuleContext { @@ -144678,20 +144678,20 @@ func (s *MapTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer } func (s *MapTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterMapType(s) } } func (s *MapTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitMapType(s) } } func (s *MapTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitMapType(s) default: @@ -144699,13 +144699,13 @@ func (s *MapTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) MapType() (localctx IMapTypeContext) { +func (p *StarRocksSQLParser) MapType() (localctx IMapTypeContext) { localctx = NewMapTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1052, DorisSQLParserRULE_mapType) + p.EnterRule(localctx, 1052, StarRocksSQLParserRULE_mapType) p.EnterOuterAlt(localctx, 1) { p.SetState(8378) - p.Match(DorisSQLParserMAP) + p.Match(StarRocksSQLParserMAP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144713,7 +144713,7 @@ func (p *DorisSQLParser) MapType() (localctx IMapTypeContext) { } { p.SetState(8379) - p.Match(DorisSQLParserLT) + p.Match(StarRocksSQLParserLT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144725,7 +144725,7 @@ func (p *DorisSQLParser) MapType() (localctx IMapTypeContext) { } { p.SetState(8381) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144737,7 +144737,7 @@ func (p *DorisSQLParser) MapType() (localctx IMapTypeContext) { } { p.SetState(8383) - p.Match(DorisSQLParserGT) + p.Match(StarRocksSQLParserGT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -144781,13 +144781,13 @@ type SubfieldDescContext struct { func NewEmptySubfieldDescContext() *SubfieldDescContext { var p = new(SubfieldDescContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subfieldDesc + p.RuleIndex = StarRocksSQLParserRULE_subfieldDesc return p } func InitEmptySubfieldDescContext(p *SubfieldDescContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subfieldDesc + p.RuleIndex = StarRocksSQLParserRULE_subfieldDesc } func (*SubfieldDescContext) IsSubfieldDescContext() {} @@ -144798,7 +144798,7 @@ func NewSubfieldDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_subfieldDesc + p.RuleIndex = StarRocksSQLParserRULE_subfieldDesc return p } @@ -144862,20 +144862,20 @@ func (s *SubfieldDescContext) ToStringTree(ruleNames []string, recog antlr.Recog } func (s *SubfieldDescContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubfieldDesc(s) } } func (s *SubfieldDescContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubfieldDesc(s) } } func (s *SubfieldDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubfieldDesc(s) default: @@ -144883,9 +144883,9 @@ func (s *SubfieldDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) SubfieldDesc() (localctx ISubfieldDescContext) { +func (p *StarRocksSQLParser) SubfieldDesc() (localctx ISubfieldDescContext) { localctx = NewSubfieldDescContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1054, DorisSQLParserRULE_subfieldDesc) + p.EnterRule(localctx, 1054, StarRocksSQLParserRULE_subfieldDesc) p.EnterOuterAlt(localctx, 1) p.SetState(8387) p.GetErrorHandler().Sync(p) @@ -144950,13 +144950,13 @@ type SubfieldDescsContext struct { func NewEmptySubfieldDescsContext() *SubfieldDescsContext { var p = new(SubfieldDescsContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subfieldDescs + p.RuleIndex = StarRocksSQLParserRULE_subfieldDescs return p } func InitEmptySubfieldDescsContext(p *SubfieldDescsContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_subfieldDescs + p.RuleIndex = StarRocksSQLParserRULE_subfieldDescs } func (*SubfieldDescsContext) IsSubfieldDescsContext() {} @@ -144967,7 +144967,7 @@ func NewSubfieldDescsContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_subfieldDescs + p.RuleIndex = StarRocksSQLParserRULE_subfieldDescs return p } @@ -145024,20 +145024,20 @@ func (s *SubfieldDescsContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *SubfieldDescsContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterSubfieldDescs(s) } } func (s *SubfieldDescsContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitSubfieldDescs(s) } } func (s *SubfieldDescsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitSubfieldDescs(s) default: @@ -145045,9 +145045,9 @@ func (s *SubfieldDescsContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) SubfieldDescs() (localctx ISubfieldDescsContext) { +func (p *StarRocksSQLParser) SubfieldDescs() (localctx ISubfieldDescsContext) { localctx = NewSubfieldDescsContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1056, DorisSQLParserRULE_subfieldDescs) + p.EnterRule(localctx, 1056, StarRocksSQLParserRULE_subfieldDescs) var _la int p.EnterOuterAlt(localctx, 1) @@ -145062,10 +145062,10 @@ func (p *DorisSQLParser) SubfieldDescs() (localctx ISubfieldDescsContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8392) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145122,13 +145122,13 @@ type StructTypeContext struct { func NewEmptyStructTypeContext() *StructTypeContext { var p = new(StructTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_structType + p.RuleIndex = StarRocksSQLParserRULE_structType return p } func InitEmptyStructTypeContext(p *StructTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_structType + p.RuleIndex = StarRocksSQLParserRULE_structType } func (*StructTypeContext) IsStructTypeContext() {} @@ -145139,7 +145139,7 @@ func NewStructTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_structType + p.RuleIndex = StarRocksSQLParserRULE_structType return p } @@ -145147,11 +145147,11 @@ func NewStructTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, i func (s *StructTypeContext) GetParser() antlr.Parser { return s.parser } func (s *StructTypeContext) STRUCT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTRUCT, 0) + return s.GetToken(StarRocksSQLParserSTRUCT, 0) } func (s *StructTypeContext) LT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLT, 0) + return s.GetToken(StarRocksSQLParserLT, 0) } func (s *StructTypeContext) SubfieldDescs() ISubfieldDescsContext { @@ -145171,7 +145171,7 @@ func (s *StructTypeContext) SubfieldDescs() ISubfieldDescsContext { } func (s *StructTypeContext) GT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGT, 0) + return s.GetToken(StarRocksSQLParserGT, 0) } func (s *StructTypeContext) GetRuleContext() antlr.RuleContext { @@ -145183,20 +145183,20 @@ func (s *StructTypeContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *StructTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterStructType(s) } } func (s *StructTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitStructType(s) } } func (s *StructTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitStructType(s) default: @@ -145204,13 +145204,13 @@ func (s *StructTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) StructType() (localctx IStructTypeContext) { +func (p *StarRocksSQLParser) StructType() (localctx IStructTypeContext) { localctx = NewStructTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1058, DorisSQLParserRULE_structType) + p.EnterRule(localctx, 1058, StarRocksSQLParserRULE_structType) p.EnterOuterAlt(localctx, 1) { p.SetState(8399) - p.Match(DorisSQLParserSTRUCT) + p.Match(StarRocksSQLParserSTRUCT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145218,7 +145218,7 @@ func (p *DorisSQLParser) StructType() (localctx IStructTypeContext) { } { p.SetState(8400) - p.Match(DorisSQLParserLT) + p.Match(StarRocksSQLParserLT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145230,7 +145230,7 @@ func (p *DorisSQLParser) StructType() (localctx IStructTypeContext) { } { p.SetState(8402) - p.Match(DorisSQLParserGT) + p.Match(StarRocksSQLParserGT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145272,13 +145272,13 @@ type TypeParameterContext struct { func NewEmptyTypeParameterContext() *TypeParameterContext { var p = new(TypeParameterContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeParameter + p.RuleIndex = StarRocksSQLParserRULE_typeParameter return p } func InitEmptyTypeParameterContext(p *TypeParameterContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_typeParameter + p.RuleIndex = StarRocksSQLParserRULE_typeParameter } func (*TypeParameterContext) IsTypeParameterContext() {} @@ -145289,7 +145289,7 @@ func NewTypeParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_typeParameter + p.RuleIndex = StarRocksSQLParserRULE_typeParameter return p } @@ -145297,7 +145297,7 @@ func NewTypeParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext func (s *TypeParameterContext) GetParser() antlr.Parser { return s.parser } func (s *TypeParameterContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *TypeParameterContext) GetRuleContext() antlr.RuleContext { @@ -145309,20 +145309,20 @@ func (s *TypeParameterContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *TypeParameterContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTypeParameter(s) } } func (s *TypeParameterContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTypeParameter(s) } } func (s *TypeParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTypeParameter(s) default: @@ -145330,13 +145330,13 @@ func (s *TypeParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) TypeParameter() (localctx ITypeParameterContext) { +func (p *StarRocksSQLParser) TypeParameter() (localctx ITypeParameterContext) { localctx = NewTypeParameterContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1060, DorisSQLParserRULE_typeParameter) + p.EnterRule(localctx, 1060, StarRocksSQLParserRULE_typeParameter) p.EnterOuterAlt(localctx, 1) { p.SetState(8404) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145344,7 +145344,7 @@ func (p *DorisSQLParser) TypeParameter() (localctx ITypeParameterContext) { } { p.SetState(8405) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145352,7 +145352,7 @@ func (p *DorisSQLParser) TypeParameter() (localctx ITypeParameterContext) { } { p.SetState(8406) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145418,13 +145418,13 @@ type BaseTypeContext struct { func NewEmptyBaseTypeContext() *BaseTypeContext { var p = new(BaseTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_baseType + p.RuleIndex = StarRocksSQLParserRULE_baseType return p } func InitEmptyBaseTypeContext(p *BaseTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_baseType + p.RuleIndex = StarRocksSQLParserRULE_baseType } func (*BaseTypeContext) IsBaseTypeContext() {} @@ -145435,7 +145435,7 @@ func NewBaseTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_baseType + p.RuleIndex = StarRocksSQLParserRULE_baseType return p } @@ -145443,11 +145443,11 @@ func NewBaseTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, inv func (s *BaseTypeContext) GetParser() antlr.Parser { return s.parser } func (s *BaseTypeContext) BOOLEAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBOOLEAN, 0) + return s.GetToken(StarRocksSQLParserBOOLEAN, 0) } func (s *BaseTypeContext) TINYINT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTINYINT, 0) + return s.GetToken(StarRocksSQLParserTINYINT, 0) } func (s *BaseTypeContext) TypeParameter() ITypeParameterContext { @@ -145467,91 +145467,91 @@ func (s *BaseTypeContext) TypeParameter() ITypeParameterContext { } func (s *BaseTypeContext) SMALLINT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSMALLINT, 0) + return s.GetToken(StarRocksSQLParserSMALLINT, 0) } func (s *BaseTypeContext) SIGNED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSIGNED, 0) + return s.GetToken(StarRocksSQLParserSIGNED, 0) } func (s *BaseTypeContext) INT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINT, 0) + return s.GetToken(StarRocksSQLParserINT, 0) } func (s *BaseTypeContext) INTEGER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER, 0) + return s.GetToken(StarRocksSQLParserINTEGER, 0) } func (s *BaseTypeContext) UNSIGNED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNSIGNED, 0) + return s.GetToken(StarRocksSQLParserUNSIGNED, 0) } func (s *BaseTypeContext) BIGINT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBIGINT, 0) + return s.GetToken(StarRocksSQLParserBIGINT, 0) } func (s *BaseTypeContext) LARGEINT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLARGEINT, 0) + return s.GetToken(StarRocksSQLParserLARGEINT, 0) } func (s *BaseTypeContext) FLOAT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFLOAT, 0) + return s.GetToken(StarRocksSQLParserFLOAT, 0) } func (s *BaseTypeContext) DOUBLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOUBLE, 0) + return s.GetToken(StarRocksSQLParserDOUBLE, 0) } func (s *BaseTypeContext) DATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATE, 0) + return s.GetToken(StarRocksSQLParserDATE, 0) } func (s *BaseTypeContext) DATETIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATETIME, 0) + return s.GetToken(StarRocksSQLParserDATETIME, 0) } func (s *BaseTypeContext) TIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIME, 0) + return s.GetToken(StarRocksSQLParserTIME, 0) } func (s *BaseTypeContext) CHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAR, 0) + return s.GetToken(StarRocksSQLParserCHAR, 0) } func (s *BaseTypeContext) VARCHAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVARCHAR, 0) + return s.GetToken(StarRocksSQLParserVARCHAR, 0) } func (s *BaseTypeContext) STRING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTRING, 0) + return s.GetToken(StarRocksSQLParserSTRING, 0) } func (s *BaseTypeContext) TEXT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEXT, 0) + return s.GetToken(StarRocksSQLParserTEXT, 0) } func (s *BaseTypeContext) BITMAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITMAP, 0) + return s.GetToken(StarRocksSQLParserBITMAP, 0) } func (s *BaseTypeContext) HLL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHLL, 0) + return s.GetToken(StarRocksSQLParserHLL, 0) } func (s *BaseTypeContext) PERCENTILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERCENTILE, 0) + return s.GetToken(StarRocksSQLParserPERCENTILE, 0) } func (s *BaseTypeContext) JSON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJSON, 0) + return s.GetToken(StarRocksSQLParserJSON, 0) } func (s *BaseTypeContext) VARBINARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVARBINARY, 0) + return s.GetToken(StarRocksSQLParserVARBINARY, 0) } func (s *BaseTypeContext) BINARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBINARY, 0) + return s.GetToken(StarRocksSQLParserBINARY, 0) } func (s *BaseTypeContext) GetRuleContext() antlr.RuleContext { @@ -145563,20 +145563,20 @@ func (s *BaseTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognize } func (s *BaseTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBaseType(s) } } func (s *BaseTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBaseType(s) } } func (s *BaseTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBaseType(s) default: @@ -145584,9 +145584,9 @@ func (s *BaseTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { +func (p *StarRocksSQLParser) BaseType() (localctx IBaseTypeContext) { localctx = NewBaseTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1062, DorisSQLParserRULE_baseType) + p.EnterRule(localctx, 1062, StarRocksSQLParserRULE_baseType) var _la int p.SetState(8476) @@ -145600,7 +145600,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 1) { p.SetState(8408) - p.Match(DorisSQLParserBOOLEAN) + p.Match(StarRocksSQLParserBOOLEAN) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145611,7 +145611,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 2) { p.SetState(8409) - p.Match(DorisSQLParserTINYINT) + p.Match(StarRocksSQLParserTINYINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145624,7 +145624,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8410) p.TypeParameter() @@ -145636,7 +145636,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 3) { p.SetState(8413) - p.Match(DorisSQLParserSMALLINT) + p.Match(StarRocksSQLParserSMALLINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145649,7 +145649,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8414) p.TypeParameter() @@ -145661,7 +145661,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 4) { p.SetState(8417) - p.Match(DorisSQLParserSIGNED) + p.Match(StarRocksSQLParserSIGNED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145674,10 +145674,10 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINT { + if _la == StarRocksSQLParserINT { { p.SetState(8418) - p.Match(DorisSQLParserINT) + p.Match(StarRocksSQLParserINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145690,7 +145690,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 5) { p.SetState(8421) - p.Match(DorisSQLParserSIGNED) + p.Match(StarRocksSQLParserSIGNED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145703,10 +145703,10 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTEGER { + if _la == StarRocksSQLParserINTEGER { { p.SetState(8422) - p.Match(DorisSQLParserINTEGER) + p.Match(StarRocksSQLParserINTEGER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145719,7 +145719,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 6) { p.SetState(8425) - p.Match(DorisSQLParserUNSIGNED) + p.Match(StarRocksSQLParserUNSIGNED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145732,10 +145732,10 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINT { + if _la == StarRocksSQLParserINT { { p.SetState(8426) - p.Match(DorisSQLParserINT) + p.Match(StarRocksSQLParserINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145748,7 +145748,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 7) { p.SetState(8429) - p.Match(DorisSQLParserUNSIGNED) + p.Match(StarRocksSQLParserUNSIGNED) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145761,10 +145761,10 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserINTEGER { + if _la == StarRocksSQLParserINTEGER { { p.SetState(8430) - p.Match(DorisSQLParserINTEGER) + p.Match(StarRocksSQLParserINTEGER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145777,7 +145777,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 8) { p.SetState(8433) - p.Match(DorisSQLParserINT) + p.Match(StarRocksSQLParserINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145790,7 +145790,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8434) p.TypeParameter() @@ -145802,7 +145802,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 9) { p.SetState(8437) - p.Match(DorisSQLParserINTEGER) + p.Match(StarRocksSQLParserINTEGER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145815,7 +145815,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8438) p.TypeParameter() @@ -145827,7 +145827,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 10) { p.SetState(8441) - p.Match(DorisSQLParserBIGINT) + p.Match(StarRocksSQLParserBIGINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145840,7 +145840,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8442) p.TypeParameter() @@ -145852,7 +145852,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 11) { p.SetState(8445) - p.Match(DorisSQLParserLARGEINT) + p.Match(StarRocksSQLParserLARGEINT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145865,7 +145865,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8446) p.TypeParameter() @@ -145877,7 +145877,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 12) { p.SetState(8449) - p.Match(DorisSQLParserFLOAT) + p.Match(StarRocksSQLParserFLOAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145888,7 +145888,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 13) { p.SetState(8450) - p.Match(DorisSQLParserDOUBLE) + p.Match(StarRocksSQLParserDOUBLE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145899,7 +145899,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 14) { p.SetState(8451) - p.Match(DorisSQLParserDATE) + p.Match(StarRocksSQLParserDATE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145910,7 +145910,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 15) { p.SetState(8452) - p.Match(DorisSQLParserDATETIME) + p.Match(StarRocksSQLParserDATETIME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145921,7 +145921,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 16) { p.SetState(8453) - p.Match(DorisSQLParserTIME) + p.Match(StarRocksSQLParserTIME) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145932,7 +145932,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 17) { p.SetState(8454) - p.Match(DorisSQLParserCHAR) + p.Match(StarRocksSQLParserCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145945,7 +145945,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8455) p.TypeParameter() @@ -145957,7 +145957,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 18) { p.SetState(8458) - p.Match(DorisSQLParserVARCHAR) + p.Match(StarRocksSQLParserVARCHAR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145970,7 +145970,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8459) p.TypeParameter() @@ -145982,7 +145982,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 19) { p.SetState(8462) - p.Match(DorisSQLParserSTRING) + p.Match(StarRocksSQLParserSTRING) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -145993,7 +145993,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 20) { p.SetState(8463) - p.Match(DorisSQLParserTEXT) + p.Match(StarRocksSQLParserTEXT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146004,7 +146004,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 21) { p.SetState(8464) - p.Match(DorisSQLParserBITMAP) + p.Match(StarRocksSQLParserBITMAP) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146015,7 +146015,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 22) { p.SetState(8465) - p.Match(DorisSQLParserHLL) + p.Match(StarRocksSQLParserHLL) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146026,7 +146026,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 23) { p.SetState(8466) - p.Match(DorisSQLParserPERCENTILE) + p.Match(StarRocksSQLParserPERCENTILE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146037,7 +146037,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 24) { p.SetState(8467) - p.Match(DorisSQLParserJSON) + p.Match(StarRocksSQLParserJSON) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146048,7 +146048,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 25) { p.SetState(8468) - p.Match(DorisSQLParserVARBINARY) + p.Match(StarRocksSQLParserVARBINARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146061,7 +146061,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8469) p.TypeParameter() @@ -146073,7 +146073,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { p.EnterOuterAlt(localctx, 26) { p.SetState(8472) - p.Match(DorisSQLParserBINARY) + p.Match(StarRocksSQLParserBINARY) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146086,7 +146086,7 @@ func (p *DorisSQLParser) BaseType() (localctx IBaseTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8473) p.TypeParameter() @@ -146155,13 +146155,13 @@ type DecimalTypeContext struct { func NewEmptyDecimalTypeContext() *DecimalTypeContext { var p = new(DecimalTypeContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_decimalType + p.RuleIndex = StarRocksSQLParserRULE_decimalType return p } func InitEmptyDecimalTypeContext(p *DecimalTypeContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_decimalType + p.RuleIndex = StarRocksSQLParserRULE_decimalType } func (*DecimalTypeContext) IsDecimalTypeContext() {} @@ -146172,7 +146172,7 @@ func NewDecimalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_decimalType + p.RuleIndex = StarRocksSQLParserRULE_decimalType return p } @@ -146188,39 +146188,39 @@ func (s *DecimalTypeContext) SetPrecision(v antlr.Token) { s.precision = v } func (s *DecimalTypeContext) SetScale(v antlr.Token) { s.scale = v } func (s *DecimalTypeContext) DECIMAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMAL, 0) + return s.GetToken(StarRocksSQLParserDECIMAL, 0) } func (s *DecimalTypeContext) DECIMALV2() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMALV2, 0) + return s.GetToken(StarRocksSQLParserDECIMALV2, 0) } func (s *DecimalTypeContext) DECIMAL32() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMAL32, 0) + return s.GetToken(StarRocksSQLParserDECIMAL32, 0) } func (s *DecimalTypeContext) DECIMAL64() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMAL64, 0) + return s.GetToken(StarRocksSQLParserDECIMAL64, 0) } func (s *DecimalTypeContext) DECIMAL128() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMAL128, 0) + return s.GetToken(StarRocksSQLParserDECIMAL128, 0) } func (s *DecimalTypeContext) NUMERIC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNUMERIC, 0) + return s.GetToken(StarRocksSQLParserNUMERIC, 0) } func (s *DecimalTypeContext) NUMBER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNUMBER, 0) + return s.GetToken(StarRocksSQLParserNUMBER, 0) } func (s *DecimalTypeContext) AllINTEGER_VALUE() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserINTEGER_VALUE) + return s.GetTokens(StarRocksSQLParserINTEGER_VALUE) } func (s *DecimalTypeContext) INTEGER_VALUE(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, i) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, i) } func (s *DecimalTypeContext) GetRuleContext() antlr.RuleContext { @@ -146232,20 +146232,20 @@ func (s *DecimalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *DecimalTypeContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDecimalType(s) } } func (s *DecimalTypeContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDecimalType(s) } } func (s *DecimalTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDecimalType(s) default: @@ -146253,9 +146253,9 @@ func (s *DecimalTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { +func (p *StarRocksSQLParser) DecimalType() (localctx IDecimalTypeContext) { localctx = NewDecimalTypeContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1064, DorisSQLParserRULE_decimalType) + p.EnterRule(localctx, 1064, StarRocksSQLParserRULE_decimalType) var _la int p.EnterOuterAlt(localctx, 1) @@ -146263,7 +146263,7 @@ func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { p.SetState(8478) _la = p.GetTokenStream().LA(1) - if !(((int64((_la-111)) & ^0x3f) == 0 && ((int64(1)<<(_la-111))&31) != 0) || _la == DorisSQLParserNUMBER || _la == DorisSQLParserNUMERIC) { + if !(((int64((_la-111)) & ^0x3f) == 0 && ((int64(1)<<(_la-111))&31) != 0) || _la == StarRocksSQLParserNUMBER || _la == StarRocksSQLParserNUMERIC) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -146277,10 +146277,10 @@ func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__1 { + if _la == StarRocksSQLParserT__1 { { p.SetState(8479) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146289,7 +146289,7 @@ func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { { p.SetState(8480) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*DecimalTypeContext).precision = _m if p.HasError() { @@ -146304,10 +146304,10 @@ func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserT__2 { + if _la == StarRocksSQLParserT__2 { { p.SetState(8481) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146316,7 +146316,7 @@ func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { { p.SetState(8482) - var _m = p.Match(DorisSQLParserINTEGER_VALUE) + var _m = p.Match(StarRocksSQLParserINTEGER_VALUE) localctx.(*DecimalTypeContext).scale = _m if p.HasError() { @@ -146328,7 +146328,7 @@ func (p *DorisSQLParser) DecimalType() (localctx IDecimalTypeContext) { } { p.SetState(8485) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146375,13 +146375,13 @@ type QualifiedNameContext struct { func NewEmptyQualifiedNameContext() *QualifiedNameContext { var p = new(QualifiedNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_qualifiedName + p.RuleIndex = StarRocksSQLParserRULE_qualifiedName return p } func InitEmptyQualifiedNameContext(p *QualifiedNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_qualifiedName + p.RuleIndex = StarRocksSQLParserRULE_qualifiedName } func (*QualifiedNameContext) IsQualifiedNameContext() {} @@ -146392,7 +146392,7 @@ func NewQualifiedNameContext(parser antlr.Parser, parent antlr.ParserRuleContext antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_qualifiedName + p.RuleIndex = StarRocksSQLParserRULE_qualifiedName return p } @@ -146441,11 +146441,11 @@ func (s *QualifiedNameContext) Identifier(i int) IIdentifierContext { } func (s *QualifiedNameContext) AllDOT_IDENTIFIER() []antlr.TerminalNode { - return s.GetTokens(DorisSQLParserDOT_IDENTIFIER) + return s.GetTokens(StarRocksSQLParserDOT_IDENTIFIER) } func (s *QualifiedNameContext) DOT_IDENTIFIER(i int) antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOT_IDENTIFIER, i) + return s.GetToken(StarRocksSQLParserDOT_IDENTIFIER, i) } func (s *QualifiedNameContext) GetRuleContext() antlr.RuleContext { @@ -146457,20 +146457,20 @@ func (s *QualifiedNameContext) ToStringTree(ruleNames []string, recog antlr.Reco } func (s *QualifiedNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterQualifiedName(s) } } func (s *QualifiedNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitQualifiedName(s) } } func (s *QualifiedNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitQualifiedName(s) default: @@ -146478,9 +146478,9 @@ func (s *QualifiedNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{ } } -func (p *DorisSQLParser) QualifiedName() (localctx IQualifiedNameContext) { +func (p *StarRocksSQLParser) QualifiedName() (localctx IQualifiedNameContext) { localctx = NewQualifiedNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1066, DorisSQLParserRULE_qualifiedName) + p.EnterRule(localctx, 1066, StarRocksSQLParserRULE_qualifiedName) var _alt int p.EnterOuterAlt(localctx, 1) @@ -146506,20 +146506,20 @@ func (p *DorisSQLParser) QualifiedName() (localctx IQualifiedNameContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDOT_IDENTIFIER: + case StarRocksSQLParserDOT_IDENTIFIER: { p.SetState(8489) - p.Match(DorisSQLParserDOT_IDENTIFIER) + p.Match(StarRocksSQLParserDOT_IDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserT__0: + case StarRocksSQLParserT__0: { p.SetState(8490) - p.Match(DorisSQLParserT__0) + p.Match(StarRocksSQLParserT__0) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146582,13 +146582,13 @@ type TableNameContext struct { func NewEmptyTableNameContext() *TableNameContext { var p = new(TableNameContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableName + p.RuleIndex = StarRocksSQLParserRULE_tableName return p } func InitEmptyTableNameContext(p *TableNameContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_tableName + p.RuleIndex = StarRocksSQLParserRULE_tableName } func (*TableNameContext) IsTableNameContext() {} @@ -146599,7 +146599,7 @@ func NewTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, in antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_tableName + p.RuleIndex = StarRocksSQLParserRULE_tableName return p } @@ -146631,20 +146631,20 @@ func (s *TableNameContext) ToStringTree(ruleNames []string, recog antlr.Recogniz } func (s *TableNameContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterTableName(s) } } func (s *TableNameContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitTableName(s) } } func (s *TableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitTableName(s) default: @@ -146652,9 +146652,9 @@ func (s *TableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) TableName() (localctx ITableNameContext) { +func (p *StarRocksSQLParser) TableName() (localctx ITableNameContext) { localctx = NewTableNameContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1068, DorisSQLParserRULE_tableName) + p.EnterRule(localctx, 1068, StarRocksSQLParserRULE_tableName) p.EnterOuterAlt(localctx, 1) { p.SetState(8497) @@ -146700,13 +146700,13 @@ type WriteBranchContext struct { func NewEmptyWriteBranchContext() *WriteBranchContext { var p = new(WriteBranchContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_writeBranch + p.RuleIndex = StarRocksSQLParserRULE_writeBranch return p } func InitEmptyWriteBranchContext(p *WriteBranchContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_writeBranch + p.RuleIndex = StarRocksSQLParserRULE_writeBranch } func (*WriteBranchContext) IsWriteBranchContext() {} @@ -146717,7 +146717,7 @@ func NewWriteBranchContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_writeBranch + p.RuleIndex = StarRocksSQLParserRULE_writeBranch return p } @@ -146725,15 +146725,15 @@ func NewWriteBranchContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *WriteBranchContext) GetParser() antlr.Parser { return s.parser } func (s *WriteBranchContext) VERSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERSION, 0) + return s.GetToken(StarRocksSQLParserVERSION, 0) } func (s *WriteBranchContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *WriteBranchContext) OF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOF, 0) + return s.GetToken(StarRocksSQLParserOF, 0) } func (s *WriteBranchContext) Identifier() IIdentifierContext { @@ -146753,7 +146753,7 @@ func (s *WriteBranchContext) Identifier() IIdentifierContext { } func (s *WriteBranchContext) FOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOR, 0) + return s.GetToken(StarRocksSQLParserFOR, 0) } func (s *WriteBranchContext) GetRuleContext() antlr.RuleContext { @@ -146765,20 +146765,20 @@ func (s *WriteBranchContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *WriteBranchContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterWriteBranch(s) } } func (s *WriteBranchContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitWriteBranch(s) } } func (s *WriteBranchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitWriteBranch(s) default: @@ -146786,9 +146786,9 @@ func (s *WriteBranchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) WriteBranch() (localctx IWriteBranchContext) { +func (p *StarRocksSQLParser) WriteBranch() (localctx IWriteBranchContext) { localctx = NewWriteBranchContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1070, DorisSQLParserRULE_writeBranch) + p.EnterRule(localctx, 1070, StarRocksSQLParserRULE_writeBranch) var _la int p.EnterOuterAlt(localctx, 1) @@ -146799,10 +146799,10 @@ func (p *DorisSQLParser) WriteBranch() (localctx IWriteBranchContext) { } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserFOR { + if _la == StarRocksSQLParserFOR { { p.SetState(8499) - p.Match(DorisSQLParserFOR) + p.Match(StarRocksSQLParserFOR) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146812,7 +146812,7 @@ func (p *DorisSQLParser) WriteBranch() (localctx IWriteBranchContext) { } { p.SetState(8502) - p.Match(DorisSQLParserVERSION) + p.Match(StarRocksSQLParserVERSION) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146820,7 +146820,7 @@ func (p *DorisSQLParser) WriteBranch() (localctx IWriteBranchContext) { } { p.SetState(8503) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146828,7 +146828,7 @@ func (p *DorisSQLParser) WriteBranch() (localctx IWriteBranchContext) { } { p.SetState(8504) - p.Match(DorisSQLParserOF) + p.Match(StarRocksSQLParserOF) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -146870,13 +146870,13 @@ type IdentifierContext struct { func NewEmptyIdentifierContext() *IdentifierContext { var p = new(IdentifierContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifier + p.RuleIndex = StarRocksSQLParserRULE_identifier return p } func InitEmptyIdentifierContext(p *IdentifierContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifier + p.RuleIndex = StarRocksSQLParserRULE_identifier } func (*IdentifierContext) IsIdentifierContext() {} @@ -146887,7 +146887,7 @@ func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifier + p.RuleIndex = StarRocksSQLParserRULE_identifier return p } @@ -146925,24 +146925,24 @@ func (s *BackQuotedIdentifierContext) GetRuleContext() antlr.RuleContext { } func (s *BackQuotedIdentifierContext) BACKQUOTED_IDENTIFIER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKQUOTED_IDENTIFIER, 0) + return s.GetToken(StarRocksSQLParserBACKQUOTED_IDENTIFIER, 0) } func (s *BackQuotedIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterBackQuotedIdentifier(s) } } func (s *BackQuotedIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitBackQuotedIdentifier(s) } } func (s *BackQuotedIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitBackQuotedIdentifier(s) default: @@ -146969,24 +146969,24 @@ func (s *DigitIdentifierContext) GetRuleContext() antlr.RuleContext { } func (s *DigitIdentifierContext) DIGIT_IDENTIFIER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDIGIT_IDENTIFIER, 0) + return s.GetToken(StarRocksSQLParserDIGIT_IDENTIFIER, 0) } func (s *DigitIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDigitIdentifier(s) } } func (s *DigitIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDigitIdentifier(s) } } func (s *DigitIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDigitIdentifier(s) default: @@ -147013,7 +147013,7 @@ func (s *UnquotedIdentifierContext) GetRuleContext() antlr.RuleContext { } func (s *UnquotedIdentifierContext) LETTER_IDENTIFIER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLETTER_IDENTIFIER, 0) + return s.GetToken(StarRocksSQLParserLETTER_IDENTIFIER, 0) } func (s *UnquotedIdentifierContext) NonReserved() INonReservedContext { @@ -147033,20 +147033,20 @@ func (s *UnquotedIdentifierContext) NonReserved() INonReservedContext { } func (s *UnquotedIdentifierContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUnquotedIdentifier(s) } } func (s *UnquotedIdentifierContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUnquotedIdentifier(s) } } func (s *UnquotedIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUnquotedIdentifier(s) default: @@ -147054,9 +147054,9 @@ func (s *UnquotedIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) Identifier() (localctx IIdentifierContext) { +func (p *StarRocksSQLParser) Identifier() (localctx IIdentifierContext) { localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1072, DorisSQLParserRULE_identifier) + p.EnterRule(localctx, 1072, StarRocksSQLParserRULE_identifier) p.SetState(8511) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -147064,19 +147064,19 @@ func (p *DorisSQLParser) Identifier() (localctx IIdentifierContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserLETTER_IDENTIFIER: + case StarRocksSQLParserLETTER_IDENTIFIER: localctx = NewUnquotedIdentifierContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(8507) - p.Match(DorisSQLParserLETTER_IDENTIFIER) + p.Match(StarRocksSQLParserLETTER_IDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserDOTDOTDOT: localctx = NewUnquotedIdentifierContext(p, localctx) p.EnterOuterAlt(localctx, 2) { @@ -147084,24 +147084,24 @@ func (p *DorisSQLParser) Identifier() (localctx IIdentifierContext) { p.NonReserved() } - case DorisSQLParserDIGIT_IDENTIFIER: + case StarRocksSQLParserDIGIT_IDENTIFIER: localctx = NewDigitIdentifierContext(p, localctx) p.EnterOuterAlt(localctx, 3) { p.SetState(8509) - p.Match(DorisSQLParserDIGIT_IDENTIFIER) + p.Match(StarRocksSQLParserDIGIT_IDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserBACKQUOTED_IDENTIFIER: + case StarRocksSQLParserBACKQUOTED_IDENTIFIER: localctx = NewBackQuotedIdentifierContext(p, localctx) p.EnterOuterAlt(localctx, 4) { p.SetState(8510) - p.Match(DorisSQLParserBACKQUOTED_IDENTIFIER) + p.Match(StarRocksSQLParserBACKQUOTED_IDENTIFIER) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147164,13 +147164,13 @@ type IdentifierWithAliasContext struct { func NewEmptyIdentifierWithAliasContext() *IdentifierWithAliasContext { var p = new(IdentifierWithAliasContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierWithAlias + p.RuleIndex = StarRocksSQLParserRULE_identifierWithAlias return p } func InitEmptyIdentifierWithAliasContext(p *IdentifierWithAliasContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierWithAlias + p.RuleIndex = StarRocksSQLParserRULE_identifierWithAlias } func (*IdentifierWithAliasContext) IsIdentifierWithAliasContext() {} @@ -147181,7 +147181,7 @@ func NewIdentifierWithAliasContext(parser antlr.Parser, parent antlr.ParserRuleC antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifierWithAlias + p.RuleIndex = StarRocksSQLParserRULE_identifierWithAlias return p } @@ -147238,7 +147238,7 @@ func (s *IdentifierWithAliasContext) Identifier(i int) IIdentifierContext { } func (s *IdentifierWithAliasContext) AS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAS, 0) + return s.GetToken(StarRocksSQLParserAS, 0) } func (s *IdentifierWithAliasContext) GetRuleContext() antlr.RuleContext { @@ -147250,20 +147250,20 @@ func (s *IdentifierWithAliasContext) ToStringTree(ruleNames []string, recog antl } func (s *IdentifierWithAliasContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIdentifierWithAlias(s) } } func (s *IdentifierWithAliasContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIdentifierWithAlias(s) } } func (s *IdentifierWithAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIdentifierWithAlias(s) default: @@ -147271,9 +147271,9 @@ func (s *IdentifierWithAliasContext) Accept(visitor antlr.ParseTreeVisitor) inte } } -func (p *DorisSQLParser) IdentifierWithAlias() (localctx IIdentifierWithAliasContext) { +func (p *StarRocksSQLParser) IdentifierWithAlias() (localctx IIdentifierWithAliasContext) { localctx = NewIdentifierWithAliasContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1074, DorisSQLParserRULE_identifierWithAlias) + p.EnterRule(localctx, 1074, StarRocksSQLParserRULE_identifierWithAlias) var _la int p.EnterOuterAlt(localctx, 1) @@ -147291,10 +147291,10 @@ func (p *DorisSQLParser) IdentifierWithAlias() (localctx IIdentifierWithAliasCon } _la = p.GetTokenStream().LA(1) - if _la == DorisSQLParserAS { + if _la == StarRocksSQLParserAS { { p.SetState(8514) - p.Match(DorisSQLParserAS) + p.Match(StarRocksSQLParserAS) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147346,13 +147346,13 @@ type IdentifierWithAliasListContext struct { func NewEmptyIdentifierWithAliasListContext() *IdentifierWithAliasListContext { var p = new(IdentifierWithAliasListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierWithAliasList + p.RuleIndex = StarRocksSQLParserRULE_identifierWithAliasList return p } func InitEmptyIdentifierWithAliasListContext(p *IdentifierWithAliasListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierWithAliasList + p.RuleIndex = StarRocksSQLParserRULE_identifierWithAliasList } func (*IdentifierWithAliasListContext) IsIdentifierWithAliasListContext() {} @@ -147363,7 +147363,7 @@ func NewIdentifierWithAliasListContext(parser antlr.Parser, parent antlr.ParserR antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifierWithAliasList + p.RuleIndex = StarRocksSQLParserRULE_identifierWithAliasList return p } @@ -147420,20 +147420,20 @@ func (s *IdentifierWithAliasListContext) ToStringTree(ruleNames []string, recog } func (s *IdentifierWithAliasListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIdentifierWithAliasList(s) } } func (s *IdentifierWithAliasListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIdentifierWithAliasList(s) } } func (s *IdentifierWithAliasListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIdentifierWithAliasList(s) default: @@ -147441,15 +147441,15 @@ func (s *IdentifierWithAliasListContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) IdentifierWithAliasList() (localctx IIdentifierWithAliasListContext) { +func (p *StarRocksSQLParser) IdentifierWithAliasList() (localctx IIdentifierWithAliasListContext) { localctx = NewIdentifierWithAliasListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1076, DorisSQLParserRULE_identifierWithAliasList) + p.EnterRule(localctx, 1076, StarRocksSQLParserRULE_identifierWithAliasList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8518) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147466,10 +147466,10 @@ func (p *DorisSQLParser) IdentifierWithAliasList() (localctx IIdentifierWithAlia } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8520) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147489,7 +147489,7 @@ func (p *DorisSQLParser) IdentifierWithAliasList() (localctx IIdentifierWithAlia } { p.SetState(8527) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147532,13 +147532,13 @@ type IdentifierListContext struct { func NewEmptyIdentifierListContext() *IdentifierListContext { var p = new(IdentifierListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierList + p.RuleIndex = StarRocksSQLParserRULE_identifierList return p } func InitEmptyIdentifierListContext(p *IdentifierListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierList + p.RuleIndex = StarRocksSQLParserRULE_identifierList } func (*IdentifierListContext) IsIdentifierListContext() {} @@ -147549,7 +147549,7 @@ func NewIdentifierListContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifierList + p.RuleIndex = StarRocksSQLParserRULE_identifierList return p } @@ -147606,20 +147606,20 @@ func (s *IdentifierListContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *IdentifierListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIdentifierList(s) } } func (s *IdentifierListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIdentifierList(s) } } func (s *IdentifierListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIdentifierList(s) default: @@ -147627,15 +147627,15 @@ func (s *IdentifierListContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) IdentifierList() (localctx IIdentifierListContext) { +func (p *StarRocksSQLParser) IdentifierList() (localctx IIdentifierListContext) { localctx = NewIdentifierListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1078, DorisSQLParserRULE_identifierList) + p.EnterRule(localctx, 1078, StarRocksSQLParserRULE_identifierList) var _la int p.EnterOuterAlt(localctx, 1) { p.SetState(8529) - p.Match(DorisSQLParserT__1) + p.Match(StarRocksSQLParserT__1) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147652,10 +147652,10 @@ func (p *DorisSQLParser) IdentifierList() (localctx IIdentifierListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8531) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147675,7 +147675,7 @@ func (p *DorisSQLParser) IdentifierList() (localctx IIdentifierListContext) { } { p.SetState(8538) - p.Match(DorisSQLParserT__3) + p.Match(StarRocksSQLParserT__3) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -147718,13 +147718,13 @@ type IdentifierOrStringContext struct { func NewEmptyIdentifierOrStringContext() *IdentifierOrStringContext { var p = new(IdentifierOrStringContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierOrString + p.RuleIndex = StarRocksSQLParserRULE_identifierOrString return p } func InitEmptyIdentifierOrStringContext(p *IdentifierOrStringContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierOrString + p.RuleIndex = StarRocksSQLParserRULE_identifierOrString } func (*IdentifierOrStringContext) IsIdentifierOrStringContext() {} @@ -147735,7 +147735,7 @@ func NewIdentifierOrStringContext(parser antlr.Parser, parent antlr.ParserRuleCo antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifierOrString + p.RuleIndex = StarRocksSQLParserRULE_identifierOrString return p } @@ -147783,20 +147783,20 @@ func (s *IdentifierOrStringContext) ToStringTree(ruleNames []string, recog antlr } func (s *IdentifierOrStringContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIdentifierOrString(s) } } func (s *IdentifierOrStringContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIdentifierOrString(s) } } func (s *IdentifierOrStringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIdentifierOrString(s) default: @@ -147804,9 +147804,9 @@ func (s *IdentifierOrStringContext) Accept(visitor antlr.ParseTreeVisitor) inter } } -func (p *DorisSQLParser) IdentifierOrString() (localctx IIdentifierOrStringContext) { +func (p *StarRocksSQLParser) IdentifierOrString() (localctx IIdentifierOrStringContext) { localctx = NewIdentifierOrStringContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1080, DorisSQLParserRULE_identifierOrString) + p.EnterRule(localctx, 1080, StarRocksSQLParserRULE_identifierOrString) p.SetState(8542) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -147814,14 +147814,14 @@ func (p *DorisSQLParser) IdentifierOrString() (localctx IIdentifierOrStringConte } switch p.GetTokenStream().LA(1) { - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: p.EnterOuterAlt(localctx, 1) { p.SetState(8540) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: p.EnterOuterAlt(localctx, 2) { p.SetState(8541) @@ -147869,13 +147869,13 @@ type IdentifierOrStringListContext struct { func NewEmptyIdentifierOrStringListContext() *IdentifierOrStringListContext { var p = new(IdentifierOrStringListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierOrStringList + p.RuleIndex = StarRocksSQLParserRULE_identifierOrStringList return p } func InitEmptyIdentifierOrStringListContext(p *IdentifierOrStringListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierOrStringList + p.RuleIndex = StarRocksSQLParserRULE_identifierOrStringList } func (*IdentifierOrStringListContext) IsIdentifierOrStringListContext() {} @@ -147886,7 +147886,7 @@ func NewIdentifierOrStringListContext(parser antlr.Parser, parent antlr.ParserRu antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifierOrStringList + p.RuleIndex = StarRocksSQLParserRULE_identifierOrStringList return p } @@ -147943,20 +147943,20 @@ func (s *IdentifierOrStringListContext) ToStringTree(ruleNames []string, recog a } func (s *IdentifierOrStringListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIdentifierOrStringList(s) } } func (s *IdentifierOrStringListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIdentifierOrStringList(s) } } func (s *IdentifierOrStringListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIdentifierOrStringList(s) default: @@ -147964,9 +147964,9 @@ func (s *IdentifierOrStringListContext) Accept(visitor antlr.ParseTreeVisitor) i } } -func (p *DorisSQLParser) IdentifierOrStringList() (localctx IIdentifierOrStringListContext) { +func (p *StarRocksSQLParser) IdentifierOrStringList() (localctx IIdentifierOrStringListContext) { localctx = NewIdentifierOrStringListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1082, DorisSQLParserRULE_identifierOrStringList) + p.EnterRule(localctx, 1082, StarRocksSQLParserRULE_identifierOrStringList) var _la int p.EnterOuterAlt(localctx, 1) @@ -147981,10 +147981,10 @@ func (p *DorisSQLParser) IdentifierOrStringList() (localctx IIdentifierOrStringL } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8545) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148040,13 +148040,13 @@ type IdentifierOrStringOrStarContext struct { func NewEmptyIdentifierOrStringOrStarContext() *IdentifierOrStringOrStarContext { var p = new(IdentifierOrStringOrStarContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierOrStringOrStar + p.RuleIndex = StarRocksSQLParserRULE_identifierOrStringOrStar return p } func InitEmptyIdentifierOrStringOrStarContext(p *IdentifierOrStringOrStarContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_identifierOrStringOrStar + p.RuleIndex = StarRocksSQLParserRULE_identifierOrStringOrStar } func (*IdentifierOrStringOrStarContext) IsIdentifierOrStringOrStarContext() {} @@ -148057,7 +148057,7 @@ func NewIdentifierOrStringOrStarContext(parser antlr.Parser, parent antlr.Parser antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_identifierOrStringOrStar + p.RuleIndex = StarRocksSQLParserRULE_identifierOrStringOrStar return p } @@ -148065,7 +148065,7 @@ func NewIdentifierOrStringOrStarContext(parser antlr.Parser, parent antlr.Parser func (s *IdentifierOrStringOrStarContext) GetParser() antlr.Parser { return s.parser } func (s *IdentifierOrStringOrStarContext) ASTERISK_SYMBOL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASTERISK_SYMBOL, 0) + return s.GetToken(StarRocksSQLParserASTERISK_SYMBOL, 0) } func (s *IdentifierOrStringOrStarContext) Identifier() IIdentifierContext { @@ -148109,20 +148109,20 @@ func (s *IdentifierOrStringOrStarContext) ToStringTree(ruleNames []string, recog } func (s *IdentifierOrStringOrStarContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIdentifierOrStringOrStar(s) } } func (s *IdentifierOrStringOrStarContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIdentifierOrStringOrStar(s) } } func (s *IdentifierOrStringOrStarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIdentifierOrStringOrStar(s) default: @@ -148130,9 +148130,9 @@ func (s *IdentifierOrStringOrStarContext) Accept(visitor antlr.ParseTreeVisitor) } } -func (p *DorisSQLParser) IdentifierOrStringOrStar() (localctx IIdentifierOrStringOrStarContext) { +func (p *StarRocksSQLParser) IdentifierOrStringOrStar() (localctx IIdentifierOrStringOrStarContext) { localctx = NewIdentifierOrStringOrStarContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1084, DorisSQLParserRULE_identifierOrStringOrStar) + p.EnterRule(localctx, 1084, StarRocksSQLParserRULE_identifierOrStringOrStar) p.SetState(8555) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -148140,25 +148140,25 @@ func (p *DorisSQLParser) IdentifierOrStringOrStar() (localctx IIdentifierOrStrin } switch p.GetTokenStream().LA(1) { - case DorisSQLParserASTERISK_SYMBOL: + case StarRocksSQLParserASTERISK_SYMBOL: p.EnterOuterAlt(localctx, 1) { p.SetState(8552) - p.Match(DorisSQLParserASTERISK_SYMBOL) + p.Match(StarRocksSQLParserASTERISK_SYMBOL) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserACCESS, DorisSQLParserACTIVE, DorisSQLParserADMIN, DorisSQLParserADVISOR, DorisSQLParserAFTER, DorisSQLParserAGGREGATE, DorisSQLParserANTI, DorisSQLParserAPPLY, DorisSQLParserARRAY_AGG, DorisSQLParserARRAY_AGG_DISTINCT, DorisSQLParserASYNC, DorisSQLParserAUTHORS, DorisSQLParserAUTHENTICATION, DorisSQLParserAUTOMATED, DorisSQLParserAUTO_INCREMENT, DorisSQLParserAVG, DorisSQLParserBACKEND, DorisSQLParserBACKENDS, DorisSQLParserBACKUP, DorisSQLParserBASE, DorisSQLParserBASELINE, DorisSQLParserBEGIN, DorisSQLParserBINARY, DorisSQLParserBITMAP_UNION, DorisSQLParserBLACKHOLE, DorisSQLParserBLACKLIST, DorisSQLParserBODY, DorisSQLParserBOOLEAN, DorisSQLParserBRANCH, DorisSQLParserBROKER, DorisSQLParserBUCKETS, DorisSQLParserBUILTIN, DorisSQLParserCACHE, DorisSQLParserCANCEL, DorisSQLParserCAST, DorisSQLParserCATALOG, DorisSQLParserCATALOGS, DorisSQLParserCEIL, DorisSQLParserCHAIN, DorisSQLParserCHARSET, DorisSQLParserCLEAN, DorisSQLParserCLEAR, DorisSQLParserCLUSTER, DorisSQLParserCLUSTERS, DorisSQLParserCNGROUP, DorisSQLParserCNGROUPS, DorisSQLParserCOLLATION, DorisSQLParserCOLUMNS, DorisSQLParserCOMMENT, DorisSQLParserCOMMIT, DorisSQLParserCOMMITTED, DorisSQLParserCOMPACT, DorisSQLParserCOMPUTE, DorisSQLParserCONFIG, DorisSQLParserCONNECTION, DorisSQLParserCONSISTENT, DorisSQLParserCOSTS, DorisSQLParserCOUNT, DorisSQLParserCUME_DIST, DorisSQLParserCUMULATIVE, DorisSQLParserCURRENT, DorisSQLParserDATA, DorisSQLParserDATACACHE, DorisSQLParserDATE, DorisSQLParserDATETIME, DorisSQLParserDAY, DorisSQLParserDAYS, DorisSQLParserDEALLOCATE, DorisSQLParserDECOMMISSION, DorisSQLParserDIALECT, DorisSQLParserDICTIONARY, DorisSQLParserDICTIONARY_GET, DorisSQLParserDISABLE, DorisSQLParserDISTRIBUTED, DorisSQLParserDISTRIBUTION, DorisSQLParserDUPLICATE, DorisSQLParserDYNAMIC, DorisSQLParserENABLE, DorisSQLParserENCLOSE, DorisSQLParserEND, DorisSQLParserENGINE, DorisSQLParserENGINES, DorisSQLParserERRORS, DorisSQLParserESCAPE, DorisSQLParserEVENTS, DorisSQLParserEXCEPT, DorisSQLParserEXCLUDE, DorisSQLParserEXECUTE, DorisSQLParserEXPORT, DorisSQLParserEXTERNAL, DorisSQLParserEXTRACT, DorisSQLParserEVERY, DorisSQLParserFAILPOINT, DorisSQLParserFAILPOINTS, DorisSQLParserFIELDS, DorisSQLParserFILE, DorisSQLParserFILTER, DorisSQLParserFIRST, DorisSQLParserFLOOR, DorisSQLParserFN, DorisSQLParserFOLLOWING, DorisSQLParserFOLLOWER, DorisSQLParserFORMAT, DorisSQLParserFREE, DorisSQLParserFRONTEND, DorisSQLParserFRONTENDS, DorisSQLParserFUNCTIONS, DorisSQLParserGLOBAL, DorisSQLParserGRANTS, DorisSQLParserGROUP_CONCAT, DorisSQLParserHASH, DorisSQLParserHELP, DorisSQLParserHISTOGRAM, DorisSQLParserHLL_UNION, DorisSQLParserHOST, DorisSQLParserHOUR, DorisSQLParserHOURS, DorisSQLParserHUB, DorisSQLParserIDENTIFIED, DorisSQLParserIMPERSONATE, DorisSQLParserIMAGE, DorisSQLParserINACTIVE, DorisSQLParserINCREMENTAL, DorisSQLParserINDEXES, DorisSQLParserINSTALL, DorisSQLParserINTEGRATION, DorisSQLParserINTEGRATIONS, DorisSQLParserINTERMEDIATE, DorisSQLParserINTERVAL, DorisSQLParserOVERWRITE, DorisSQLParserISOLATION, DorisSQLParserJOB, DorisSQLParserLABEL, DorisSQLParserLAST, DorisSQLParserLESS, DorisSQLParserLEVEL, DorisSQLParserLIST, DorisSQLParserLOCAL, DorisSQLParserLOCATION, DorisSQLParserLOCATIONS, DorisSQLParserLOGS, DorisSQLParserLOGICAL, DorisSQLParserMANUAL, DorisSQLParserMAP, DorisSQLParserMAPPING, DorisSQLParserMAPPINGS, DorisSQLParserMASKING, DorisSQLParserMATCH, DorisSQLParserMATERIALIZED, DorisSQLParserMAX, DorisSQLParserMERGE, DorisSQLParserMIN, DorisSQLParserMINUTE, DorisSQLParserMINUTES, DorisSQLParserMINUS, DorisSQLParserMETA, DorisSQLParserMODE, DorisSQLParserMODIFY, DorisSQLParserMONTH, DorisSQLParserMULTIPLE, DorisSQLParserNAME, DorisSQLParserNAMES, DorisSQLParserNEGATIVE, DorisSQLParserNGRAMBF, DorisSQLParserNO, DorisSQLParserNODE, DorisSQLParserNODES, DorisSQLParserNONE, DorisSQLParserNULLS, DorisSQLParserNUMBER, DorisSQLParserNUMERIC, DorisSQLParserOBSERVER, DorisSQLParserOF, DorisSQLParserOFF, DorisSQLParserOFFSET, DorisSQLParserONLY, DorisSQLParserOPEN, DorisSQLParserOPERATE, DorisSQLParserOPTIMIZER, DorisSQLParserOPTION, DorisSQLParserPARTITIONS, DorisSQLParserPASSWORD, DorisSQLParserPATH, DorisSQLParserPAUSE, DorisSQLParserPENDING, DorisSQLParserPERCENT_RANK, DorisSQLParserPERCENTILE_UNION, DorisSQLParserPLAN, DorisSQLParserPLUGIN, DorisSQLParserPLUGINS, DorisSQLParserPIPE, DorisSQLParserPIPES, DorisSQLParserPIVOT, DorisSQLParserPOLICY, DorisSQLParserPOLICIES, DorisSQLParserPRECEDING, DorisSQLParserPREDICATE, DorisSQLParserPRIORITY, DorisSQLParserPRIVILEGES, DorisSQLParserPROBABILITY, DorisSQLParserPROC, DorisSQLParserPROCESSLIST, DorisSQLParserPROFILE, DorisSQLParserPROFILELIST, DorisSQLParserPROPERTIES, DorisSQLParserPROPERTY, DorisSQLParserPROVIDER, DorisSQLParserPROVIDERS, DorisSQLParserQUALIFY, DorisSQLParserQUARTER, DorisSQLParserQUERY, DorisSQLParserQUERIES, DorisSQLParserQUEUE, DorisSQLParserQUOTA, DorisSQLParserRANDOM, DorisSQLParserRANK, DorisSQLParserREASON, DorisSQLParserRECOVER, DorisSQLParserREFRESH, DorisSQLParserREWRITE, DorisSQLParserREMOVE, DorisSQLParserREPAIR, DorisSQLParserREPEATABLE, DorisSQLParserREPLACE_IF_NOT_NULL, DorisSQLParserREPLICA, DorisSQLParserREPOSITORY, DorisSQLParserREPOSITORIES, DorisSQLParserRESOURCE, DorisSQLParserRESOURCES, DorisSQLParserRESTORE, DorisSQLParserRESUME, DorisSQLParserRETAIN, DorisSQLParserRETENTION, DorisSQLParserRETURNS, DorisSQLParserRETRY, DorisSQLParserREVERT, DorisSQLParserROLE, DorisSQLParserROLES, DorisSQLParserROLLBACK, DorisSQLParserROLLUP, DorisSQLParserROUTINE, DorisSQLParserROW, DorisSQLParserRULE, DorisSQLParserRULES, DorisSQLParserRUNNING, DorisSQLParserSAMPLE, DorisSQLParserSCHEDULE, DorisSQLParserSCHEDULER, DorisSQLParserSECOND, DorisSQLParserSECURITY, DorisSQLParserSEMI, DorisSQLParserSEPARATOR, DorisSQLParserSERIALIZABLE, DorisSQLParserSESSION, DorisSQLParserSETS, DorisSQLParserSIGNED, DorisSQLParserSKIP_HEADER, DorisSQLParserSNAPSHOT, DorisSQLParserSNAPSHOTS, DorisSQLParserSQLBLACKLIST, DorisSQLParserSTART, DorisSQLParserSTATS, DorisSQLParserSTATUS, DorisSQLParserSTOP, DorisSQLParserSTORAGE, DorisSQLParserSTREAM, DorisSQLParserSTRING, DorisSQLParserSUBMIT, DorisSQLParserSUM, DorisSQLParserSUSPEND, DorisSQLParserSYNC, DorisSQLParserSYSTEM_TIME, DorisSQLParserSWAP, DorisSQLParserSTRUCT, DorisSQLParserTABLES, DorisSQLParserTABLET, DorisSQLParserTABLETS, DorisSQLParserTAG, DorisSQLParserTASK, DorisSQLParserTEMPORARY, DorisSQLParserTHAN, DorisSQLParserTIME, DorisSQLParserTIMES, DorisSQLParserTIMESTAMP, DorisSQLParserTIMESTAMPADD, DorisSQLParserTIMESTAMPDIFF, DorisSQLParserTRANSACTION, DorisSQLParserTRANSLATE, DorisSQLParserTRACE, DorisSQLParserTRIGGERS, DorisSQLParserTRIM_SPACE, DorisSQLParserTRUNCATE, DorisSQLParserTYPE, DorisSQLParserTYPES, DorisSQLParserUNBOUNDED, DorisSQLParserUNCOMMITTED, DorisSQLParserUNINSTALL, DorisSQLParserUNSET, DorisSQLParserUSAGE, DorisSQLParserUSER, DorisSQLParserUSERS, DorisSQLParserVALUE, DorisSQLParserVARBINARY, DorisSQLParserVARIABLES, DorisSQLParserVECTOR, DorisSQLParserVERBOSE, DorisSQLParserVERSION, DorisSQLParserVIEW, DorisSQLParserVIEWS, DorisSQLParserVOLUME, DorisSQLParserVOLUMES, DorisSQLParserWAREHOUSE, DorisSQLParserWAREHOUSES, DorisSQLParserWARNINGS, DorisSQLParserWEEK, DorisSQLParserWHITELIST, DorisSQLParserWORK, DorisSQLParserWRITE, DorisSQLParserYEAR, DorisSQLParserLOCK, DorisSQLParserUNLOCK, DorisSQLParserLOW_PRIORITY, DorisSQLParserDISK, DorisSQLParserDISKS, DorisSQLParserBEFORE, DorisSQLParserFIELD, DorisSQLParserPERSISTENT, DorisSQLParserSKEW, DorisSQLParserENCRYPT, DorisSQLParserCACHED, DorisSQLParserLIGHT, DorisSQLParserRECYCLE, DorisSQLParserBIN, DorisSQLParserTRASH, DorisSQLParserWORKLOAD, DorisSQLParserSQL, DorisSQLParserBLOCK, DorisSQLParserTASKS, DorisSQLParserCHANGE, DorisSQLParserPROCESS, DorisSQLParserMIGRATIONS, DorisSQLParserARRAY_ELEMENT, DorisSQLParserLETTER_IDENTIFIER, DorisSQLParserDIGIT_IDENTIFIER, DorisSQLParserBACKQUOTED_IDENTIFIER, DorisSQLParserDOTDOTDOT: + case StarRocksSQLParserACCESS, StarRocksSQLParserACTIVE, StarRocksSQLParserADMIN, StarRocksSQLParserADVISOR, StarRocksSQLParserAFTER, StarRocksSQLParserAGGREGATE, StarRocksSQLParserANTI, StarRocksSQLParserAPPLY, StarRocksSQLParserARRAY_AGG, StarRocksSQLParserARRAY_AGG_DISTINCT, StarRocksSQLParserASYNC, StarRocksSQLParserAUTHORS, StarRocksSQLParserAUTHENTICATION, StarRocksSQLParserAUTOMATED, StarRocksSQLParserAUTO_INCREMENT, StarRocksSQLParserAVG, StarRocksSQLParserBACKEND, StarRocksSQLParserBACKENDS, StarRocksSQLParserBACKUP, StarRocksSQLParserBASE, StarRocksSQLParserBASELINE, StarRocksSQLParserBEGIN, StarRocksSQLParserBINARY, StarRocksSQLParserBITMAP_UNION, StarRocksSQLParserBLACKHOLE, StarRocksSQLParserBLACKLIST, StarRocksSQLParserBODY, StarRocksSQLParserBOOLEAN, StarRocksSQLParserBRANCH, StarRocksSQLParserBROKER, StarRocksSQLParserBUCKETS, StarRocksSQLParserBUILTIN, StarRocksSQLParserCACHE, StarRocksSQLParserCANCEL, StarRocksSQLParserCAST, StarRocksSQLParserCATALOG, StarRocksSQLParserCATALOGS, StarRocksSQLParserCEIL, StarRocksSQLParserCHAIN, StarRocksSQLParserCHARSET, StarRocksSQLParserCLEAN, StarRocksSQLParserCLEAR, StarRocksSQLParserCLUSTER, StarRocksSQLParserCLUSTERS, StarRocksSQLParserCNGROUP, StarRocksSQLParserCNGROUPS, StarRocksSQLParserCOLLATION, StarRocksSQLParserCOLUMNS, StarRocksSQLParserCOMMENT, StarRocksSQLParserCOMMIT, StarRocksSQLParserCOMMITTED, StarRocksSQLParserCOMPACT, StarRocksSQLParserCOMPUTE, StarRocksSQLParserCONFIG, StarRocksSQLParserCONNECTION, StarRocksSQLParserCONSISTENT, StarRocksSQLParserCOSTS, StarRocksSQLParserCOUNT, StarRocksSQLParserCUME_DIST, StarRocksSQLParserCUMULATIVE, StarRocksSQLParserCURRENT, StarRocksSQLParserDATA, StarRocksSQLParserDATACACHE, StarRocksSQLParserDATE, StarRocksSQLParserDATETIME, StarRocksSQLParserDAY, StarRocksSQLParserDAYS, StarRocksSQLParserDEALLOCATE, StarRocksSQLParserDECOMMISSION, StarRocksSQLParserDIALECT, StarRocksSQLParserDICTIONARY, StarRocksSQLParserDICTIONARY_GET, StarRocksSQLParserDISABLE, StarRocksSQLParserDISTRIBUTED, StarRocksSQLParserDISTRIBUTION, StarRocksSQLParserDUPLICATE, StarRocksSQLParserDYNAMIC, StarRocksSQLParserENABLE, StarRocksSQLParserENCLOSE, StarRocksSQLParserEND, StarRocksSQLParserENGINE, StarRocksSQLParserENGINES, StarRocksSQLParserERRORS, StarRocksSQLParserESCAPE, StarRocksSQLParserEVENTS, StarRocksSQLParserEXCEPT, StarRocksSQLParserEXCLUDE, StarRocksSQLParserEXECUTE, StarRocksSQLParserEXPORT, StarRocksSQLParserEXTERNAL, StarRocksSQLParserEXTRACT, StarRocksSQLParserEVERY, StarRocksSQLParserFAILPOINT, StarRocksSQLParserFAILPOINTS, StarRocksSQLParserFIELDS, StarRocksSQLParserFILE, StarRocksSQLParserFILTER, StarRocksSQLParserFIRST, StarRocksSQLParserFLOOR, StarRocksSQLParserFN, StarRocksSQLParserFOLLOWING, StarRocksSQLParserFOLLOWER, StarRocksSQLParserFORMAT, StarRocksSQLParserFREE, StarRocksSQLParserFRONTEND, StarRocksSQLParserFRONTENDS, StarRocksSQLParserFUNCTIONS, StarRocksSQLParserGLOBAL, StarRocksSQLParserGRANTS, StarRocksSQLParserGROUP_CONCAT, StarRocksSQLParserHASH, StarRocksSQLParserHELP, StarRocksSQLParserHISTOGRAM, StarRocksSQLParserHLL_UNION, StarRocksSQLParserHOST, StarRocksSQLParserHOUR, StarRocksSQLParserHOURS, StarRocksSQLParserHUB, StarRocksSQLParserIDENTIFIED, StarRocksSQLParserIMPERSONATE, StarRocksSQLParserIMAGE, StarRocksSQLParserINACTIVE, StarRocksSQLParserINCREMENTAL, StarRocksSQLParserINDEXES, StarRocksSQLParserINSTALL, StarRocksSQLParserINTEGRATION, StarRocksSQLParserINTEGRATIONS, StarRocksSQLParserINTERMEDIATE, StarRocksSQLParserINTERVAL, StarRocksSQLParserOVERWRITE, StarRocksSQLParserISOLATION, StarRocksSQLParserJOB, StarRocksSQLParserLABEL, StarRocksSQLParserLAST, StarRocksSQLParserLESS, StarRocksSQLParserLEVEL, StarRocksSQLParserLIST, StarRocksSQLParserLOCAL, StarRocksSQLParserLOCATION, StarRocksSQLParserLOCATIONS, StarRocksSQLParserLOGS, StarRocksSQLParserLOGICAL, StarRocksSQLParserMANUAL, StarRocksSQLParserMAP, StarRocksSQLParserMAPPING, StarRocksSQLParserMAPPINGS, StarRocksSQLParserMASKING, StarRocksSQLParserMATCH, StarRocksSQLParserMATERIALIZED, StarRocksSQLParserMAX, StarRocksSQLParserMERGE, StarRocksSQLParserMIN, StarRocksSQLParserMINUTE, StarRocksSQLParserMINUTES, StarRocksSQLParserMINUS, StarRocksSQLParserMETA, StarRocksSQLParserMODE, StarRocksSQLParserMODIFY, StarRocksSQLParserMONTH, StarRocksSQLParserMULTIPLE, StarRocksSQLParserNAME, StarRocksSQLParserNAMES, StarRocksSQLParserNEGATIVE, StarRocksSQLParserNGRAMBF, StarRocksSQLParserNO, StarRocksSQLParserNODE, StarRocksSQLParserNODES, StarRocksSQLParserNONE, StarRocksSQLParserNULLS, StarRocksSQLParserNUMBER, StarRocksSQLParserNUMERIC, StarRocksSQLParserOBSERVER, StarRocksSQLParserOF, StarRocksSQLParserOFF, StarRocksSQLParserOFFSET, StarRocksSQLParserONLY, StarRocksSQLParserOPEN, StarRocksSQLParserOPERATE, StarRocksSQLParserOPTIMIZER, StarRocksSQLParserOPTION, StarRocksSQLParserPARTITIONS, StarRocksSQLParserPASSWORD, StarRocksSQLParserPATH, StarRocksSQLParserPAUSE, StarRocksSQLParserPENDING, StarRocksSQLParserPERCENT_RANK, StarRocksSQLParserPERCENTILE_UNION, StarRocksSQLParserPLAN, StarRocksSQLParserPLUGIN, StarRocksSQLParserPLUGINS, StarRocksSQLParserPIPE, StarRocksSQLParserPIPES, StarRocksSQLParserPIVOT, StarRocksSQLParserPOLICY, StarRocksSQLParserPOLICIES, StarRocksSQLParserPRECEDING, StarRocksSQLParserPREDICATE, StarRocksSQLParserPRIORITY, StarRocksSQLParserPRIVILEGES, StarRocksSQLParserPROBABILITY, StarRocksSQLParserPROC, StarRocksSQLParserPROCESSLIST, StarRocksSQLParserPROFILE, StarRocksSQLParserPROFILELIST, StarRocksSQLParserPROPERTIES, StarRocksSQLParserPROPERTY, StarRocksSQLParserPROVIDER, StarRocksSQLParserPROVIDERS, StarRocksSQLParserQUALIFY, StarRocksSQLParserQUARTER, StarRocksSQLParserQUERY, StarRocksSQLParserQUERIES, StarRocksSQLParserQUEUE, StarRocksSQLParserQUOTA, StarRocksSQLParserRANDOM, StarRocksSQLParserRANK, StarRocksSQLParserREASON, StarRocksSQLParserRECOVER, StarRocksSQLParserREFRESH, StarRocksSQLParserREWRITE, StarRocksSQLParserREMOVE, StarRocksSQLParserREPAIR, StarRocksSQLParserREPEATABLE, StarRocksSQLParserREPLACE_IF_NOT_NULL, StarRocksSQLParserREPLICA, StarRocksSQLParserREPOSITORY, StarRocksSQLParserREPOSITORIES, StarRocksSQLParserRESOURCE, StarRocksSQLParserRESOURCES, StarRocksSQLParserRESTORE, StarRocksSQLParserRESUME, StarRocksSQLParserRETAIN, StarRocksSQLParserRETENTION, StarRocksSQLParserRETURNS, StarRocksSQLParserRETRY, StarRocksSQLParserREVERT, StarRocksSQLParserROLE, StarRocksSQLParserROLES, StarRocksSQLParserROLLBACK, StarRocksSQLParserROLLUP, StarRocksSQLParserROUTINE, StarRocksSQLParserROW, StarRocksSQLParserRULE, StarRocksSQLParserRULES, StarRocksSQLParserRUNNING, StarRocksSQLParserSAMPLE, StarRocksSQLParserSCHEDULE, StarRocksSQLParserSCHEDULER, StarRocksSQLParserSECOND, StarRocksSQLParserSECURITY, StarRocksSQLParserSEMI, StarRocksSQLParserSEPARATOR, StarRocksSQLParserSERIALIZABLE, StarRocksSQLParserSESSION, StarRocksSQLParserSETS, StarRocksSQLParserSIGNED, StarRocksSQLParserSKIP_HEADER, StarRocksSQLParserSNAPSHOT, StarRocksSQLParserSNAPSHOTS, StarRocksSQLParserSQLBLACKLIST, StarRocksSQLParserSTART, StarRocksSQLParserSTATS, StarRocksSQLParserSTATUS, StarRocksSQLParserSTOP, StarRocksSQLParserSTORAGE, StarRocksSQLParserSTREAM, StarRocksSQLParserSTRING, StarRocksSQLParserSUBMIT, StarRocksSQLParserSUM, StarRocksSQLParserSUSPEND, StarRocksSQLParserSYNC, StarRocksSQLParserSYSTEM_TIME, StarRocksSQLParserSWAP, StarRocksSQLParserSTRUCT, StarRocksSQLParserTABLES, StarRocksSQLParserTABLET, StarRocksSQLParserTABLETS, StarRocksSQLParserTAG, StarRocksSQLParserTASK, StarRocksSQLParserTEMPORARY, StarRocksSQLParserTHAN, StarRocksSQLParserTIME, StarRocksSQLParserTIMES, StarRocksSQLParserTIMESTAMP, StarRocksSQLParserTIMESTAMPADD, StarRocksSQLParserTIMESTAMPDIFF, StarRocksSQLParserTRANSACTION, StarRocksSQLParserTRANSLATE, StarRocksSQLParserTRACE, StarRocksSQLParserTRIGGERS, StarRocksSQLParserTRIM_SPACE, StarRocksSQLParserTRUNCATE, StarRocksSQLParserTYPE, StarRocksSQLParserTYPES, StarRocksSQLParserUNBOUNDED, StarRocksSQLParserUNCOMMITTED, StarRocksSQLParserUNINSTALL, StarRocksSQLParserUNSET, StarRocksSQLParserUSAGE, StarRocksSQLParserUSER, StarRocksSQLParserUSERS, StarRocksSQLParserVALUE, StarRocksSQLParserVARBINARY, StarRocksSQLParserVARIABLES, StarRocksSQLParserVECTOR, StarRocksSQLParserVERBOSE, StarRocksSQLParserVERSION, StarRocksSQLParserVIEW, StarRocksSQLParserVIEWS, StarRocksSQLParserVOLUME, StarRocksSQLParserVOLUMES, StarRocksSQLParserWAREHOUSE, StarRocksSQLParserWAREHOUSES, StarRocksSQLParserWARNINGS, StarRocksSQLParserWEEK, StarRocksSQLParserWHITELIST, StarRocksSQLParserWORK, StarRocksSQLParserWRITE, StarRocksSQLParserYEAR, StarRocksSQLParserLOCK, StarRocksSQLParserUNLOCK, StarRocksSQLParserLOW_PRIORITY, StarRocksSQLParserDISK, StarRocksSQLParserDISKS, StarRocksSQLParserBEFORE, StarRocksSQLParserFIELD, StarRocksSQLParserPERSISTENT, StarRocksSQLParserSKEW, StarRocksSQLParserENCRYPT, StarRocksSQLParserCACHED, StarRocksSQLParserLIGHT, StarRocksSQLParserRECYCLE, StarRocksSQLParserBIN, StarRocksSQLParserTRASH, StarRocksSQLParserWORKLOAD, StarRocksSQLParserSQL, StarRocksSQLParserBLOCK, StarRocksSQLParserTASKS, StarRocksSQLParserCHANGE, StarRocksSQLParserPROCESS, StarRocksSQLParserMIGRATIONS, StarRocksSQLParserARRAY_ELEMENT, StarRocksSQLParserLETTER_IDENTIFIER, StarRocksSQLParserDIGIT_IDENTIFIER, StarRocksSQLParserBACKQUOTED_IDENTIFIER, StarRocksSQLParserDOTDOTDOT: p.EnterOuterAlt(localctx, 2) { p.SetState(8553) p.Identifier() } - case DorisSQLParserSINGLE_QUOTED_TEXT, DorisSQLParserDOUBLE_QUOTED_TEXT: + case StarRocksSQLParserSINGLE_QUOTED_TEXT, StarRocksSQLParserDOUBLE_QUOTED_TEXT: p.EnterOuterAlt(localctx, 3) { p.SetState(8554) @@ -148201,13 +148201,13 @@ type UserContext struct { func NewEmptyUserContext() *UserContext { var p = new(UserContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_user + p.RuleIndex = StarRocksSQLParserRULE_user return p } func InitEmptyUserContext(p *UserContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_user + p.RuleIndex = StarRocksSQLParserRULE_user } func (*UserContext) IsUserContext() {} @@ -148218,7 +148218,7 @@ func NewUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_user + p.RuleIndex = StarRocksSQLParserRULE_user return p } @@ -148297,24 +148297,24 @@ func (s *UserWithHostAndBlanketContext) IdentifierOrString(i int) IIdentifierOrS } func (s *UserWithHostAndBlanketContext) AT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAT, 0) + return s.GetToken(StarRocksSQLParserAT, 0) } func (s *UserWithHostAndBlanketContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUserWithHostAndBlanket(s) } } func (s *UserWithHostAndBlanketContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUserWithHostAndBlanket(s) } } func (s *UserWithHostAndBlanketContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUserWithHostAndBlanket(s) default: @@ -148382,24 +148382,24 @@ func (s *UserWithHostContext) IdentifierOrString(i int) IIdentifierOrStringConte } func (s *UserWithHostContext) AT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAT, 0) + return s.GetToken(StarRocksSQLParserAT, 0) } func (s *UserWithHostContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUserWithHost(s) } } func (s *UserWithHostContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUserWithHost(s) } } func (s *UserWithHostContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUserWithHost(s) default: @@ -148442,20 +148442,20 @@ func (s *UserWithoutHostContext) IdentifierOrString() IIdentifierOrStringContext } func (s *UserWithoutHostContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterUserWithoutHost(s) } } func (s *UserWithoutHostContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitUserWithoutHost(s) } } func (s *UserWithoutHostContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitUserWithoutHost(s) default: @@ -148463,9 +148463,9 @@ func (s *UserWithoutHostContext) Accept(visitor antlr.ParseTreeVisitor) interfac } } -func (p *DorisSQLParser) User() (localctx IUserContext) { +func (p *StarRocksSQLParser) User() (localctx IUserContext) { localctx = NewUserContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1086, DorisSQLParserRULE_user) + p.EnterRule(localctx, 1086, StarRocksSQLParserRULE_user) p.SetState(8568) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -148490,7 +148490,7 @@ func (p *DorisSQLParser) User() (localctx IUserContext) { } { p.SetState(8559) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148510,7 +148510,7 @@ func (p *DorisSQLParser) User() (localctx IUserContext) { } { p.SetState(8563) - p.Match(DorisSQLParserAT) + p.Match(StarRocksSQLParserAT) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148518,7 +148518,7 @@ func (p *DorisSQLParser) User() (localctx IUserContext) { } { p.SetState(8564) - p.Match(DorisSQLParserT__5) + p.Match(StarRocksSQLParserT__5) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148530,7 +148530,7 @@ func (p *DorisSQLParser) User() (localctx IUserContext) { } { p.SetState(8566) - p.Match(DorisSQLParserT__6) + p.Match(StarRocksSQLParserT__6) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148578,13 +148578,13 @@ type AssignmentContext struct { func NewEmptyAssignmentContext() *AssignmentContext { var p = new(AssignmentContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_assignment + p.RuleIndex = StarRocksSQLParserRULE_assignment return p } func InitEmptyAssignmentContext(p *AssignmentContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_assignment + p.RuleIndex = StarRocksSQLParserRULE_assignment } func (*AssignmentContext) IsAssignmentContext() {} @@ -148595,7 +148595,7 @@ func NewAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, i antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_assignment + p.RuleIndex = StarRocksSQLParserRULE_assignment return p } @@ -148619,7 +148619,7 @@ func (s *AssignmentContext) Identifier() IIdentifierContext { } func (s *AssignmentContext) EQ() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEQ, 0) + return s.GetToken(StarRocksSQLParserEQ, 0) } func (s *AssignmentContext) ExpressionOrDefault() IExpressionOrDefaultContext { @@ -148647,20 +148647,20 @@ func (s *AssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recogni } func (s *AssignmentContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAssignment(s) } } func (s *AssignmentContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAssignment(s) } } func (s *AssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAssignment(s) default: @@ -148668,9 +148668,9 @@ func (s *AssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { } } -func (p *DorisSQLParser) Assignment() (localctx IAssignmentContext) { +func (p *StarRocksSQLParser) Assignment() (localctx IAssignmentContext) { localctx = NewAssignmentContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1088, DorisSQLParserRULE_assignment) + p.EnterRule(localctx, 1088, StarRocksSQLParserRULE_assignment) p.EnterOuterAlt(localctx, 1) { p.SetState(8570) @@ -148678,7 +148678,7 @@ func (p *DorisSQLParser) Assignment() (localctx IAssignmentContext) { } { p.SetState(8571) - p.Match(DorisSQLParserEQ) + p.Match(StarRocksSQLParserEQ) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148725,13 +148725,13 @@ type AssignmentListContext struct { func NewEmptyAssignmentListContext() *AssignmentListContext { var p = new(AssignmentListContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_assignmentList + p.RuleIndex = StarRocksSQLParserRULE_assignmentList return p } func InitEmptyAssignmentListContext(p *AssignmentListContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_assignmentList + p.RuleIndex = StarRocksSQLParserRULE_assignmentList } func (*AssignmentListContext) IsAssignmentListContext() {} @@ -148742,7 +148742,7 @@ func NewAssignmentListContext(parser antlr.Parser, parent antlr.ParserRuleContex antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_assignmentList + p.RuleIndex = StarRocksSQLParserRULE_assignmentList return p } @@ -148799,20 +148799,20 @@ func (s *AssignmentListContext) ToStringTree(ruleNames []string, recog antlr.Rec } func (s *AssignmentListContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterAssignmentList(s) } } func (s *AssignmentListContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitAssignmentList(s) } } func (s *AssignmentListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitAssignmentList(s) default: @@ -148820,9 +148820,9 @@ func (s *AssignmentListContext) Accept(visitor antlr.ParseTreeVisitor) interface } } -func (p *DorisSQLParser) AssignmentList() (localctx IAssignmentListContext) { +func (p *StarRocksSQLParser) AssignmentList() (localctx IAssignmentListContext) { localctx = NewAssignmentListContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1090, DorisSQLParserRULE_assignmentList) + p.EnterRule(localctx, 1090, StarRocksSQLParserRULE_assignmentList) var _la int p.EnterOuterAlt(localctx, 1) @@ -148837,10 +148837,10 @@ func (p *DorisSQLParser) AssignmentList() (localctx IAssignmentListContext) { } _la = p.GetTokenStream().LA(1) - for _la == DorisSQLParserT__2 { + for _la == StarRocksSQLParserT__2 { { p.SetState(8575) - p.Match(DorisSQLParserT__2) + p.Match(StarRocksSQLParserT__2) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -148890,13 +148890,13 @@ type NumberContext struct { func NewEmptyNumberContext() *NumberContext { var p = new(NumberContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_number + p.RuleIndex = StarRocksSQLParserRULE_number return p } func InitEmptyNumberContext(p *NumberContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_number + p.RuleIndex = StarRocksSQLParserRULE_number } func (*NumberContext) IsNumberContext() {} @@ -148907,7 +148907,7 @@ func NewNumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invok antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_number + p.RuleIndex = StarRocksSQLParserRULE_number return p } @@ -148945,24 +148945,24 @@ func (s *DecimalValueContext) GetRuleContext() antlr.RuleContext { } func (s *DecimalValueContext) DECIMAL_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECIMAL_VALUE, 0) + return s.GetToken(StarRocksSQLParserDECIMAL_VALUE, 0) } func (s *DecimalValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDecimalValue(s) } } func (s *DecimalValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDecimalValue(s) } } func (s *DecimalValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDecimalValue(s) default: @@ -148989,24 +148989,24 @@ func (s *IntegerValueContext) GetRuleContext() antlr.RuleContext { } func (s *IntegerValueContext) INTEGER_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGER_VALUE, 0) + return s.GetToken(StarRocksSQLParserINTEGER_VALUE, 0) } func (s *IntegerValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterIntegerValue(s) } } func (s *IntegerValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitIntegerValue(s) } } func (s *IntegerValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitIntegerValue(s) default: @@ -149033,24 +149033,24 @@ func (s *DoubleValueContext) GetRuleContext() antlr.RuleContext { } func (s *DoubleValueContext) DOUBLE_VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOUBLE_VALUE, 0) + return s.GetToken(StarRocksSQLParserDOUBLE_VALUE, 0) } func (s *DoubleValueContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterDoubleValue(s) } } func (s *DoubleValueContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitDoubleValue(s) } } func (s *DoubleValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitDoubleValue(s) default: @@ -149058,9 +149058,9 @@ func (s *DoubleValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) Number() (localctx INumberContext) { +func (p *StarRocksSQLParser) Number() (localctx INumberContext) { localctx = NewNumberContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1092, DorisSQLParserRULE_number) + p.EnterRule(localctx, 1092, StarRocksSQLParserRULE_number) p.SetState(8585) p.GetErrorHandler().Sync(p) if p.HasError() { @@ -149068,36 +149068,36 @@ func (p *DorisSQLParser) Number() (localctx INumberContext) { } switch p.GetTokenStream().LA(1) { - case DorisSQLParserDECIMAL_VALUE: + case StarRocksSQLParserDECIMAL_VALUE: localctx = NewDecimalValueContext(p, localctx) p.EnterOuterAlt(localctx, 1) { p.SetState(8582) - p.Match(DorisSQLParserDECIMAL_VALUE) + p.Match(StarRocksSQLParserDECIMAL_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserDOUBLE_VALUE: + case StarRocksSQLParserDOUBLE_VALUE: localctx = NewDoubleValueContext(p, localctx) p.EnterOuterAlt(localctx, 2) { p.SetState(8583) - p.Match(DorisSQLParserDOUBLE_VALUE) + p.Match(StarRocksSQLParserDOUBLE_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit } } - case DorisSQLParserINTEGER_VALUE: + case StarRocksSQLParserINTEGER_VALUE: localctx = NewIntegerValueContext(p, localctx) p.EnterOuterAlt(localctx, 3) { p.SetState(8584) - p.Match(DorisSQLParserINTEGER_VALUE) + p.Match(StarRocksSQLParserINTEGER_VALUE) if p.HasError() { // Recognition error - abort rule goto errorExit @@ -149486,13 +149486,13 @@ type NonReservedContext struct { func NewEmptyNonReservedContext() *NonReservedContext { var p = new(NonReservedContext) antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_nonReserved + p.RuleIndex = StarRocksSQLParserRULE_nonReserved return p } func InitEmptyNonReservedContext(p *NonReservedContext) { antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) - p.RuleIndex = DorisSQLParserRULE_nonReserved + p.RuleIndex = StarRocksSQLParserRULE_nonReserved } func (*NonReservedContext) IsNonReservedContext() {} @@ -149503,7 +149503,7 @@ func NewNonReservedContext(parser antlr.Parser, parent antlr.ParserRuleContext, antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) p.parser = parser - p.RuleIndex = DorisSQLParserRULE_nonReserved + p.RuleIndex = StarRocksSQLParserRULE_nonReserved return p } @@ -149511,1375 +149511,1375 @@ func NewNonReservedContext(parser antlr.Parser, parent antlr.ParserRuleContext, func (s *NonReservedContext) GetParser() antlr.Parser { return s.parser } func (s *NonReservedContext) ACCESS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserACCESS, 0) + return s.GetToken(StarRocksSQLParserACCESS, 0) } func (s *NonReservedContext) ACTIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserACTIVE, 0) + return s.GetToken(StarRocksSQLParserACTIVE, 0) } func (s *NonReservedContext) ADVISOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADVISOR, 0) + return s.GetToken(StarRocksSQLParserADVISOR, 0) } func (s *NonReservedContext) AFTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAFTER, 0) + return s.GetToken(StarRocksSQLParserAFTER, 0) } func (s *NonReservedContext) AGGREGATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAGGREGATE, 0) + return s.GetToken(StarRocksSQLParserAGGREGATE, 0) } func (s *NonReservedContext) APPLY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAPPLY, 0) + return s.GetToken(StarRocksSQLParserAPPLY, 0) } func (s *NonReservedContext) ASYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserASYNC, 0) + return s.GetToken(StarRocksSQLParserASYNC, 0) } func (s *NonReservedContext) AUTHORS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTHORS, 0) + return s.GetToken(StarRocksSQLParserAUTHORS, 0) } func (s *NonReservedContext) AVG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAVG, 0) + return s.GetToken(StarRocksSQLParserAVG, 0) } func (s *NonReservedContext) ADMIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserADMIN, 0) + return s.GetToken(StarRocksSQLParserADMIN, 0) } func (s *NonReservedContext) ANTI() antlr.TerminalNode { - return s.GetToken(DorisSQLParserANTI, 0) + return s.GetToken(StarRocksSQLParserANTI, 0) } func (s *NonReservedContext) AUTHENTICATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTHENTICATION, 0) + return s.GetToken(StarRocksSQLParserAUTHENTICATION, 0) } func (s *NonReservedContext) AUTO_INCREMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTO_INCREMENT, 0) + return s.GetToken(StarRocksSQLParserAUTO_INCREMENT, 0) } func (s *NonReservedContext) AUTOMATED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserAUTOMATED, 0) + return s.GetToken(StarRocksSQLParserAUTOMATED, 0) } func (s *NonReservedContext) ARRAY_AGG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY_AGG, 0) + return s.GetToken(StarRocksSQLParserARRAY_AGG, 0) } func (s *NonReservedContext) ARRAY_AGG_DISTINCT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY_AGG_DISTINCT, 0) + return s.GetToken(StarRocksSQLParserARRAY_AGG_DISTINCT, 0) } func (s *NonReservedContext) BACKEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKEND, 0) + return s.GetToken(StarRocksSQLParserBACKEND, 0) } func (s *NonReservedContext) BACKENDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKENDS, 0) + return s.GetToken(StarRocksSQLParserBACKENDS, 0) } func (s *NonReservedContext) BACKUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBACKUP, 0) + return s.GetToken(StarRocksSQLParserBACKUP, 0) } func (s *NonReservedContext) BEGIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBEGIN, 0) + return s.GetToken(StarRocksSQLParserBEGIN, 0) } func (s *NonReservedContext) BITMAP_UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBITMAP_UNION, 0) + return s.GetToken(StarRocksSQLParserBITMAP_UNION, 0) } func (s *NonReservedContext) BLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserBLACKLIST, 0) } func (s *NonReservedContext) BLACKHOLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLACKHOLE, 0) + return s.GetToken(StarRocksSQLParserBLACKHOLE, 0) } func (s *NonReservedContext) BINARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBINARY, 0) + return s.GetToken(StarRocksSQLParserBINARY, 0) } func (s *NonReservedContext) BODY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBODY, 0) + return s.GetToken(StarRocksSQLParserBODY, 0) } func (s *NonReservedContext) BOOLEAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBOOLEAN, 0) + return s.GetToken(StarRocksSQLParserBOOLEAN, 0) } func (s *NonReservedContext) BRANCH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBRANCH, 0) + return s.GetToken(StarRocksSQLParserBRANCH, 0) } func (s *NonReservedContext) BROKER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBROKER, 0) + return s.GetToken(StarRocksSQLParserBROKER, 0) } func (s *NonReservedContext) BUCKETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBUCKETS, 0) + return s.GetToken(StarRocksSQLParserBUCKETS, 0) } func (s *NonReservedContext) BUILTIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBUILTIN, 0) + return s.GetToken(StarRocksSQLParserBUILTIN, 0) } func (s *NonReservedContext) BASE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBASE, 0) + return s.GetToken(StarRocksSQLParserBASE, 0) } func (s *NonReservedContext) BEFORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBEFORE, 0) + return s.GetToken(StarRocksSQLParserBEFORE, 0) } func (s *NonReservedContext) BASELINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBASELINE, 0) + return s.GetToken(StarRocksSQLParserBASELINE, 0) } func (s *NonReservedContext) BIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBIN, 0) + return s.GetToken(StarRocksSQLParserBIN, 0) } func (s *NonReservedContext) BLOCK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserBLOCK, 0) + return s.GetToken(StarRocksSQLParserBLOCK, 0) } func (s *NonReservedContext) CACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCACHE, 0) + return s.GetToken(StarRocksSQLParserCACHE, 0) } func (s *NonReservedContext) CACHED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCACHED, 0) + return s.GetToken(StarRocksSQLParserCACHED, 0) } func (s *NonReservedContext) CAST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCAST, 0) + return s.GetToken(StarRocksSQLParserCAST, 0) } func (s *NonReservedContext) CANCEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCANCEL, 0) + return s.GetToken(StarRocksSQLParserCANCEL, 0) } func (s *NonReservedContext) CATALOG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOG, 0) + return s.GetToken(StarRocksSQLParserCATALOG, 0) } func (s *NonReservedContext) CATALOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCATALOGS, 0) + return s.GetToken(StarRocksSQLParserCATALOGS, 0) } func (s *NonReservedContext) CEIL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCEIL, 0) + return s.GetToken(StarRocksSQLParserCEIL, 0) } func (s *NonReservedContext) CHAIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHAIN, 0) + return s.GetToken(StarRocksSQLParserCHAIN, 0) } func (s *NonReservedContext) CHANGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHANGE, 0) + return s.GetToken(StarRocksSQLParserCHANGE, 0) } func (s *NonReservedContext) CHARSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCHARSET, 0) + return s.GetToken(StarRocksSQLParserCHARSET, 0) } func (s *NonReservedContext) CLEAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLEAN, 0) + return s.GetToken(StarRocksSQLParserCLEAN, 0) } func (s *NonReservedContext) CLEAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLEAR, 0) + return s.GetToken(StarRocksSQLParserCLEAR, 0) } func (s *NonReservedContext) CLUSTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLUSTER, 0) + return s.GetToken(StarRocksSQLParserCLUSTER, 0) } func (s *NonReservedContext) CLUSTERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCLUSTERS, 0) + return s.GetToken(StarRocksSQLParserCLUSTERS, 0) } func (s *NonReservedContext) CNGROUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUP, 0) + return s.GetToken(StarRocksSQLParserCNGROUP, 0) } func (s *NonReservedContext) CNGROUPS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCNGROUPS, 0) + return s.GetToken(StarRocksSQLParserCNGROUPS, 0) } func (s *NonReservedContext) CURRENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCURRENT, 0) + return s.GetToken(StarRocksSQLParserCURRENT, 0) } func (s *NonReservedContext) COLLATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLLATION, 0) + return s.GetToken(StarRocksSQLParserCOLLATION, 0) } func (s *NonReservedContext) COLUMNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOLUMNS, 0) + return s.GetToken(StarRocksSQLParserCOLUMNS, 0) } func (s *NonReservedContext) CUME_DIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCUME_DIST, 0) + return s.GetToken(StarRocksSQLParserCUME_DIST, 0) } func (s *NonReservedContext) CUMULATIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCUMULATIVE, 0) + return s.GetToken(StarRocksSQLParserCUMULATIVE, 0) } func (s *NonReservedContext) COMMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMENT, 0) + return s.GetToken(StarRocksSQLParserCOMMENT, 0) } func (s *NonReservedContext) COMMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMIT, 0) + return s.GetToken(StarRocksSQLParserCOMMIT, 0) } func (s *NonReservedContext) COMMITTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMMITTED, 0) + return s.GetToken(StarRocksSQLParserCOMMITTED, 0) } func (s *NonReservedContext) COMPUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPUTE, 0) + return s.GetToken(StarRocksSQLParserCOMPUTE, 0) } func (s *NonReservedContext) CONNECTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONNECTION, 0) + return s.GetToken(StarRocksSQLParserCONNECTION, 0) } func (s *NonReservedContext) CONSISTENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONSISTENT, 0) + return s.GetToken(StarRocksSQLParserCONSISTENT, 0) } func (s *NonReservedContext) COSTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOSTS, 0) + return s.GetToken(StarRocksSQLParserCOSTS, 0) } func (s *NonReservedContext) COUNT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOUNT, 0) + return s.GetToken(StarRocksSQLParserCOUNT, 0) } func (s *NonReservedContext) CONFIG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCONFIG, 0) + return s.GetToken(StarRocksSQLParserCONFIG, 0) } func (s *NonReservedContext) COMPACT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserCOMPACT, 0) + return s.GetToken(StarRocksSQLParserCOMPACT, 0) } func (s *NonReservedContext) DATA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATA, 0) + return s.GetToken(StarRocksSQLParserDATA, 0) } func (s *NonReservedContext) DATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATE, 0) + return s.GetToken(StarRocksSQLParserDATE, 0) } func (s *NonReservedContext) DATACACHE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATACACHE, 0) + return s.GetToken(StarRocksSQLParserDATACACHE, 0) } func (s *NonReservedContext) DATETIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDATETIME, 0) + return s.GetToken(StarRocksSQLParserDATETIME, 0) } func (s *NonReservedContext) DAY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDAY, 0) + return s.GetToken(StarRocksSQLParserDAY, 0) } func (s *NonReservedContext) DAYS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDAYS, 0) + return s.GetToken(StarRocksSQLParserDAYS, 0) } func (s *NonReservedContext) DECOMMISSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDECOMMISSION, 0) + return s.GetToken(StarRocksSQLParserDECOMMISSION, 0) } func (s *NonReservedContext) DIALECT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDIALECT, 0) + return s.GetToken(StarRocksSQLParserDIALECT, 0) } func (s *NonReservedContext) DISABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISABLE, 0) + return s.GetToken(StarRocksSQLParserDISABLE, 0) } func (s *NonReservedContext) DISK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISK, 0) + return s.GetToken(StarRocksSQLParserDISK, 0) } func (s *NonReservedContext) DISKS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISKS, 0) + return s.GetToken(StarRocksSQLParserDISKS, 0) } func (s *NonReservedContext) DISTRIBUTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTRIBUTION, 0) + return s.GetToken(StarRocksSQLParserDISTRIBUTION, 0) } func (s *NonReservedContext) DUPLICATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDUPLICATE, 0) + return s.GetToken(StarRocksSQLParserDUPLICATE, 0) } func (s *NonReservedContext) DYNAMIC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDYNAMIC, 0) + return s.GetToken(StarRocksSQLParserDYNAMIC, 0) } func (s *NonReservedContext) DISTRIBUTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDISTRIBUTED, 0) + return s.GetToken(StarRocksSQLParserDISTRIBUTED, 0) } func (s *NonReservedContext) DICTIONARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY, 0) } func (s *NonReservedContext) DICTIONARY_GET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDICTIONARY_GET, 0) + return s.GetToken(StarRocksSQLParserDICTIONARY_GET, 0) } func (s *NonReservedContext) DEALLOCATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDEALLOCATE, 0) + return s.GetToken(StarRocksSQLParserDEALLOCATE, 0) } func (s *NonReservedContext) ENABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENABLE, 0) + return s.GetToken(StarRocksSQLParserENABLE, 0) } func (s *NonReservedContext) ENCRYPT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENCRYPT, 0) + return s.GetToken(StarRocksSQLParserENCRYPT, 0) } func (s *NonReservedContext) END() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEND, 0) + return s.GetToken(StarRocksSQLParserEND, 0) } func (s *NonReservedContext) ENGINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENGINE, 0) + return s.GetToken(StarRocksSQLParserENGINE, 0) } func (s *NonReservedContext) ENGINES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENGINES, 0) + return s.GetToken(StarRocksSQLParserENGINES, 0) } func (s *NonReservedContext) ERRORS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserERRORS, 0) + return s.GetToken(StarRocksSQLParserERRORS, 0) } func (s *NonReservedContext) EVENTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEVENTS, 0) + return s.GetToken(StarRocksSQLParserEVENTS, 0) } func (s *NonReservedContext) EXECUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXECUTE, 0) + return s.GetToken(StarRocksSQLParserEXECUTE, 0) } func (s *NonReservedContext) EXTERNAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTERNAL, 0) + return s.GetToken(StarRocksSQLParserEXTERNAL, 0) } func (s *NonReservedContext) EXTRACT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXTRACT, 0) + return s.GetToken(StarRocksSQLParserEXTRACT, 0) } func (s *NonReservedContext) EVERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEVERY, 0) + return s.GetToken(StarRocksSQLParserEVERY, 0) } func (s *NonReservedContext) ENCLOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserENCLOSE, 0) + return s.GetToken(StarRocksSQLParserENCLOSE, 0) } func (s *NonReservedContext) ESCAPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserESCAPE, 0) + return s.GetToken(StarRocksSQLParserESCAPE, 0) } func (s *NonReservedContext) EXPORT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXPORT, 0) + return s.GetToken(StarRocksSQLParserEXPORT, 0) } func (s *NonReservedContext) FAILPOINT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFAILPOINT, 0) + return s.GetToken(StarRocksSQLParserFAILPOINT, 0) } func (s *NonReservedContext) FAILPOINTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFAILPOINTS, 0) + return s.GetToken(StarRocksSQLParserFAILPOINTS, 0) } func (s *NonReservedContext) FIELDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIELDS, 0) + return s.GetToken(StarRocksSQLParserFIELDS, 0) } func (s *NonReservedContext) FILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILE, 0) + return s.GetToken(StarRocksSQLParserFILE, 0) } func (s *NonReservedContext) FILTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFILTER, 0) + return s.GetToken(StarRocksSQLParserFILTER, 0) } func (s *NonReservedContext) FIRST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIRST, 0) + return s.GetToken(StarRocksSQLParserFIRST, 0) } func (s *NonReservedContext) FLOOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFLOOR, 0) + return s.GetToken(StarRocksSQLParserFLOOR, 0) } func (s *NonReservedContext) FOLLOWING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOLLOWING, 0) + return s.GetToken(StarRocksSQLParserFOLLOWING, 0) } func (s *NonReservedContext) FORMAT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFORMAT, 0) + return s.GetToken(StarRocksSQLParserFORMAT, 0) } func (s *NonReservedContext) FN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFN, 0) + return s.GetToken(StarRocksSQLParserFN, 0) } func (s *NonReservedContext) FRONTEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTEND, 0) + return s.GetToken(StarRocksSQLParserFRONTEND, 0) } func (s *NonReservedContext) FRONTENDS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFRONTENDS, 0) + return s.GetToken(StarRocksSQLParserFRONTENDS, 0) } func (s *NonReservedContext) FOLLOWER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFOLLOWER, 0) + return s.GetToken(StarRocksSQLParserFOLLOWER, 0) } func (s *NonReservedContext) FREE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFREE, 0) + return s.GetToken(StarRocksSQLParserFREE, 0) } func (s *NonReservedContext) FUNCTIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFUNCTIONS, 0) + return s.GetToken(StarRocksSQLParserFUNCTIONS, 0) } func (s *NonReservedContext) GLOBAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGLOBAL, 0) + return s.GetToken(StarRocksSQLParserGLOBAL, 0) } func (s *NonReservedContext) GRANTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGRANTS, 0) + return s.GetToken(StarRocksSQLParserGRANTS, 0) } func (s *NonReservedContext) GROUP_CONCAT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserGROUP_CONCAT, 0) + return s.GetToken(StarRocksSQLParserGROUP_CONCAT, 0) } func (s *NonReservedContext) HASH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHASH, 0) + return s.GetToken(StarRocksSQLParserHASH, 0) } func (s *NonReservedContext) HISTOGRAM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHISTOGRAM, 0) + return s.GetToken(StarRocksSQLParserHISTOGRAM, 0) } func (s *NonReservedContext) HELP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHELP, 0) + return s.GetToken(StarRocksSQLParserHELP, 0) } func (s *NonReservedContext) HLL_UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHLL_UNION, 0) + return s.GetToken(StarRocksSQLParserHLL_UNION, 0) } func (s *NonReservedContext) HOST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOST, 0) + return s.GetToken(StarRocksSQLParserHOST, 0) } func (s *NonReservedContext) HOUR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOUR, 0) + return s.GetToken(StarRocksSQLParserHOUR, 0) } func (s *NonReservedContext) HOURS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHOURS, 0) + return s.GetToken(StarRocksSQLParserHOURS, 0) } func (s *NonReservedContext) HUB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserHUB, 0) + return s.GetToken(StarRocksSQLParserHUB, 0) } func (s *NonReservedContext) IDENTIFIED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIDENTIFIED, 0) + return s.GetToken(StarRocksSQLParserIDENTIFIED, 0) } func (s *NonReservedContext) IMAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMAGE, 0) + return s.GetToken(StarRocksSQLParserIMAGE, 0) } func (s *NonReservedContext) IMPERSONATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserIMPERSONATE, 0) + return s.GetToken(StarRocksSQLParserIMPERSONATE, 0) } func (s *NonReservedContext) INACTIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINACTIVE, 0) + return s.GetToken(StarRocksSQLParserINACTIVE, 0) } func (s *NonReservedContext) INCREMENTAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINCREMENTAL, 0) + return s.GetToken(StarRocksSQLParserINCREMENTAL, 0) } func (s *NonReservedContext) INDEXES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINDEXES, 0) + return s.GetToken(StarRocksSQLParserINDEXES, 0) } func (s *NonReservedContext) INSTALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINSTALL, 0) + return s.GetToken(StarRocksSQLParserINSTALL, 0) } func (s *NonReservedContext) INTEGRATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATION, 0) + return s.GetToken(StarRocksSQLParserINTEGRATION, 0) } func (s *NonReservedContext) INTEGRATIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTEGRATIONS, 0) + return s.GetToken(StarRocksSQLParserINTEGRATIONS, 0) } func (s *NonReservedContext) INTERMEDIATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTERMEDIATE, 0) + return s.GetToken(StarRocksSQLParserINTERMEDIATE, 0) } func (s *NonReservedContext) INTERVAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserINTERVAL, 0) + return s.GetToken(StarRocksSQLParserINTERVAL, 0) } func (s *NonReservedContext) ISOLATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserISOLATION, 0) + return s.GetToken(StarRocksSQLParserISOLATION, 0) } func (s *NonReservedContext) JOB() antlr.TerminalNode { - return s.GetToken(DorisSQLParserJOB, 0) + return s.GetToken(StarRocksSQLParserJOB, 0) } func (s *NonReservedContext) LABEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLABEL, 0) + return s.GetToken(StarRocksSQLParserLABEL, 0) } func (s *NonReservedContext) LAST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLAST, 0) + return s.GetToken(StarRocksSQLParserLAST, 0) } func (s *NonReservedContext) LESS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLESS, 0) + return s.GetToken(StarRocksSQLParserLESS, 0) } func (s *NonReservedContext) LEVEL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLEVEL, 0) + return s.GetToken(StarRocksSQLParserLEVEL, 0) } func (s *NonReservedContext) LIGHT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIGHT, 0) + return s.GetToken(StarRocksSQLParserLIGHT, 0) } func (s *NonReservedContext) LIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLIST, 0) + return s.GetToken(StarRocksSQLParserLIST, 0) } func (s *NonReservedContext) LOCAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCAL, 0) + return s.GetToken(StarRocksSQLParserLOCAL, 0) } func (s *NonReservedContext) LOCATION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCATION, 0) + return s.GetToken(StarRocksSQLParserLOCATION, 0) } func (s *NonReservedContext) LOGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGS, 0) + return s.GetToken(StarRocksSQLParserLOGS, 0) } func (s *NonReservedContext) LOGICAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOGICAL, 0) + return s.GetToken(StarRocksSQLParserLOGICAL, 0) } func (s *NonReservedContext) LOW_PRIORITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOW_PRIORITY, 0) + return s.GetToken(StarRocksSQLParserLOW_PRIORITY, 0) } func (s *NonReservedContext) LOCK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCK, 0) + return s.GetToken(StarRocksSQLParserLOCK, 0) } func (s *NonReservedContext) LOCATIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserLOCATIONS, 0) + return s.GetToken(StarRocksSQLParserLOCATIONS, 0) } func (s *NonReservedContext) MANUAL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMANUAL, 0) + return s.GetToken(StarRocksSQLParserMANUAL, 0) } func (s *NonReservedContext) MAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAP, 0) + return s.GetToken(StarRocksSQLParserMAP, 0) } func (s *NonReservedContext) MAPPING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAPPING, 0) + return s.GetToken(StarRocksSQLParserMAPPING, 0) } func (s *NonReservedContext) MAPPINGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAPPINGS, 0) + return s.GetToken(StarRocksSQLParserMAPPINGS, 0) } func (s *NonReservedContext) MASKING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMASKING, 0) + return s.GetToken(StarRocksSQLParserMASKING, 0) } func (s *NonReservedContext) MATCH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATCH, 0) + return s.GetToken(StarRocksSQLParserMATCH, 0) } func (s *NonReservedContext) MATERIALIZED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMATERIALIZED, 0) + return s.GetToken(StarRocksSQLParserMATERIALIZED, 0) } func (s *NonReservedContext) MAX() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMAX, 0) + return s.GetToken(StarRocksSQLParserMAX, 0) } func (s *NonReservedContext) META() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMETA, 0) + return s.GetToken(StarRocksSQLParserMETA, 0) } func (s *NonReservedContext) MIGRATIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMIGRATIONS, 0) + return s.GetToken(StarRocksSQLParserMIGRATIONS, 0) } func (s *NonReservedContext) MIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMIN, 0) + return s.GetToken(StarRocksSQLParserMIN, 0) } func (s *NonReservedContext) MINUTE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUTE, 0) + return s.GetToken(StarRocksSQLParserMINUTE, 0) } func (s *NonReservedContext) MINUTES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUTES, 0) + return s.GetToken(StarRocksSQLParserMINUTES, 0) } func (s *NonReservedContext) MODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODE, 0) + return s.GetToken(StarRocksSQLParserMODE, 0) } func (s *NonReservedContext) MODIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMODIFY, 0) + return s.GetToken(StarRocksSQLParserMODIFY, 0) } func (s *NonReservedContext) MONTH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMONTH, 0) + return s.GetToken(StarRocksSQLParserMONTH, 0) } func (s *NonReservedContext) MERGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMERGE, 0) + return s.GetToken(StarRocksSQLParserMERGE, 0) } func (s *NonReservedContext) MINUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMINUS, 0) + return s.GetToken(StarRocksSQLParserMINUS, 0) } func (s *NonReservedContext) MULTIPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserMULTIPLE, 0) + return s.GetToken(StarRocksSQLParserMULTIPLE, 0) } func (s *NonReservedContext) NAME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNAME, 0) + return s.GetToken(StarRocksSQLParserNAME, 0) } func (s *NonReservedContext) NAMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNAMES, 0) + return s.GetToken(StarRocksSQLParserNAMES, 0) } func (s *NonReservedContext) NEGATIVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNEGATIVE, 0) + return s.GetToken(StarRocksSQLParserNEGATIVE, 0) } func (s *NonReservedContext) NO() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNO, 0) + return s.GetToken(StarRocksSQLParserNO, 0) } func (s *NonReservedContext) NODE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODE, 0) + return s.GetToken(StarRocksSQLParserNODE, 0) } func (s *NonReservedContext) NODES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNODES, 0) + return s.GetToken(StarRocksSQLParserNODES, 0) } func (s *NonReservedContext) NONE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNONE, 0) + return s.GetToken(StarRocksSQLParserNONE, 0) } func (s *NonReservedContext) NULLS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNULLS, 0) + return s.GetToken(StarRocksSQLParserNULLS, 0) } func (s *NonReservedContext) NUMBER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNUMBER, 0) + return s.GetToken(StarRocksSQLParserNUMBER, 0) } func (s *NonReservedContext) NUMERIC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNUMERIC, 0) + return s.GetToken(StarRocksSQLParserNUMERIC, 0) } func (s *NonReservedContext) OBSERVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOBSERVER, 0) + return s.GetToken(StarRocksSQLParserOBSERVER, 0) } func (s *NonReservedContext) OF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOF, 0) + return s.GetToken(StarRocksSQLParserOF, 0) } func (s *NonReservedContext) OFFSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOFFSET, 0) + return s.GetToken(StarRocksSQLParserOFFSET, 0) } func (s *NonReservedContext) ONLY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserONLY, 0) + return s.GetToken(StarRocksSQLParserONLY, 0) } func (s *NonReservedContext) OPTIMIZER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTIMIZER, 0) + return s.GetToken(StarRocksSQLParserOPTIMIZER, 0) } func (s *NonReservedContext) OPEN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPEN, 0) + return s.GetToken(StarRocksSQLParserOPEN, 0) } func (s *NonReservedContext) OPERATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPERATE, 0) + return s.GetToken(StarRocksSQLParserOPERATE, 0) } func (s *NonReservedContext) OPTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOPTION, 0) + return s.GetToken(StarRocksSQLParserOPTION, 0) } func (s *NonReservedContext) OVERWRITE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOVERWRITE, 0) + return s.GetToken(StarRocksSQLParserOVERWRITE, 0) } func (s *NonReservedContext) OFF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserOFF, 0) + return s.GetToken(StarRocksSQLParserOFF, 0) } func (s *NonReservedContext) PARTITIONS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPARTITIONS, 0) + return s.GetToken(StarRocksSQLParserPARTITIONS, 0) } func (s *NonReservedContext) PASSWORD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPASSWORD, 0) + return s.GetToken(StarRocksSQLParserPASSWORD, 0) } func (s *NonReservedContext) PATH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPATH, 0) + return s.GetToken(StarRocksSQLParserPATH, 0) } func (s *NonReservedContext) PAUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPAUSE, 0) + return s.GetToken(StarRocksSQLParserPAUSE, 0) } func (s *NonReservedContext) PENDING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPENDING, 0) + return s.GetToken(StarRocksSQLParserPENDING, 0) } func (s *NonReservedContext) PERCENTILE_UNION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERCENTILE_UNION, 0) + return s.GetToken(StarRocksSQLParserPERCENTILE_UNION, 0) } func (s *NonReservedContext) PIVOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIVOT, 0) + return s.GetToken(StarRocksSQLParserPIVOT, 0) } func (s *NonReservedContext) PLAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLAN, 0) + return s.GetToken(StarRocksSQLParserPLAN, 0) } func (s *NonReservedContext) PLUGIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUGIN, 0) + return s.GetToken(StarRocksSQLParserPLUGIN, 0) } func (s *NonReservedContext) PLUGINS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPLUGINS, 0) + return s.GetToken(StarRocksSQLParserPLUGINS, 0) } func (s *NonReservedContext) POLICY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPOLICY, 0) + return s.GetToken(StarRocksSQLParserPOLICY, 0) } func (s *NonReservedContext) POLICIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPOLICIES, 0) + return s.GetToken(StarRocksSQLParserPOLICIES, 0) } func (s *NonReservedContext) PERCENT_RANK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERCENT_RANK, 0) + return s.GetToken(StarRocksSQLParserPERCENT_RANK, 0) } func (s *NonReservedContext) PREDICATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPREDICATE, 0) + return s.GetToken(StarRocksSQLParserPREDICATE, 0) } func (s *NonReservedContext) PRECEDING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRECEDING, 0) + return s.GetToken(StarRocksSQLParserPRECEDING, 0) } func (s *NonReservedContext) PRIORITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIORITY, 0) + return s.GetToken(StarRocksSQLParserPRIORITY, 0) } func (s *NonReservedContext) PROC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROC, 0) + return s.GetToken(StarRocksSQLParserPROC, 0) } func (s *NonReservedContext) PROCESS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROCESS, 0) + return s.GetToken(StarRocksSQLParserPROCESS, 0) } func (s *NonReservedContext) PROCESSLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROCESSLIST, 0) + return s.GetToken(StarRocksSQLParserPROCESSLIST, 0) } func (s *NonReservedContext) PROFILE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROFILE, 0) + return s.GetToken(StarRocksSQLParserPROFILE, 0) } func (s *NonReservedContext) PROFILELIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROFILELIST, 0) + return s.GetToken(StarRocksSQLParserPROFILELIST, 0) } func (s *NonReservedContext) PROVIDER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROVIDER, 0) + return s.GetToken(StarRocksSQLParserPROVIDER, 0) } func (s *NonReservedContext) PROVIDERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROVIDERS, 0) + return s.GetToken(StarRocksSQLParserPROVIDERS, 0) } func (s *NonReservedContext) PRIVILEGES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPRIVILEGES, 0) + return s.GetToken(StarRocksSQLParserPRIVILEGES, 0) } func (s *NonReservedContext) PROBABILITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROBABILITY, 0) + return s.GetToken(StarRocksSQLParserPROBABILITY, 0) } func (s *NonReservedContext) PROPERTIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTIES, 0) + return s.GetToken(StarRocksSQLParserPROPERTIES, 0) } func (s *NonReservedContext) PROPERTY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPROPERTY, 0) + return s.GetToken(StarRocksSQLParserPROPERTY, 0) } func (s *NonReservedContext) PIPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPE, 0) + return s.GetToken(StarRocksSQLParserPIPE, 0) } func (s *NonReservedContext) PIPES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPIPES, 0) + return s.GetToken(StarRocksSQLParserPIPES, 0) } func (s *NonReservedContext) QUARTER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUARTER, 0) + return s.GetToken(StarRocksSQLParserQUARTER, 0) } func (s *NonReservedContext) QUERY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUERY, 0) + return s.GetToken(StarRocksSQLParserQUERY, 0) } func (s *NonReservedContext) QUERIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUERIES, 0) + return s.GetToken(StarRocksSQLParserQUERIES, 0) } func (s *NonReservedContext) QUEUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUEUE, 0) + return s.GetToken(StarRocksSQLParserQUEUE, 0) } func (s *NonReservedContext) QUOTA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUOTA, 0) + return s.GetToken(StarRocksSQLParserQUOTA, 0) } func (s *NonReservedContext) QUALIFY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserQUALIFY, 0) + return s.GetToken(StarRocksSQLParserQUALIFY, 0) } func (s *NonReservedContext) REASON() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREASON, 0) + return s.GetToken(StarRocksSQLParserREASON, 0) } func (s *NonReservedContext) RECYCLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRECYCLE, 0) + return s.GetToken(StarRocksSQLParserRECYCLE, 0) } func (s *NonReservedContext) REMOVE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREMOVE, 0) + return s.GetToken(StarRocksSQLParserREMOVE, 0) } func (s *NonReservedContext) REWRITE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREWRITE, 0) + return s.GetToken(StarRocksSQLParserREWRITE, 0) } func (s *NonReservedContext) RANDOM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRANDOM, 0) + return s.GetToken(StarRocksSQLParserRANDOM, 0) } func (s *NonReservedContext) RANK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRANK, 0) + return s.GetToken(StarRocksSQLParserRANK, 0) } func (s *NonReservedContext) RECOVER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRECOVER, 0) + return s.GetToken(StarRocksSQLParserRECOVER, 0) } func (s *NonReservedContext) REFRESH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREFRESH, 0) + return s.GetToken(StarRocksSQLParserREFRESH, 0) } func (s *NonReservedContext) REPAIR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPAIR, 0) + return s.GetToken(StarRocksSQLParserREPAIR, 0) } func (s *NonReservedContext) REPEATABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPEATABLE, 0) + return s.GetToken(StarRocksSQLParserREPEATABLE, 0) } func (s *NonReservedContext) REPLACE_IF_NOT_NULL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLACE_IF_NOT_NULL, 0) + return s.GetToken(StarRocksSQLParserREPLACE_IF_NOT_NULL, 0) } func (s *NonReservedContext) REPLICA() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPLICA, 0) + return s.GetToken(StarRocksSQLParserREPLICA, 0) } func (s *NonReservedContext) REPOSITORY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORY, 0) + return s.GetToken(StarRocksSQLParserREPOSITORY, 0) } func (s *NonReservedContext) REPOSITORIES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREPOSITORIES, 0) + return s.GetToken(StarRocksSQLParserREPOSITORIES, 0) } func (s *NonReservedContext) RESOURCE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCE, 0) + return s.GetToken(StarRocksSQLParserRESOURCE, 0) } func (s *NonReservedContext) RESOURCES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESOURCES, 0) + return s.GetToken(StarRocksSQLParserRESOURCES, 0) } func (s *NonReservedContext) RESTORE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESTORE, 0) + return s.GetToken(StarRocksSQLParserRESTORE, 0) } func (s *NonReservedContext) RESUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRESUME, 0) + return s.GetToken(StarRocksSQLParserRESUME, 0) } func (s *NonReservedContext) RETAIN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETAIN, 0) + return s.GetToken(StarRocksSQLParserRETAIN, 0) } func (s *NonReservedContext) RETENTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETENTION, 0) + return s.GetToken(StarRocksSQLParserRETENTION, 0) } func (s *NonReservedContext) RETURNS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETURNS, 0) + return s.GetToken(StarRocksSQLParserRETURNS, 0) } func (s *NonReservedContext) RETRY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRETRY, 0) + return s.GetToken(StarRocksSQLParserRETRY, 0) } func (s *NonReservedContext) REVERT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserREVERT, 0) + return s.GetToken(StarRocksSQLParserREVERT, 0) } func (s *NonReservedContext) ROLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLE, 0) + return s.GetToken(StarRocksSQLParserROLE, 0) } func (s *NonReservedContext) ROLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLES, 0) + return s.GetToken(StarRocksSQLParserROLES, 0) } func (s *NonReservedContext) ROLLUP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLUP, 0) + return s.GetToken(StarRocksSQLParserROLLUP, 0) } func (s *NonReservedContext) ROLLBACK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROLLBACK, 0) + return s.GetToken(StarRocksSQLParserROLLBACK, 0) } func (s *NonReservedContext) ROUTINE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROUTINE, 0) + return s.GetToken(StarRocksSQLParserROUTINE, 0) } func (s *NonReservedContext) ROW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserROW, 0) + return s.GetToken(StarRocksSQLParserROW, 0) } func (s *NonReservedContext) RUNNING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRUNNING, 0) + return s.GetToken(StarRocksSQLParserRUNNING, 0) } func (s *NonReservedContext) RULE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULE, 0) + return s.GetToken(StarRocksSQLParserRULE, 0) } func (s *NonReservedContext) RULES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserRULES, 0) + return s.GetToken(StarRocksSQLParserRULES, 0) } func (s *NonReservedContext) SAMPLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSAMPLE, 0) + return s.GetToken(StarRocksSQLParserSAMPLE, 0) } func (s *NonReservedContext) SCHEDULE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEDULE, 0) + return s.GetToken(StarRocksSQLParserSCHEDULE, 0) } func (s *NonReservedContext) SCHEDULER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSCHEDULER, 0) + return s.GetToken(StarRocksSQLParserSCHEDULER, 0) } func (s *NonReservedContext) SECOND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECOND, 0) + return s.GetToken(StarRocksSQLParserSECOND, 0) } func (s *NonReservedContext) SECURITY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSECURITY, 0) + return s.GetToken(StarRocksSQLParserSECURITY, 0) } func (s *NonReservedContext) SEPARATOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSEPARATOR, 0) + return s.GetToken(StarRocksSQLParserSEPARATOR, 0) } func (s *NonReservedContext) SERIALIZABLE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSERIALIZABLE, 0) + return s.GetToken(StarRocksSQLParserSERIALIZABLE, 0) } func (s *NonReservedContext) SEMI() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSEMI, 0) + return s.GetToken(StarRocksSQLParserSEMI, 0) } func (s *NonReservedContext) SESSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSESSION, 0) + return s.GetToken(StarRocksSQLParserSESSION, 0) } func (s *NonReservedContext) SETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSETS, 0) + return s.GetToken(StarRocksSQLParserSETS, 0) } func (s *NonReservedContext) SIGNED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSIGNED, 0) + return s.GetToken(StarRocksSQLParserSIGNED, 0) } func (s *NonReservedContext) SKEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSKEW, 0) + return s.GetToken(StarRocksSQLParserSKEW, 0) } func (s *NonReservedContext) SNAPSHOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOT, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOT, 0) } func (s *NonReservedContext) SNAPSHOTS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSNAPSHOTS, 0) + return s.GetToken(StarRocksSQLParserSNAPSHOTS, 0) } func (s *NonReservedContext) SQL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSQL, 0) + return s.GetToken(StarRocksSQLParserSQL, 0) } func (s *NonReservedContext) SQLBLACKLIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSQLBLACKLIST, 0) + return s.GetToken(StarRocksSQLParserSQLBLACKLIST, 0) } func (s *NonReservedContext) START() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTART, 0) + return s.GetToken(StarRocksSQLParserSTART, 0) } func (s *NonReservedContext) STREAM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTREAM, 0) + return s.GetToken(StarRocksSQLParserSTREAM, 0) } func (s *NonReservedContext) SUM() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUM, 0) + return s.GetToken(StarRocksSQLParserSUM, 0) } func (s *NonReservedContext) STATUS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATUS, 0) + return s.GetToken(StarRocksSQLParserSTATUS, 0) } func (s *NonReservedContext) STOP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTOP, 0) + return s.GetToken(StarRocksSQLParserSTOP, 0) } func (s *NonReservedContext) SKIP_HEADER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSKIP_HEADER, 0) + return s.GetToken(StarRocksSQLParserSKIP_HEADER, 0) } func (s *NonReservedContext) SWAP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSWAP, 0) + return s.GetToken(StarRocksSQLParserSWAP, 0) } func (s *NonReservedContext) STORAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTORAGE, 0) + return s.GetToken(StarRocksSQLParserSTORAGE, 0) } func (s *NonReservedContext) STRING() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTRING, 0) + return s.GetToken(StarRocksSQLParserSTRING, 0) } func (s *NonReservedContext) STRUCT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTRUCT, 0) + return s.GetToken(StarRocksSQLParserSTRUCT, 0) } func (s *NonReservedContext) STATS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSTATS, 0) + return s.GetToken(StarRocksSQLParserSTATS, 0) } func (s *NonReservedContext) SUBMIT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUBMIT, 0) + return s.GetToken(StarRocksSQLParserSUBMIT, 0) } func (s *NonReservedContext) SUSPEND() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSUSPEND, 0) + return s.GetToken(StarRocksSQLParserSUSPEND, 0) } func (s *NonReservedContext) SYNC() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYNC, 0) + return s.GetToken(StarRocksSQLParserSYNC, 0) } func (s *NonReservedContext) SYSTEM_TIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserSYSTEM_TIME, 0) + return s.GetToken(StarRocksSQLParserSYSTEM_TIME, 0) } func (s *NonReservedContext) TABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLES, 0) + return s.GetToken(StarRocksSQLParserTABLES, 0) } func (s *NonReservedContext) TABLET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLET, 0) + return s.GetToken(StarRocksSQLParserTABLET, 0) } func (s *NonReservedContext) TABLETS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTABLETS, 0) + return s.GetToken(StarRocksSQLParserTABLETS, 0) } func (s *NonReservedContext) TAG() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTAG, 0) + return s.GetToken(StarRocksSQLParserTAG, 0) } func (s *NonReservedContext) TASK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTASK, 0) + return s.GetToken(StarRocksSQLParserTASK, 0) } func (s *NonReservedContext) TASKS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTASKS, 0) + return s.GetToken(StarRocksSQLParserTASKS, 0) } func (s *NonReservedContext) TEMPORARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTEMPORARY, 0) + return s.GetToken(StarRocksSQLParserTEMPORARY, 0) } func (s *NonReservedContext) TIMESTAMP() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMESTAMP, 0) + return s.GetToken(StarRocksSQLParserTIMESTAMP, 0) } func (s *NonReservedContext) TIMESTAMPADD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMESTAMPADD, 0) + return s.GetToken(StarRocksSQLParserTIMESTAMPADD, 0) } func (s *NonReservedContext) TIMESTAMPDIFF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMESTAMPDIFF, 0) + return s.GetToken(StarRocksSQLParserTIMESTAMPDIFF, 0) } func (s *NonReservedContext) THAN() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTHAN, 0) + return s.GetToken(StarRocksSQLParserTHAN, 0) } func (s *NonReservedContext) TIME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIME, 0) + return s.GetToken(StarRocksSQLParserTIME, 0) } func (s *NonReservedContext) TIMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTIMES, 0) + return s.GetToken(StarRocksSQLParserTIMES, 0) } func (s *NonReservedContext) TRANSACTION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSACTION, 0) + return s.GetToken(StarRocksSQLParserTRANSACTION, 0) } func (s *NonReservedContext) TRACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRACE, 0) + return s.GetToken(StarRocksSQLParserTRACE, 0) } func (s *NonReservedContext) TRANSLATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRANSLATE, 0) + return s.GetToken(StarRocksSQLParserTRANSLATE, 0) } func (s *NonReservedContext) TRASH() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRASH, 0) + return s.GetToken(StarRocksSQLParserTRASH, 0) } func (s *NonReservedContext) TRIM_SPACE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRIM_SPACE, 0) + return s.GetToken(StarRocksSQLParserTRIM_SPACE, 0) } func (s *NonReservedContext) TRIGGERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRIGGERS, 0) + return s.GetToken(StarRocksSQLParserTRIGGERS, 0) } func (s *NonReservedContext) TRUNCATE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTRUNCATE, 0) + return s.GetToken(StarRocksSQLParserTRUNCATE, 0) } func (s *NonReservedContext) TYPE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTYPE, 0) + return s.GetToken(StarRocksSQLParserTYPE, 0) } func (s *NonReservedContext) TYPES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserTYPES, 0) + return s.GetToken(StarRocksSQLParserTYPES, 0) } func (s *NonReservedContext) UNBOUNDED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNBOUNDED, 0) + return s.GetToken(StarRocksSQLParserUNBOUNDED, 0) } func (s *NonReservedContext) UNCOMMITTED() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNCOMMITTED, 0) + return s.GetToken(StarRocksSQLParserUNCOMMITTED, 0) } func (s *NonReservedContext) UNSET() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNSET, 0) + return s.GetToken(StarRocksSQLParserUNSET, 0) } func (s *NonReservedContext) UNINSTALL() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNINSTALL, 0) + return s.GetToken(StarRocksSQLParserUNINSTALL, 0) } func (s *NonReservedContext) USAGE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSAGE, 0) + return s.GetToken(StarRocksSQLParserUSAGE, 0) } func (s *NonReservedContext) USER() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSER, 0) + return s.GetToken(StarRocksSQLParserUSER, 0) } func (s *NonReservedContext) USERS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUSERS, 0) + return s.GetToken(StarRocksSQLParserUSERS, 0) } func (s *NonReservedContext) UNLOCK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserUNLOCK, 0) + return s.GetToken(StarRocksSQLParserUNLOCK, 0) } func (s *NonReservedContext) VALUE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVALUE, 0) + return s.GetToken(StarRocksSQLParserVALUE, 0) } func (s *NonReservedContext) VARBINARY() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVARBINARY, 0) + return s.GetToken(StarRocksSQLParserVARBINARY, 0) } func (s *NonReservedContext) VARIABLES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVARIABLES, 0) + return s.GetToken(StarRocksSQLParserVARIABLES, 0) } func (s *NonReservedContext) VIEW() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEW, 0) + return s.GetToken(StarRocksSQLParserVIEW, 0) } func (s *NonReservedContext) VIEWS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVIEWS, 0) + return s.GetToken(StarRocksSQLParserVIEWS, 0) } func (s *NonReservedContext) VERBOSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERBOSE, 0) + return s.GetToken(StarRocksSQLParserVERBOSE, 0) } func (s *NonReservedContext) VERSION() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVERSION, 0) + return s.GetToken(StarRocksSQLParserVERSION, 0) } func (s *NonReservedContext) VOLUME() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUME, 0) + return s.GetToken(StarRocksSQLParserVOLUME, 0) } func (s *NonReservedContext) VOLUMES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVOLUMES, 0) + return s.GetToken(StarRocksSQLParserVOLUMES, 0) } func (s *NonReservedContext) WARNINGS() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWARNINGS, 0) + return s.GetToken(StarRocksSQLParserWARNINGS, 0) } func (s *NonReservedContext) WEEK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWEEK, 0) + return s.GetToken(StarRocksSQLParserWEEK, 0) } func (s *NonReservedContext) WHITELIST() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWHITELIST, 0) + return s.GetToken(StarRocksSQLParserWHITELIST, 0) } func (s *NonReservedContext) WORK() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWORK, 0) + return s.GetToken(StarRocksSQLParserWORK, 0) } func (s *NonReservedContext) WORKLOAD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWORKLOAD, 0) + return s.GetToken(StarRocksSQLParserWORKLOAD, 0) } func (s *NonReservedContext) WRITE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWRITE, 0) + return s.GetToken(StarRocksSQLParserWRITE, 0) } func (s *NonReservedContext) WAREHOUSE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSE, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSE, 0) } func (s *NonReservedContext) WAREHOUSES() antlr.TerminalNode { - return s.GetToken(DorisSQLParserWAREHOUSES, 0) + return s.GetToken(StarRocksSQLParserWAREHOUSES, 0) } func (s *NonReservedContext) YEAR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserYEAR, 0) + return s.GetToken(StarRocksSQLParserYEAR, 0) } func (s *NonReservedContext) DOTDOTDOT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserDOTDOTDOT, 0) + return s.GetToken(StarRocksSQLParserDOTDOTDOT, 0) } func (s *NonReservedContext) NGRAMBF() antlr.TerminalNode { - return s.GetToken(DorisSQLParserNGRAMBF, 0) + return s.GetToken(StarRocksSQLParserNGRAMBF, 0) } func (s *NonReservedContext) VECTOR() antlr.TerminalNode { - return s.GetToken(DorisSQLParserVECTOR, 0) + return s.GetToken(StarRocksSQLParserVECTOR, 0) } func (s *NonReservedContext) FIELD() antlr.TerminalNode { - return s.GetToken(DorisSQLParserFIELD, 0) + return s.GetToken(StarRocksSQLParserFIELD, 0) } func (s *NonReservedContext) ARRAY_ELEMENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserARRAY_ELEMENT, 0) + return s.GetToken(StarRocksSQLParserARRAY_ELEMENT, 0) } func (s *NonReservedContext) PERSISTENT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserPERSISTENT, 0) + return s.GetToken(StarRocksSQLParserPERSISTENT, 0) } func (s *NonReservedContext) EXCLUDE() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXCLUDE, 0) + return s.GetToken(StarRocksSQLParserEXCLUDE, 0) } func (s *NonReservedContext) EXCEPT() antlr.TerminalNode { - return s.GetToken(DorisSQLParserEXCEPT, 0) + return s.GetToken(StarRocksSQLParserEXCEPT, 0) } func (s *NonReservedContext) GetRuleContext() antlr.RuleContext { @@ -150891,20 +150891,20 @@ func (s *NonReservedContext) ToStringTree(ruleNames []string, recog antlr.Recogn } func (s *NonReservedContext) EnterRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.EnterNonReserved(s) } } func (s *NonReservedContext) ExitRule(listener antlr.ParseTreeListener) { - if listenerT, ok := listener.(DorisSQLListener); ok { + if listenerT, ok := listener.(StarRocksSQLListener); ok { listenerT.ExitNonReserved(s) } } func (s *NonReservedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { switch t := visitor.(type) { - case DorisSQLVisitor: + case StarRocksSQLVisitor: return t.VisitNonReserved(s) default: @@ -150912,9 +150912,9 @@ func (s *NonReservedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} } } -func (p *DorisSQLParser) NonReserved() (localctx INonReservedContext) { +func (p *StarRocksSQLParser) NonReserved() (localctx INonReservedContext) { localctx = NewNonReservedContext(p, p.GetParserRuleContext(), p.GetState()) - p.EnterRule(localctx, 1094, DorisSQLParserRULE_nonReserved) + p.EnterRule(localctx, 1094, StarRocksSQLParserRULE_nonReserved) var _la int p.EnterOuterAlt(localctx, 1) @@ -150922,7 +150922,7 @@ func (p *DorisSQLParser) NonReserved() (localctx INonReservedContext) { p.SetState(8587) _la = p.GetTokenStream().LA(1) - if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-325409262756702208) != 0) || ((int64((_la-66)) & ^0x3f) == 0 && ((int64(1)<<(_la-66))&-6664167256628462851) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-5325949716511064143) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-30185710323344801) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-18293966621380713) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-1736700686877327629) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&-1234162512355020953) != 0) || ((int64((_la-450)) & ^0x3f) == 0 && ((int64(1)<<(_la-450))&576456348351245619) != 0) || _la == DorisSQLParserARRAY_ELEMENT || _la == DorisSQLParserDOTDOTDOT) { + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-325409262756702208) != 0) || ((int64((_la-66)) & ^0x3f) == 0 && ((int64(1)<<(_la-66))&-6664167256628462851) != 0) || ((int64((_la-130)) & ^0x3f) == 0 && ((int64(1)<<(_la-130))&-5325949716511064143) != 0) || ((int64((_la-194)) & ^0x3f) == 0 && ((int64(1)<<(_la-194))&-30185710323344801) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-18293966621380713) != 0) || ((int64((_la-322)) & ^0x3f) == 0 && ((int64(1)<<(_la-322))&-1736700686877327629) != 0) || ((int64((_la-386)) & ^0x3f) == 0 && ((int64(1)<<(_la-386))&-1234162512355020953) != 0) || ((int64((_la-450)) & ^0x3f) == 0 && ((int64(1)<<(_la-450))&576456348351245619) != 0) || _la == StarRocksSQLParserARRAY_ELEMENT || _la == StarRocksSQLParserDOTDOTDOT) { p.GetErrorHandler().RecoverInline(p) } else { p.GetErrorHandler().ReportMatch(p) @@ -150943,7 +150943,7 @@ errorExit: goto errorExit // Trick to prevent compiler error if the label is not used } -func (p *DorisSQLParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { +func (p *StarRocksSQLParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { switch ruleIndex { case 405: var t *QueryPrimaryContext = nil @@ -150985,7 +150985,7 @@ func (p *DorisSQLParser) Sempred(localctx antlr.RuleContext, ruleIndex, predInde } } -func (p *DorisSQLParser) QueryPrimary_Sempred(localctx antlr.RuleContext, predIndex int) bool { +func (p *StarRocksSQLParser) QueryPrimary_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 0: return p.Precpred(p.GetParserRuleContext(), 2) @@ -150998,7 +150998,7 @@ func (p *DorisSQLParser) QueryPrimary_Sempred(localctx antlr.RuleContext, predIn } } -func (p *DorisSQLParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { +func (p *StarRocksSQLParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 2: return p.Precpred(p.GetParserRuleContext(), 2) @@ -151011,7 +151011,7 @@ func (p *DorisSQLParser) Expression_Sempred(localctx antlr.RuleContext, predInde } } -func (p *DorisSQLParser) BooleanExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { +func (p *StarRocksSQLParser) BooleanExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 4: return p.Precpred(p.GetParserRuleContext(), 3) @@ -151027,7 +151027,7 @@ func (p *DorisSQLParser) BooleanExpression_Sempred(localctx antlr.RuleContext, p } } -func (p *DorisSQLParser) ValueExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { +func (p *StarRocksSQLParser) ValueExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 7: return p.Precpred(p.GetParserRuleContext(), 8) @@ -151058,7 +151058,7 @@ func (p *DorisSQLParser) ValueExpression_Sempred(localctx antlr.RuleContext, pre } } -func (p *DorisSQLParser) PrimaryExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { +func (p *StarRocksSQLParser) PrimaryExpression_Sempred(localctx antlr.RuleContext, predIndex int) bool { switch predIndex { case 15: return p.Precpred(p.GetParserRuleContext(), 19) diff --git a/doris/dorissql_visitor.go b/starrocks/starrockssql_visitor.go similarity index 50% rename from doris/dorissql_visitor.go rename to starrocks/starrockssql_visitor.go index db95490..8a68f90 100644 --- a/doris/dorissql_visitor.go +++ b/starrocks/starrockssql_visitor.go @@ -1,1929 +1,1929 @@ -// Code generated from DorisSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from StarRocksSQL.g4 by ANTLR 4.13.2. DO NOT EDIT. -package doris // DorisSQL +package starrocks // StarRocksSQL import "github.com/antlr4-go/antlr/v4" -// A complete Visitor for a parse tree produced by DorisSQLParser. -type DorisSQLVisitor interface { +// A complete Visitor for a parse tree produced by StarRocksSQLParser. +type StarRocksSQLVisitor interface { antlr.ParseTreeVisitor - // Visit a parse tree produced by DorisSQLParser#sqlStatements. + // Visit a parse tree produced by StarRocksSQLParser#sqlStatements. VisitSqlStatements(ctx *SqlStatementsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#singleStatement. + // Visit a parse tree produced by StarRocksSQLParser#singleStatement. VisitSingleStatement(ctx *SingleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#statement. + // Visit a parse tree produced by StarRocksSQLParser#statement. VisitStatement(ctx *StatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#useDatabaseStatement. + // Visit a parse tree produced by StarRocksSQLParser#useDatabaseStatement. VisitUseDatabaseStatement(ctx *UseDatabaseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#useCatalogStatement. + // Visit a parse tree produced by StarRocksSQLParser#useCatalogStatement. VisitUseCatalogStatement(ctx *UseCatalogStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setCatalogStatement. + // Visit a parse tree produced by StarRocksSQLParser#setCatalogStatement. VisitSetCatalogStatement(ctx *SetCatalogStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDatabasesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDatabasesStatement. VisitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterDbQuotaStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterDbQuotaStatement. VisitAlterDbQuotaStatement(ctx *AlterDbQuotaStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createDbStatement. + // Visit a parse tree produced by StarRocksSQLParser#createDbStatement. VisitCreateDbStatement(ctx *CreateDbStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropDbStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropDbStatement. VisitDropDbStatement(ctx *DropDbStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateDbStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateDbStatement. VisitShowCreateDbStatement(ctx *ShowCreateDbStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterDatabaseRenameStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterDatabaseRenameStatement. VisitAlterDatabaseRenameStatement(ctx *AlterDatabaseRenameStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#recoverDbStmt. + // Visit a parse tree produced by StarRocksSQLParser#recoverDbStmt. VisitRecoverDbStmt(ctx *RecoverDbStmtContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDataStmt. + // Visit a parse tree produced by StarRocksSQLParser#showDataStmt. VisitShowDataStmt(ctx *ShowDataStmtContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDataDistributionStmt. + // Visit a parse tree produced by StarRocksSQLParser#showDataDistributionStmt. VisitShowDataDistributionStmt(ctx *ShowDataDistributionStmtContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#createTableStatement. VisitCreateTableStatement(ctx *CreateTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnDesc. + // Visit a parse tree produced by StarRocksSQLParser#columnDesc. VisitColumnDesc(ctx *ColumnDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#charsetName. + // Visit a parse tree produced by StarRocksSQLParser#charsetName. VisitCharsetName(ctx *CharsetNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#defaultDesc. + // Visit a parse tree produced by StarRocksSQLParser#defaultDesc. VisitDefaultDesc(ctx *DefaultDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#generatedColumnDesc. + // Visit a parse tree produced by StarRocksSQLParser#generatedColumnDesc. VisitGeneratedColumnDesc(ctx *GeneratedColumnDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#indexDesc. + // Visit a parse tree produced by StarRocksSQLParser#indexDesc. VisitIndexDesc(ctx *IndexDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#engineDesc. + // Visit a parse tree produced by StarRocksSQLParser#engineDesc. VisitEngineDesc(ctx *EngineDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#charsetDesc. + // Visit a parse tree produced by StarRocksSQLParser#charsetDesc. VisitCharsetDesc(ctx *CharsetDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#collateDesc. + // Visit a parse tree produced by StarRocksSQLParser#collateDesc. VisitCollateDesc(ctx *CollateDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#keyDesc. + // Visit a parse tree produced by StarRocksSQLParser#keyDesc. VisitKeyDesc(ctx *KeyDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#orderByDesc. + // Visit a parse tree produced by StarRocksSQLParser#orderByDesc. VisitOrderByDesc(ctx *OrderByDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnNullable. + // Visit a parse tree produced by StarRocksSQLParser#columnNullable. VisitColumnNullable(ctx *ColumnNullableContext) interface{} - // Visit a parse tree produced by DorisSQLParser#typeWithNullable. + // Visit a parse tree produced by StarRocksSQLParser#typeWithNullable. VisitTypeWithNullable(ctx *TypeWithNullableContext) interface{} - // Visit a parse tree produced by DorisSQLParser#aggStateDesc. + // Visit a parse tree produced by StarRocksSQLParser#aggStateDesc. VisitAggStateDesc(ctx *AggStateDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#aggDesc. + // Visit a parse tree produced by StarRocksSQLParser#aggDesc. VisitAggDesc(ctx *AggDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rollupDesc. + // Visit a parse tree produced by StarRocksSQLParser#rollupDesc. VisitRollupDesc(ctx *RollupDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rollupItem. + // Visit a parse tree produced by StarRocksSQLParser#rollupItem. VisitRollupItem(ctx *RollupItemContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dupKeys. + // Visit a parse tree produced by StarRocksSQLParser#dupKeys. VisitDupKeys(ctx *DupKeysContext) interface{} - // Visit a parse tree produced by DorisSQLParser#fromRollup. + // Visit a parse tree produced by StarRocksSQLParser#fromRollup. VisitFromRollup(ctx *FromRollupContext) interface{} - // Visit a parse tree produced by DorisSQLParser#orReplace. + // Visit a parse tree produced by StarRocksSQLParser#orReplace. VisitOrReplace(ctx *OrReplaceContext) interface{} - // Visit a parse tree produced by DorisSQLParser#ifNotExists. + // Visit a parse tree produced by StarRocksSQLParser#ifNotExists. VisitIfNotExists(ctx *IfNotExistsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createTableAsSelectStatement. + // Visit a parse tree produced by StarRocksSQLParser#createTableAsSelectStatement. VisitCreateTableAsSelectStatement(ctx *CreateTableAsSelectStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropTableStatement. VisitDropTableStatement(ctx *DropTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cleanTemporaryTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#cleanTemporaryTableStatement. VisitCleanTemporaryTableStatement(ctx *CleanTemporaryTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterTableStatement. VisitAlterTableStatement(ctx *AlterTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createIndexStatement. + // Visit a parse tree produced by StarRocksSQLParser#createIndexStatement. VisitCreateIndexStatement(ctx *CreateIndexStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropIndexStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropIndexStatement. VisitDropIndexStatement(ctx *DropIndexStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#indexType. + // Visit a parse tree produced by StarRocksSQLParser#indexType. VisitIndexType(ctx *IndexTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTableStatement. VisitShowTableStatement(ctx *ShowTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTemporaryTablesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTemporaryTablesStatement. VisitShowTemporaryTablesStatement(ctx *ShowTemporaryTablesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateTableStatement. VisitShowCreateTableStatement(ctx *ShowCreateTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showColumnStatement. + // Visit a parse tree produced by StarRocksSQLParser#showColumnStatement. VisitShowColumnStatement(ctx *ShowColumnStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTableStatusStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTableStatusStatement. VisitShowTableStatusStatement(ctx *ShowTableStatusStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#refreshTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#refreshTableStatement. VisitRefreshTableStatement(ctx *RefreshTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showAlterStatement. + // Visit a parse tree produced by StarRocksSQLParser#showAlterStatement. VisitShowAlterStatement(ctx *ShowAlterStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#descTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#descTableStatement. VisitDescTableStatement(ctx *DescTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createTableLikeStatement. + // Visit a parse tree produced by StarRocksSQLParser#createTableLikeStatement. VisitCreateTableLikeStatement(ctx *CreateTableLikeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showIndexStatement. + // Visit a parse tree produced by StarRocksSQLParser#showIndexStatement. VisitShowIndexStatement(ctx *ShowIndexStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#recoverTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#recoverTableStatement. VisitRecoverTableStatement(ctx *RecoverTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#truncateTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#truncateTableStatement. VisitTruncateTableStatement(ctx *TruncateTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelAlterTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelAlterTableStatement. VisitCancelAlterTableStatement(ctx *CancelAlterTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPartitionsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPartitionsStatement. VisitShowPartitionsStatement(ctx *ShowPartitionsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#recoverPartitionStatement. + // Visit a parse tree produced by StarRocksSQLParser#recoverPartitionStatement. VisitRecoverPartitionStatement(ctx *RecoverPartitionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#createViewStatement. VisitCreateViewStatement(ctx *CreateViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterViewStatement. VisitAlterViewStatement(ctx *AlterViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropViewStatement. VisitDropViewStatement(ctx *DropViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnNameWithComment. + // Visit a parse tree produced by StarRocksSQLParser#columnNameWithComment. VisitColumnNameWithComment(ctx *ColumnNameWithCommentContext) interface{} - // Visit a parse tree produced by DorisSQLParser#submitTaskStatement. + // Visit a parse tree produced by StarRocksSQLParser#submitTaskStatement. VisitSubmitTaskStatement(ctx *SubmitTaskStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#taskClause. + // Visit a parse tree produced by StarRocksSQLParser#taskClause. VisitTaskClause(ctx *TaskClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropTaskStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropTaskStatement. VisitDropTaskStatement(ctx *DropTaskStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#taskScheduleDesc. + // Visit a parse tree produced by StarRocksSQLParser#taskScheduleDesc. VisitTaskScheduleDesc(ctx *TaskScheduleDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createMaterializedViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#createMaterializedViewStatement. VisitCreateMaterializedViewStatement(ctx *CreateMaterializedViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#mvPartitionExprs. + // Visit a parse tree produced by StarRocksSQLParser#mvPartitionExprs. VisitMvPartitionExprs(ctx *MvPartitionExprsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#materializedViewDesc. + // Visit a parse tree produced by StarRocksSQLParser#materializedViewDesc. VisitMaterializedViewDesc(ctx *MaterializedViewDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showMaterializedViewsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showMaterializedViewsStatement. VisitShowMaterializedViewsStatement(ctx *ShowMaterializedViewsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropMaterializedViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropMaterializedViewStatement. VisitDropMaterializedViewStatement(ctx *DropMaterializedViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterMaterializedViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterMaterializedViewStatement. VisitAlterMaterializedViewStatement(ctx *AlterMaterializedViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#refreshMaterializedViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#refreshMaterializedViewStatement. VisitRefreshMaterializedViewStatement(ctx *RefreshMaterializedViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelRefreshMaterializedViewStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelRefreshMaterializedViewStatement. VisitCancelRefreshMaterializedViewStatement(ctx *CancelRefreshMaterializedViewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminSetConfigStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminSetConfigStatement. VisitAdminSetConfigStatement(ctx *AdminSetConfigStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminSetReplicaStatusStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminSetReplicaStatusStatement. VisitAdminSetReplicaStatusStatement(ctx *AdminSetReplicaStatusStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminShowConfigStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminShowConfigStatement. VisitAdminShowConfigStatement(ctx *AdminShowConfigStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminShowReplicaDistributionStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminShowReplicaDistributionStatement. VisitAdminShowReplicaDistributionStatement(ctx *AdminShowReplicaDistributionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminShowReplicaStatusStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminShowReplicaStatusStatement. VisitAdminShowReplicaStatusStatement(ctx *AdminShowReplicaStatusStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminRepairTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminRepairTableStatement. VisitAdminRepairTableStatement(ctx *AdminRepairTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminCancelRepairTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminCancelRepairTableStatement. VisitAdminCancelRepairTableStatement(ctx *AdminCancelRepairTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminCheckTabletsStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminCheckTabletsStatement. VisitAdminCheckTabletsStatement(ctx *AdminCheckTabletsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminSetPartitionVersion. + // Visit a parse tree produced by StarRocksSQLParser#adminSetPartitionVersion. VisitAdminSetPartitionVersion(ctx *AdminSetPartitionVersionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#killStatement. + // Visit a parse tree produced by StarRocksSQLParser#killStatement. VisitKillStatement(ctx *KillStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#syncStatement. + // Visit a parse tree produced by StarRocksSQLParser#syncStatement. VisitSyncStatement(ctx *SyncStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminSetAutomatedSnapshotOnStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminSetAutomatedSnapshotOnStatement. VisitAdminSetAutomatedSnapshotOnStatement(ctx *AdminSetAutomatedSnapshotOnStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#adminSetAutomatedSnapshotOffStatement. + // Visit a parse tree produced by StarRocksSQLParser#adminSetAutomatedSnapshotOffStatement. VisitAdminSetAutomatedSnapshotOffStatement(ctx *AdminSetAutomatedSnapshotOffStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterSystemStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterSystemStatement. VisitAlterSystemStatement(ctx *AlterSystemStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelAlterSystemStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelAlterSystemStatement. VisitCancelAlterSystemStatement(ctx *CancelAlterSystemStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showComputeNodesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showComputeNodesStatement. VisitShowComputeNodesStatement(ctx *ShowComputeNodesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createExternalCatalogStatement. + // Visit a parse tree produced by StarRocksSQLParser#createExternalCatalogStatement. VisitCreateExternalCatalogStatement(ctx *CreateExternalCatalogStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateExternalCatalogStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateExternalCatalogStatement. VisitShowCreateExternalCatalogStatement(ctx *ShowCreateExternalCatalogStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropExternalCatalogStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropExternalCatalogStatement. VisitDropExternalCatalogStatement(ctx *DropExternalCatalogStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCatalogsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCatalogsStatement. VisitShowCatalogsStatement(ctx *ShowCatalogsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterCatalogStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterCatalogStatement. VisitAlterCatalogStatement(ctx *AlterCatalogStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createStorageVolumeStatement. + // Visit a parse tree produced by StarRocksSQLParser#createStorageVolumeStatement. VisitCreateStorageVolumeStatement(ctx *CreateStorageVolumeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#typeDesc. + // Visit a parse tree produced by StarRocksSQLParser#typeDesc. VisitTypeDesc(ctx *TypeDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#locationsDesc. + // Visit a parse tree produced by StarRocksSQLParser#locationsDesc. VisitLocationsDesc(ctx *LocationsDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showStorageVolumesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showStorageVolumesStatement. VisitShowStorageVolumesStatement(ctx *ShowStorageVolumesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropStorageVolumeStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropStorageVolumeStatement. VisitDropStorageVolumeStatement(ctx *DropStorageVolumeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterStorageVolumeStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterStorageVolumeStatement. VisitAlterStorageVolumeStatement(ctx *AlterStorageVolumeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterStorageVolumeClause. + // Visit a parse tree produced by StarRocksSQLParser#alterStorageVolumeClause. VisitAlterStorageVolumeClause(ctx *AlterStorageVolumeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyStorageVolumePropertiesClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyStorageVolumePropertiesClause. VisitModifyStorageVolumePropertiesClause(ctx *ModifyStorageVolumePropertiesClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyStorageVolumeCommentClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyStorageVolumeCommentClause. VisitModifyStorageVolumeCommentClause(ctx *ModifyStorageVolumeCommentClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#descStorageVolumeStatement. + // Visit a parse tree produced by StarRocksSQLParser#descStorageVolumeStatement. VisitDescStorageVolumeStatement(ctx *DescStorageVolumeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setDefaultStorageVolumeStatement. + // Visit a parse tree produced by StarRocksSQLParser#setDefaultStorageVolumeStatement. VisitSetDefaultStorageVolumeStatement(ctx *SetDefaultStorageVolumeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#updateFailPointStatusStatement. + // Visit a parse tree produced by StarRocksSQLParser#updateFailPointStatusStatement. VisitUpdateFailPointStatusStatement(ctx *UpdateFailPointStatusStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showFailPointStatement. + // Visit a parse tree produced by StarRocksSQLParser#showFailPointStatement. VisitShowFailPointStatement(ctx *ShowFailPointStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createDictionaryStatement. + // Visit a parse tree produced by StarRocksSQLParser#createDictionaryStatement. VisitCreateDictionaryStatement(ctx *CreateDictionaryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropDictionaryStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropDictionaryStatement. VisitDropDictionaryStatement(ctx *DropDictionaryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#refreshDictionaryStatement. + // Visit a parse tree produced by StarRocksSQLParser#refreshDictionaryStatement. VisitRefreshDictionaryStatement(ctx *RefreshDictionaryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDictionaryStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDictionaryStatement. VisitShowDictionaryStatement(ctx *ShowDictionaryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelRefreshDictionaryStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelRefreshDictionaryStatement. VisitCancelRefreshDictionaryStatement(ctx *CancelRefreshDictionaryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dictionaryColumnDesc. + // Visit a parse tree produced by StarRocksSQLParser#dictionaryColumnDesc. VisitDictionaryColumnDesc(ctx *DictionaryColumnDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dictionaryName. + // Visit a parse tree produced by StarRocksSQLParser#dictionaryName. VisitDictionaryName(ctx *DictionaryNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterClause. + // Visit a parse tree produced by StarRocksSQLParser#alterClause. VisitAlterClause(ctx *AlterClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addFrontendClause. + // Visit a parse tree produced by StarRocksSQLParser#addFrontendClause. VisitAddFrontendClause(ctx *AddFrontendClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropFrontendClause. + // Visit a parse tree produced by StarRocksSQLParser#dropFrontendClause. VisitDropFrontendClause(ctx *DropFrontendClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyFrontendHostClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyFrontendHostClause. VisitModifyFrontendHostClause(ctx *ModifyFrontendHostClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addBackendClause. + // Visit a parse tree produced by StarRocksSQLParser#addBackendClause. VisitAddBackendClause(ctx *AddBackendClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropBackendClause. + // Visit a parse tree produced by StarRocksSQLParser#dropBackendClause. VisitDropBackendClause(ctx *DropBackendClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#decommissionBackendClause. + // Visit a parse tree produced by StarRocksSQLParser#decommissionBackendClause. VisitDecommissionBackendClause(ctx *DecommissionBackendClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyBackendClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyBackendClause. VisitModifyBackendClause(ctx *ModifyBackendClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addComputeNodeClause. + // Visit a parse tree produced by StarRocksSQLParser#addComputeNodeClause. VisitAddComputeNodeClause(ctx *AddComputeNodeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropComputeNodeClause. + // Visit a parse tree produced by StarRocksSQLParser#dropComputeNodeClause. VisitDropComputeNodeClause(ctx *DropComputeNodeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyBrokerClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyBrokerClause. VisitModifyBrokerClause(ctx *ModifyBrokerClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterLoadErrorUrlClause. + // Visit a parse tree produced by StarRocksSQLParser#alterLoadErrorUrlClause. VisitAlterLoadErrorUrlClause(ctx *AlterLoadErrorUrlClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createImageClause. + // Visit a parse tree produced by StarRocksSQLParser#createImageClause. VisitCreateImageClause(ctx *CreateImageClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cleanTabletSchedQClause. + // Visit a parse tree produced by StarRocksSQLParser#cleanTabletSchedQClause. VisitCleanTabletSchedQClause(ctx *CleanTabletSchedQClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#decommissionDiskClause. + // Visit a parse tree produced by StarRocksSQLParser#decommissionDiskClause. VisitDecommissionDiskClause(ctx *DecommissionDiskClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelDecommissionDiskClause. + // Visit a parse tree produced by StarRocksSQLParser#cancelDecommissionDiskClause. VisitCancelDecommissionDiskClause(ctx *CancelDecommissionDiskClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#disableDiskClause. + // Visit a parse tree produced by StarRocksSQLParser#disableDiskClause. VisitDisableDiskClause(ctx *DisableDiskClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelDisableDiskClause. + // Visit a parse tree produced by StarRocksSQLParser#cancelDisableDiskClause. VisitCancelDisableDiskClause(ctx *CancelDisableDiskClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createIndexClause. + // Visit a parse tree produced by StarRocksSQLParser#createIndexClause. VisitCreateIndexClause(ctx *CreateIndexClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropIndexClause. + // Visit a parse tree produced by StarRocksSQLParser#dropIndexClause. VisitDropIndexClause(ctx *DropIndexClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tableRenameClause. + // Visit a parse tree produced by StarRocksSQLParser#tableRenameClause. VisitTableRenameClause(ctx *TableRenameClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#swapTableClause. + // Visit a parse tree produced by StarRocksSQLParser#swapTableClause. VisitSwapTableClause(ctx *SwapTableClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyPropertiesClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyPropertiesClause. VisitModifyPropertiesClause(ctx *ModifyPropertiesClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyCommentClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyCommentClause. VisitModifyCommentClause(ctx *ModifyCommentClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#optimizeRange. + // Visit a parse tree produced by StarRocksSQLParser#optimizeRange. VisitOptimizeRange(ctx *OptimizeRangeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#optimizeClause. + // Visit a parse tree produced by StarRocksSQLParser#optimizeClause. VisitOptimizeClause(ctx *OptimizeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addColumnClause. + // Visit a parse tree produced by StarRocksSQLParser#addColumnClause. VisitAddColumnClause(ctx *AddColumnClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addColumnsClause. + // Visit a parse tree produced by StarRocksSQLParser#addColumnsClause. VisitAddColumnsClause(ctx *AddColumnsClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropColumnClause. + // Visit a parse tree produced by StarRocksSQLParser#dropColumnClause. VisitDropColumnClause(ctx *DropColumnClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyColumnClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyColumnClause. VisitModifyColumnClause(ctx *ModifyColumnClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyColumnCommentClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyColumnCommentClause. VisitModifyColumnCommentClause(ctx *ModifyColumnCommentClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnRenameClause. + // Visit a parse tree produced by StarRocksSQLParser#columnRenameClause. VisitColumnRenameClause(ctx *ColumnRenameClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#reorderColumnsClause. + // Visit a parse tree produced by StarRocksSQLParser#reorderColumnsClause. VisitReorderColumnsClause(ctx *ReorderColumnsClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rollupRenameClause. + // Visit a parse tree produced by StarRocksSQLParser#rollupRenameClause. VisitRollupRenameClause(ctx *RollupRenameClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#compactionClause. + // Visit a parse tree produced by StarRocksSQLParser#compactionClause. VisitCompactionClause(ctx *CompactionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#subfieldName. + // Visit a parse tree produced by StarRocksSQLParser#subfieldName. VisitSubfieldName(ctx *SubfieldNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#nestedFieldName. + // Visit a parse tree produced by StarRocksSQLParser#nestedFieldName. VisitNestedFieldName(ctx *NestedFieldNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addFieldClause. + // Visit a parse tree produced by StarRocksSQLParser#addFieldClause. VisitAddFieldClause(ctx *AddFieldClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropFieldClause. + // Visit a parse tree produced by StarRocksSQLParser#dropFieldClause. VisitDropFieldClause(ctx *DropFieldClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createOrReplaceTagClause. + // Visit a parse tree produced by StarRocksSQLParser#createOrReplaceTagClause. VisitCreateOrReplaceTagClause(ctx *CreateOrReplaceTagClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createOrReplaceBranchClause. + // Visit a parse tree produced by StarRocksSQLParser#createOrReplaceBranchClause. VisitCreateOrReplaceBranchClause(ctx *CreateOrReplaceBranchClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropBranchClause. + // Visit a parse tree produced by StarRocksSQLParser#dropBranchClause. VisitDropBranchClause(ctx *DropBranchClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropTagClause. + // Visit a parse tree produced by StarRocksSQLParser#dropTagClause. VisitDropTagClause(ctx *DropTagClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tableOperationClause. + // Visit a parse tree produced by StarRocksSQLParser#tableOperationClause. VisitTableOperationClause(ctx *TableOperationClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tagOptions. + // Visit a parse tree produced by StarRocksSQLParser#tagOptions. VisitTagOptions(ctx *TagOptionsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#branchOptions. + // Visit a parse tree produced by StarRocksSQLParser#branchOptions. VisitBranchOptions(ctx *BranchOptionsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#snapshotRetention. + // Visit a parse tree produced by StarRocksSQLParser#snapshotRetention. VisitSnapshotRetention(ctx *SnapshotRetentionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#refRetain. + // Visit a parse tree produced by StarRocksSQLParser#refRetain. VisitRefRetain(ctx *RefRetainContext) interface{} - // Visit a parse tree produced by DorisSQLParser#maxSnapshotAge. + // Visit a parse tree produced by StarRocksSQLParser#maxSnapshotAge. VisitMaxSnapshotAge(ctx *MaxSnapshotAgeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#minSnapshotsToKeep. + // Visit a parse tree produced by StarRocksSQLParser#minSnapshotsToKeep. VisitMinSnapshotsToKeep(ctx *MinSnapshotsToKeepContext) interface{} - // Visit a parse tree produced by DorisSQLParser#snapshotId. + // Visit a parse tree produced by StarRocksSQLParser#snapshotId. VisitSnapshotId(ctx *SnapshotIdContext) interface{} - // Visit a parse tree produced by DorisSQLParser#timeUnit. + // Visit a parse tree produced by StarRocksSQLParser#timeUnit. VisitTimeUnit(ctx *TimeUnitContext) interface{} - // Visit a parse tree produced by DorisSQLParser#integer_list. + // Visit a parse tree produced by StarRocksSQLParser#integer_list. VisitInteger_list(ctx *Integer_listContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropPersistentIndexClause. + // Visit a parse tree produced by StarRocksSQLParser#dropPersistentIndexClause. VisitDropPersistentIndexClause(ctx *DropPersistentIndexClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addPartitionClause. + // Visit a parse tree produced by StarRocksSQLParser#addPartitionClause. VisitAddPartitionClause(ctx *AddPartitionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropPartitionClause. + // Visit a parse tree produced by StarRocksSQLParser#dropPartitionClause. VisitDropPartitionClause(ctx *DropPartitionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#truncatePartitionClause. + // Visit a parse tree produced by StarRocksSQLParser#truncatePartitionClause. VisitTruncatePartitionClause(ctx *TruncatePartitionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#modifyPartitionClause. + // Visit a parse tree produced by StarRocksSQLParser#modifyPartitionClause. VisitModifyPartitionClause(ctx *ModifyPartitionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#replacePartitionClause. + // Visit a parse tree produced by StarRocksSQLParser#replacePartitionClause. VisitReplacePartitionClause(ctx *ReplacePartitionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionRenameClause. + // Visit a parse tree produced by StarRocksSQLParser#partitionRenameClause. VisitPartitionRenameClause(ctx *PartitionRenameClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#insertStatement. + // Visit a parse tree produced by StarRocksSQLParser#insertStatement. VisitInsertStatement(ctx *InsertStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#insertLabelOrColumnAliases. + // Visit a parse tree produced by StarRocksSQLParser#insertLabelOrColumnAliases. VisitInsertLabelOrColumnAliases(ctx *InsertLabelOrColumnAliasesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnAliasesOrByName. + // Visit a parse tree produced by StarRocksSQLParser#columnAliasesOrByName. VisitColumnAliasesOrByName(ctx *ColumnAliasesOrByNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#updateStatement. + // Visit a parse tree produced by StarRocksSQLParser#updateStatement. VisitUpdateStatement(ctx *UpdateStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#deleteStatement. + // Visit a parse tree produced by StarRocksSQLParser#deleteStatement. VisitDeleteStatement(ctx *DeleteStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#createRoutineLoadStatement. VisitCreateRoutineLoadStatement(ctx *CreateRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterRoutineLoadStatement. VisitAlterRoutineLoadStatement(ctx *AlterRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dataSource. + // Visit a parse tree produced by StarRocksSQLParser#dataSource. VisitDataSource(ctx *DataSourceContext) interface{} - // Visit a parse tree produced by DorisSQLParser#loadProperties. + // Visit a parse tree produced by StarRocksSQLParser#loadProperties. VisitLoadProperties(ctx *LoadPropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#colSeparatorProperty. + // Visit a parse tree produced by StarRocksSQLParser#colSeparatorProperty. VisitColSeparatorProperty(ctx *ColSeparatorPropertyContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rowDelimiterProperty. + // Visit a parse tree produced by StarRocksSQLParser#rowDelimiterProperty. VisitRowDelimiterProperty(ctx *RowDelimiterPropertyContext) interface{} - // Visit a parse tree produced by DorisSQLParser#importColumns. + // Visit a parse tree produced by StarRocksSQLParser#importColumns. VisitImportColumns(ctx *ImportColumnsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnProperties. + // Visit a parse tree produced by StarRocksSQLParser#columnProperties. VisitColumnProperties(ctx *ColumnPropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#jobProperties. + // Visit a parse tree produced by StarRocksSQLParser#jobProperties. VisitJobProperties(ctx *JobPropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dataSourceProperties. + // Visit a parse tree produced by StarRocksSQLParser#dataSourceProperties. VisitDataSourceProperties(ctx *DataSourcePropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#stopRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#stopRoutineLoadStatement. VisitStopRoutineLoadStatement(ctx *StopRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#resumeRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#resumeRoutineLoadStatement. VisitResumeRoutineLoadStatement(ctx *ResumeRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#pauseRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#pauseRoutineLoadStatement. VisitPauseRoutineLoadStatement(ctx *PauseRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#showRoutineLoadStatement. VisitShowRoutineLoadStatement(ctx *ShowRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showRoutineLoadTaskStatement. + // Visit a parse tree produced by StarRocksSQLParser#showRoutineLoadTaskStatement. VisitShowRoutineLoadTaskStatement(ctx *ShowRoutineLoadTaskStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateRoutineLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateRoutineLoadStatement. VisitShowCreateRoutineLoadStatement(ctx *ShowCreateRoutineLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showStreamLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#showStreamLoadStatement. VisitShowStreamLoadStatement(ctx *ShowStreamLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#analyzeStatement. + // Visit a parse tree produced by StarRocksSQLParser#analyzeStatement. VisitAnalyzeStatement(ctx *AnalyzeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#regularColumns. + // Visit a parse tree produced by StarRocksSQLParser#regularColumns. VisitRegularColumns(ctx *RegularColumnsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#allColumns. + // Visit a parse tree produced by StarRocksSQLParser#allColumns. VisitAllColumns(ctx *AllColumnsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#predicateColumns. + // Visit a parse tree produced by StarRocksSQLParser#predicateColumns. VisitPredicateColumns(ctx *PredicateColumnsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#multiColumnSet. + // Visit a parse tree produced by StarRocksSQLParser#multiColumnSet. VisitMultiColumnSet(ctx *MultiColumnSetContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropStatsStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropStatsStatement. VisitDropStatsStatement(ctx *DropStatsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#histogramStatement. + // Visit a parse tree produced by StarRocksSQLParser#histogramStatement. VisitHistogramStatement(ctx *HistogramStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#analyzeHistogramStatement. + // Visit a parse tree produced by StarRocksSQLParser#analyzeHistogramStatement. VisitAnalyzeHistogramStatement(ctx *AnalyzeHistogramStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropHistogramStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropHistogramStatement. VisitDropHistogramStatement(ctx *DropHistogramStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createAnalyzeStatement. + // Visit a parse tree produced by StarRocksSQLParser#createAnalyzeStatement. VisitCreateAnalyzeStatement(ctx *CreateAnalyzeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropAnalyzeJobStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropAnalyzeJobStatement. VisitDropAnalyzeJobStatement(ctx *DropAnalyzeJobStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showAnalyzeStatement. + // Visit a parse tree produced by StarRocksSQLParser#showAnalyzeStatement. VisitShowAnalyzeStatement(ctx *ShowAnalyzeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showStatsMetaStatement. + // Visit a parse tree produced by StarRocksSQLParser#showStatsMetaStatement. VisitShowStatsMetaStatement(ctx *ShowStatsMetaStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showHistogramMetaStatement. + // Visit a parse tree produced by StarRocksSQLParser#showHistogramMetaStatement. VisitShowHistogramMetaStatement(ctx *ShowHistogramMetaStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#killAnalyzeStatement. + // Visit a parse tree produced by StarRocksSQLParser#killAnalyzeStatement. VisitKillAnalyzeStatement(ctx *KillAnalyzeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#analyzeProfileStatement. + // Visit a parse tree produced by StarRocksSQLParser#analyzeProfileStatement. VisitAnalyzeProfileStatement(ctx *AnalyzeProfileStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createBaselinePlanStatement. + // Visit a parse tree produced by StarRocksSQLParser#createBaselinePlanStatement. VisitCreateBaselinePlanStatement(ctx *CreateBaselinePlanStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropBaselinePlanStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropBaselinePlanStatement. VisitDropBaselinePlanStatement(ctx *DropBaselinePlanStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showBaselinePlanStatement. + // Visit a parse tree produced by StarRocksSQLParser#showBaselinePlanStatement. VisitShowBaselinePlanStatement(ctx *ShowBaselinePlanStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createResourceGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#createResourceGroupStatement. VisitCreateResourceGroupStatement(ctx *CreateResourceGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropResourceGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropResourceGroupStatement. VisitDropResourceGroupStatement(ctx *DropResourceGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterResourceGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterResourceGroupStatement. VisitAlterResourceGroupStatement(ctx *AlterResourceGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showResourceGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#showResourceGroupStatement. VisitShowResourceGroupStatement(ctx *ShowResourceGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showResourceGroupUsageStatement. + // Visit a parse tree produced by StarRocksSQLParser#showResourceGroupUsageStatement. VisitShowResourceGroupUsageStatement(ctx *ShowResourceGroupUsageStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createResourceStatement. + // Visit a parse tree produced by StarRocksSQLParser#createResourceStatement. VisitCreateResourceStatement(ctx *CreateResourceStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterResourceStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterResourceStatement. VisitAlterResourceStatement(ctx *AlterResourceStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropResourceStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropResourceStatement. VisitDropResourceStatement(ctx *DropResourceStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showResourceStatement. + // Visit a parse tree produced by StarRocksSQLParser#showResourceStatement. VisitShowResourceStatement(ctx *ShowResourceStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#classifier. + // Visit a parse tree produced by StarRocksSQLParser#classifier. VisitClassifier(ctx *ClassifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showFunctionsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showFunctionsStatement. VisitShowFunctionsStatement(ctx *ShowFunctionsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropFunctionStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropFunctionStatement. VisitDropFunctionStatement(ctx *DropFunctionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createFunctionStatement. + // Visit a parse tree produced by StarRocksSQLParser#createFunctionStatement. VisitCreateFunctionStatement(ctx *CreateFunctionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#inlineFunction. + // Visit a parse tree produced by StarRocksSQLParser#inlineFunction. VisitInlineFunction(ctx *InlineFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#typeList. + // Visit a parse tree produced by StarRocksSQLParser#typeList. VisitTypeList(ctx *TypeListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#loadStatement. + // Visit a parse tree produced by StarRocksSQLParser#loadStatement. VisitLoadStatement(ctx *LoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#labelName. + // Visit a parse tree produced by StarRocksSQLParser#labelName. VisitLabelName(ctx *LabelNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dataDescList. + // Visit a parse tree produced by StarRocksSQLParser#dataDescList. VisitDataDescList(ctx *DataDescListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dataDesc. + // Visit a parse tree produced by StarRocksSQLParser#dataDesc. VisitDataDesc(ctx *DataDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#formatProps. + // Visit a parse tree produced by StarRocksSQLParser#formatProps. VisitFormatProps(ctx *FormatPropsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#brokerDesc. + // Visit a parse tree produced by StarRocksSQLParser#brokerDesc. VisitBrokerDesc(ctx *BrokerDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#resourceDesc. + // Visit a parse tree produced by StarRocksSQLParser#resourceDesc. VisitResourceDesc(ctx *ResourceDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#showLoadStatement. VisitShowLoadStatement(ctx *ShowLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showLoadWarningsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showLoadWarningsStatement. VisitShowLoadWarningsStatement(ctx *ShowLoadWarningsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelLoadStatement. VisitCancelLoadStatement(ctx *CancelLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterLoadStatement. VisitAlterLoadStatement(ctx *AlterLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelCompactionStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelCompactionStatement. VisitCancelCompactionStatement(ctx *CancelCompactionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showAuthorStatement. + // Visit a parse tree produced by StarRocksSQLParser#showAuthorStatement. VisitShowAuthorStatement(ctx *ShowAuthorStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showBackendsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showBackendsStatement. VisitShowBackendsStatement(ctx *ShowBackendsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showBrokerStatement. + // Visit a parse tree produced by StarRocksSQLParser#showBrokerStatement. VisitShowBrokerStatement(ctx *ShowBrokerStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCharsetStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCharsetStatement. VisitShowCharsetStatement(ctx *ShowCharsetStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCollationStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCollationStatement. VisitShowCollationStatement(ctx *ShowCollationStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDeleteStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDeleteStatement. VisitShowDeleteStatement(ctx *ShowDeleteStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDynamicPartitionStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDynamicPartitionStatement. VisitShowDynamicPartitionStatement(ctx *ShowDynamicPartitionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showEventsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showEventsStatement. VisitShowEventsStatement(ctx *ShowEventsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showEnginesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showEnginesStatement. VisitShowEnginesStatement(ctx *ShowEnginesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showFrontendsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showFrontendsStatement. VisitShowFrontendsStatement(ctx *ShowFrontendsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showFrontendsDisksStatement. + // Visit a parse tree produced by StarRocksSQLParser#showFrontendsDisksStatement. VisitShowFrontendsDisksStatement(ctx *ShowFrontendsDisksStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPluginsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPluginsStatement. VisitShowPluginsStatement(ctx *ShowPluginsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showRepositoriesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showRepositoriesStatement. VisitShowRepositoriesStatement(ctx *ShowRepositoriesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showOpenTableStatement. + // Visit a parse tree produced by StarRocksSQLParser#showOpenTableStatement. VisitShowOpenTableStatement(ctx *ShowOpenTableStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPrivilegesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPrivilegesStatement. VisitShowPrivilegesStatement(ctx *ShowPrivilegesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showProcedureStatement. + // Visit a parse tree produced by StarRocksSQLParser#showProcedureStatement. VisitShowProcedureStatement(ctx *ShowProcedureStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showProcStatement. + // Visit a parse tree produced by StarRocksSQLParser#showProcStatement. VisitShowProcStatement(ctx *ShowProcStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showProcesslistStatement. + // Visit a parse tree produced by StarRocksSQLParser#showProcesslistStatement. VisitShowProcesslistStatement(ctx *ShowProcesslistStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showProfilelistStatement. + // Visit a parse tree produced by StarRocksSQLParser#showProfilelistStatement. VisitShowProfilelistStatement(ctx *ShowProfilelistStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showRunningQueriesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showRunningQueriesStatement. VisitShowRunningQueriesStatement(ctx *ShowRunningQueriesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showStatusStatement. + // Visit a parse tree produced by StarRocksSQLParser#showStatusStatement. VisitShowStatusStatement(ctx *ShowStatusStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTabletStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTabletStatement. VisitShowTabletStatement(ctx *ShowTabletStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTransactionStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTransactionStatement. VisitShowTransactionStatement(ctx *ShowTransactionStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTriggersStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTriggersStatement. VisitShowTriggersStatement(ctx *ShowTriggersStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showUserPropertyStatement. + // Visit a parse tree produced by StarRocksSQLParser#showUserPropertyStatement. VisitShowUserPropertyStatement(ctx *ShowUserPropertyStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showVariablesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showVariablesStatement. VisitShowVariablesStatement(ctx *ShowVariablesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showWarningStatement. + // Visit a parse tree produced by StarRocksSQLParser#showWarningStatement. VisitShowWarningStatement(ctx *ShowWarningStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#helpStatement. + // Visit a parse tree produced by StarRocksSQLParser#helpStatement. VisitHelpStatement(ctx *HelpStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showQueryProfileStatement. + // Visit a parse tree produced by StarRocksSQLParser#showQueryProfileStatement. VisitShowQueryProfileStatement(ctx *ShowQueryProfileStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showQueryStatsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showQueryStatsStatement. VisitShowQueryStatsStatement(ctx *ShowQueryStatsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showLoadProfileStatement. + // Visit a parse tree produced by StarRocksSQLParser#showLoadProfileStatement. VisitShowLoadProfileStatement(ctx *ShowLoadProfileStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDataSkewStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDataSkewStatement. VisitShowDataSkewStatement(ctx *ShowDataSkewStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDataTypesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDataTypesStatement. VisitShowDataTypesStatement(ctx *ShowDataTypesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showSyncJobStatement. + // Visit a parse tree produced by StarRocksSQLParser#showSyncJobStatement. VisitShowSyncJobStatement(ctx *ShowSyncJobStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPolicyStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPolicyStatement. VisitShowPolicyStatement(ctx *ShowPolicyStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showSqlBlockRuleStatement. + // Visit a parse tree produced by StarRocksSQLParser#showSqlBlockRuleStatement. VisitShowSqlBlockRuleStatement(ctx *ShowSqlBlockRuleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showEncryptKeysStatement. + // Visit a parse tree produced by StarRocksSQLParser#showEncryptKeysStatement. VisitShowEncryptKeysStatement(ctx *ShowEncryptKeysStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateLoadStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateLoadStatement. VisitShowCreateLoadStatement(ctx *ShowCreateLoadStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateRepositoryStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateRepositoryStatement. VisitShowCreateRepositoryStatement(ctx *ShowCreateRepositoryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showLastInsertStatement. + // Visit a parse tree produced by StarRocksSQLParser#showLastInsertStatement. VisitShowLastInsertStatement(ctx *ShowLastInsertStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTableIdStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTableIdStatement. VisitShowTableIdStatement(ctx *ShowTableIdStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDatabaseIdStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDatabaseIdStatement. VisitShowDatabaseIdStatement(ctx *ShowDatabaseIdStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPartitionIdStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPartitionIdStatement. VisitShowPartitionIdStatement(ctx *ShowPartitionIdStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTableStatsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTableStatsStatement. VisitShowTableStatsStatement(ctx *ShowTableStatsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showColumnStatsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showColumnStatsStatement. VisitShowColumnStatsStatement(ctx *ShowColumnStatsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showConvertLightSchemaChangeStatement. + // Visit a parse tree produced by StarRocksSQLParser#showConvertLightSchemaChangeStatement. VisitShowConvertLightSchemaChangeStatement(ctx *ShowConvertLightSchemaChangeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCatalogRecycleBinStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCatalogRecycleBinStatement. VisitShowCatalogRecycleBinStatement(ctx *ShowCatalogRecycleBinStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showTrashStatement. + // Visit a parse tree produced by StarRocksSQLParser#showTrashStatement. VisitShowTrashStatement(ctx *ShowTrashStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showMigrationsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showMigrationsStatement. VisitShowMigrationsStatement(ctx *ShowMigrationsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showWorkloadGroupsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showWorkloadGroupsStatement. VisitShowWorkloadGroupsStatement(ctx *ShowWorkloadGroupsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showJobTaskStatement. + // Visit a parse tree produced by StarRocksSQLParser#showJobTaskStatement. VisitShowJobTaskStatement(ctx *ShowJobTaskStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createUserStatement. + // Visit a parse tree produced by StarRocksSQLParser#createUserStatement. VisitCreateUserStatement(ctx *CreateUserStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropUserStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropUserStatement. VisitDropUserStatement(ctx *DropUserStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterUserStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterUserStatement. VisitAlterUserStatement(ctx *AlterUserStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showUserStatement. + // Visit a parse tree produced by StarRocksSQLParser#showUserStatement. VisitShowUserStatement(ctx *ShowUserStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showAllAuthentication. + // Visit a parse tree produced by StarRocksSQLParser#showAllAuthentication. VisitShowAllAuthentication(ctx *ShowAllAuthenticationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showAuthenticationForUser. + // Visit a parse tree produced by StarRocksSQLParser#showAuthenticationForUser. VisitShowAuthenticationForUser(ctx *ShowAuthenticationForUserContext) interface{} - // Visit a parse tree produced by DorisSQLParser#executeAsStatement. + // Visit a parse tree produced by StarRocksSQLParser#executeAsStatement. VisitExecuteAsStatement(ctx *ExecuteAsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createRoleStatement. + // Visit a parse tree produced by StarRocksSQLParser#createRoleStatement. VisitCreateRoleStatement(ctx *CreateRoleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterRoleStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterRoleStatement. VisitAlterRoleStatement(ctx *AlterRoleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropRoleStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropRoleStatement. VisitDropRoleStatement(ctx *DropRoleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showRolesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showRolesStatement. VisitShowRolesStatement(ctx *ShowRolesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantRoleToUser. + // Visit a parse tree produced by StarRocksSQLParser#grantRoleToUser. VisitGrantRoleToUser(ctx *GrantRoleToUserContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantRoleToRole. + // Visit a parse tree produced by StarRocksSQLParser#grantRoleToRole. VisitGrantRoleToRole(ctx *GrantRoleToRoleContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeRoleFromUser. + // Visit a parse tree produced by StarRocksSQLParser#revokeRoleFromUser. VisitRevokeRoleFromUser(ctx *RevokeRoleFromUserContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeRoleFromRole. + // Visit a parse tree produced by StarRocksSQLParser#revokeRoleFromRole. VisitRevokeRoleFromRole(ctx *RevokeRoleFromRoleContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setRoleStatement. + // Visit a parse tree produced by StarRocksSQLParser#setRoleStatement. VisitSetRoleStatement(ctx *SetRoleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setDefaultRoleStatement. + // Visit a parse tree produced by StarRocksSQLParser#setDefaultRoleStatement. VisitSetDefaultRoleStatement(ctx *SetDefaultRoleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantRevokeClause. + // Visit a parse tree produced by StarRocksSQLParser#grantRevokeClause. VisitGrantRevokeClause(ctx *GrantRevokeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantOnUser. + // Visit a parse tree produced by StarRocksSQLParser#grantOnUser. VisitGrantOnUser(ctx *GrantOnUserContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantOnTableBrief. + // Visit a parse tree produced by StarRocksSQLParser#grantOnTableBrief. VisitGrantOnTableBrief(ctx *GrantOnTableBriefContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantOnFunc. + // Visit a parse tree produced by StarRocksSQLParser#grantOnFunc. VisitGrantOnFunc(ctx *GrantOnFuncContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantOnSystem. + // Visit a parse tree produced by StarRocksSQLParser#grantOnSystem. VisitGrantOnSystem(ctx *GrantOnSystemContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantOnPrimaryObj. + // Visit a parse tree produced by StarRocksSQLParser#grantOnPrimaryObj. VisitGrantOnPrimaryObj(ctx *GrantOnPrimaryObjContext) interface{} - // Visit a parse tree produced by DorisSQLParser#grantOnAll. + // Visit a parse tree produced by StarRocksSQLParser#grantOnAll. VisitGrantOnAll(ctx *GrantOnAllContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeOnUser. + // Visit a parse tree produced by StarRocksSQLParser#revokeOnUser. VisitRevokeOnUser(ctx *RevokeOnUserContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeOnTableBrief. + // Visit a parse tree produced by StarRocksSQLParser#revokeOnTableBrief. VisitRevokeOnTableBrief(ctx *RevokeOnTableBriefContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeOnFunc. + // Visit a parse tree produced by StarRocksSQLParser#revokeOnFunc. VisitRevokeOnFunc(ctx *RevokeOnFuncContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeOnSystem. + // Visit a parse tree produced by StarRocksSQLParser#revokeOnSystem. VisitRevokeOnSystem(ctx *RevokeOnSystemContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeOnPrimaryObj. + // Visit a parse tree produced by StarRocksSQLParser#revokeOnPrimaryObj. VisitRevokeOnPrimaryObj(ctx *RevokeOnPrimaryObjContext) interface{} - // Visit a parse tree produced by DorisSQLParser#revokeOnAll. + // Visit a parse tree produced by StarRocksSQLParser#revokeOnAll. VisitRevokeOnAll(ctx *RevokeOnAllContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showGrantsStatement. + // Visit a parse tree produced by StarRocksSQLParser#showGrantsStatement. VisitShowGrantsStatement(ctx *ShowGrantsStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#authWithoutPlugin. + // Visit a parse tree produced by StarRocksSQLParser#authWithoutPlugin. VisitAuthWithoutPlugin(ctx *AuthWithoutPluginContext) interface{} - // Visit a parse tree produced by DorisSQLParser#authWithPlugin. + // Visit a parse tree produced by StarRocksSQLParser#authWithPlugin. VisitAuthWithPlugin(ctx *AuthWithPluginContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privObjectName. + // Visit a parse tree produced by StarRocksSQLParser#privObjectName. VisitPrivObjectName(ctx *PrivObjectNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privObjectNameList. + // Visit a parse tree produced by StarRocksSQLParser#privObjectNameList. VisitPrivObjectNameList(ctx *PrivObjectNameListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privFunctionObjectNameList. + // Visit a parse tree produced by StarRocksSQLParser#privFunctionObjectNameList. VisitPrivFunctionObjectNameList(ctx *PrivFunctionObjectNameListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privilegeTypeList. + // Visit a parse tree produced by StarRocksSQLParser#privilegeTypeList. VisitPrivilegeTypeList(ctx *PrivilegeTypeListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privilegeType. + // Visit a parse tree produced by StarRocksSQLParser#privilegeType. VisitPrivilegeType(ctx *PrivilegeTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privObjectType. + // Visit a parse tree produced by StarRocksSQLParser#privObjectType. VisitPrivObjectType(ctx *PrivObjectTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#privObjectTypePlural. + // Visit a parse tree produced by StarRocksSQLParser#privObjectTypePlural. VisitPrivObjectTypePlural(ctx *PrivObjectTypePluralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createSecurityIntegrationStatement. + // Visit a parse tree produced by StarRocksSQLParser#createSecurityIntegrationStatement. VisitCreateSecurityIntegrationStatement(ctx *CreateSecurityIntegrationStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterSecurityIntegrationStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterSecurityIntegrationStatement. VisitAlterSecurityIntegrationStatement(ctx *AlterSecurityIntegrationStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropSecurityIntegrationStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropSecurityIntegrationStatement. VisitDropSecurityIntegrationStatement(ctx *DropSecurityIntegrationStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showSecurityIntegrationStatement. + // Visit a parse tree produced by StarRocksSQLParser#showSecurityIntegrationStatement. VisitShowSecurityIntegrationStatement(ctx *ShowSecurityIntegrationStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateSecurityIntegrationStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateSecurityIntegrationStatement. VisitShowCreateSecurityIntegrationStatement(ctx *ShowCreateSecurityIntegrationStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createGroupProviderStatement. + // Visit a parse tree produced by StarRocksSQLParser#createGroupProviderStatement. VisitCreateGroupProviderStatement(ctx *CreateGroupProviderStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropGroupProviderStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropGroupProviderStatement. VisitDropGroupProviderStatement(ctx *DropGroupProviderStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showGroupProvidersStatement. + // Visit a parse tree produced by StarRocksSQLParser#showGroupProvidersStatement. VisitShowGroupProvidersStatement(ctx *ShowGroupProvidersStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showCreateGroupProviderStatement. + // Visit a parse tree produced by StarRocksSQLParser#showCreateGroupProviderStatement. VisitShowCreateGroupProviderStatement(ctx *ShowCreateGroupProviderStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#backupStatement. + // Visit a parse tree produced by StarRocksSQLParser#backupStatement. VisitBackupStatement(ctx *BackupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelBackupStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelBackupStatement. VisitCancelBackupStatement(ctx *CancelBackupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showBackupStatement. + // Visit a parse tree produced by StarRocksSQLParser#showBackupStatement. VisitShowBackupStatement(ctx *ShowBackupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#restoreStatement. + // Visit a parse tree produced by StarRocksSQLParser#restoreStatement. VisitRestoreStatement(ctx *RestoreStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelRestoreStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelRestoreStatement. VisitCancelRestoreStatement(ctx *CancelRestoreStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showRestoreStatement. + // Visit a parse tree produced by StarRocksSQLParser#showRestoreStatement. VisitShowRestoreStatement(ctx *ShowRestoreStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showSnapshotStatement. + // Visit a parse tree produced by StarRocksSQLParser#showSnapshotStatement. VisitShowSnapshotStatement(ctx *ShowSnapshotStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createRepositoryStatement. + // Visit a parse tree produced by StarRocksSQLParser#createRepositoryStatement. VisitCreateRepositoryStatement(ctx *CreateRepositoryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropRepositoryStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropRepositoryStatement. VisitDropRepositoryStatement(ctx *DropRepositoryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addSqlBlackListStatement. + // Visit a parse tree produced by StarRocksSQLParser#addSqlBlackListStatement. VisitAddSqlBlackListStatement(ctx *AddSqlBlackListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#delSqlBlackListStatement. + // Visit a parse tree produced by StarRocksSQLParser#delSqlBlackListStatement. VisitDelSqlBlackListStatement(ctx *DelSqlBlackListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showSqlBlackListStatement. + // Visit a parse tree produced by StarRocksSQLParser#showSqlBlackListStatement. VisitShowSqlBlackListStatement(ctx *ShowSqlBlackListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showWhiteListStatement. + // Visit a parse tree produced by StarRocksSQLParser#showWhiteListStatement. VisitShowWhiteListStatement(ctx *ShowWhiteListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#addBackendBlackListStatement. + // Visit a parse tree produced by StarRocksSQLParser#addBackendBlackListStatement. VisitAddBackendBlackListStatement(ctx *AddBackendBlackListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#delBackendBlackListStatement. + // Visit a parse tree produced by StarRocksSQLParser#delBackendBlackListStatement. VisitDelBackendBlackListStatement(ctx *DelBackendBlackListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showBackendBlackListStatement. + // Visit a parse tree produced by StarRocksSQLParser#showBackendBlackListStatement. VisitShowBackendBlackListStatement(ctx *ShowBackendBlackListStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dataCacheTarget. + // Visit a parse tree produced by StarRocksSQLParser#dataCacheTarget. VisitDataCacheTarget(ctx *DataCacheTargetContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createDataCacheRuleStatement. + // Visit a parse tree produced by StarRocksSQLParser#createDataCacheRuleStatement. VisitCreateDataCacheRuleStatement(ctx *CreateDataCacheRuleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showDataCacheRulesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showDataCacheRulesStatement. VisitShowDataCacheRulesStatement(ctx *ShowDataCacheRulesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropDataCacheRuleStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropDataCacheRuleStatement. VisitDropDataCacheRuleStatement(ctx *DropDataCacheRuleStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#clearDataCacheRulesStatement. + // Visit a parse tree produced by StarRocksSQLParser#clearDataCacheRulesStatement. VisitClearDataCacheRulesStatement(ctx *ClearDataCacheRulesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dataCacheSelectStatement. + // Visit a parse tree produced by StarRocksSQLParser#dataCacheSelectStatement. VisitDataCacheSelectStatement(ctx *DataCacheSelectStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#exportStatement. + // Visit a parse tree produced by StarRocksSQLParser#exportStatement. VisitExportStatement(ctx *ExportStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cancelExportStatement. + // Visit a parse tree produced by StarRocksSQLParser#cancelExportStatement. VisitCancelExportStatement(ctx *CancelExportStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showExportStatement. + // Visit a parse tree produced by StarRocksSQLParser#showExportStatement. VisitShowExportStatement(ctx *ShowExportStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#installPluginStatement. + // Visit a parse tree produced by StarRocksSQLParser#installPluginStatement. VisitInstallPluginStatement(ctx *InstallPluginStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#uninstallPluginStatement. + // Visit a parse tree produced by StarRocksSQLParser#uninstallPluginStatement. VisitUninstallPluginStatement(ctx *UninstallPluginStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createFileStatement. + // Visit a parse tree produced by StarRocksSQLParser#createFileStatement. VisitCreateFileStatement(ctx *CreateFileStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropFileStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropFileStatement. VisitDropFileStatement(ctx *DropFileStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showSmallFilesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showSmallFilesStatement. VisitShowSmallFilesStatement(ctx *ShowSmallFilesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createPipeStatement. + // Visit a parse tree produced by StarRocksSQLParser#createPipeStatement. VisitCreatePipeStatement(ctx *CreatePipeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropPipeStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropPipeStatement. VisitDropPipeStatement(ctx *DropPipeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterPipeClause. + // Visit a parse tree produced by StarRocksSQLParser#alterPipeClause. VisitAlterPipeClause(ctx *AlterPipeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterPipeStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterPipeStatement. VisitAlterPipeStatement(ctx *AlterPipeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#descPipeStatement. + // Visit a parse tree produced by StarRocksSQLParser#descPipeStatement. VisitDescPipeStatement(ctx *DescPipeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPipeStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPipeStatement. VisitShowPipeStatement(ctx *ShowPipeStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setStatement. + // Visit a parse tree produced by StarRocksSQLParser#setStatement. VisitSetStatement(ctx *SetStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setNames. + // Visit a parse tree produced by StarRocksSQLParser#setNames. VisitSetNames(ctx *SetNamesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setPassword. + // Visit a parse tree produced by StarRocksSQLParser#setPassword. VisitSetPassword(ctx *SetPasswordContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setUserVar. + // Visit a parse tree produced by StarRocksSQLParser#setUserVar. VisitSetUserVar(ctx *SetUserVarContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setSystemVar. + // Visit a parse tree produced by StarRocksSQLParser#setSystemVar. VisitSetSystemVar(ctx *SetSystemVarContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setTransaction. + // Visit a parse tree produced by StarRocksSQLParser#setTransaction. VisitSetTransaction(ctx *SetTransactionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#transaction_characteristics. + // Visit a parse tree produced by StarRocksSQLParser#transaction_characteristics. VisitTransaction_characteristics(ctx *Transaction_characteristicsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#transaction_access_mode. + // Visit a parse tree produced by StarRocksSQLParser#transaction_access_mode. VisitTransaction_access_mode(ctx *Transaction_access_modeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#isolation_level. + // Visit a parse tree produced by StarRocksSQLParser#isolation_level. VisitIsolation_level(ctx *Isolation_levelContext) interface{} - // Visit a parse tree produced by DorisSQLParser#isolation_types. + // Visit a parse tree produced by StarRocksSQLParser#isolation_types. VisitIsolation_types(ctx *Isolation_typesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setExprOrDefault. + // Visit a parse tree produced by StarRocksSQLParser#setExprOrDefault. VisitSetExprOrDefault(ctx *SetExprOrDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setUserPropertyStatement. + // Visit a parse tree produced by StarRocksSQLParser#setUserPropertyStatement. VisitSetUserPropertyStatement(ctx *SetUserPropertyStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#roleList. + // Visit a parse tree produced by StarRocksSQLParser#roleList. VisitRoleList(ctx *RoleListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#executeScriptStatement. + // Visit a parse tree produced by StarRocksSQLParser#executeScriptStatement. VisitExecuteScriptStatement(ctx *ExecuteScriptStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#unsupportedStatement. + // Visit a parse tree produced by StarRocksSQLParser#unsupportedStatement. VisitUnsupportedStatement(ctx *UnsupportedStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#lock_item. + // Visit a parse tree produced by StarRocksSQLParser#lock_item. VisitLock_item(ctx *Lock_itemContext) interface{} - // Visit a parse tree produced by DorisSQLParser#lock_type. + // Visit a parse tree produced by StarRocksSQLParser#lock_type. VisitLock_type(ctx *Lock_typeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterPlanAdvisorAddStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterPlanAdvisorAddStatement. VisitAlterPlanAdvisorAddStatement(ctx *AlterPlanAdvisorAddStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#truncatePlanAdvisorStatement. + // Visit a parse tree produced by StarRocksSQLParser#truncatePlanAdvisorStatement. VisitTruncatePlanAdvisorStatement(ctx *TruncatePlanAdvisorStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterPlanAdvisorDropStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterPlanAdvisorDropStatement. VisitAlterPlanAdvisorDropStatement(ctx *AlterPlanAdvisorDropStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showPlanAdvisorStatement. + // Visit a parse tree produced by StarRocksSQLParser#showPlanAdvisorStatement. VisitShowPlanAdvisorStatement(ctx *ShowPlanAdvisorStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createWarehouseStatement. + // Visit a parse tree produced by StarRocksSQLParser#createWarehouseStatement. VisitCreateWarehouseStatement(ctx *CreateWarehouseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropWarehouseStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropWarehouseStatement. VisitDropWarehouseStatement(ctx *DropWarehouseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#suspendWarehouseStatement. + // Visit a parse tree produced by StarRocksSQLParser#suspendWarehouseStatement. VisitSuspendWarehouseStatement(ctx *SuspendWarehouseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#resumeWarehouseStatement. + // Visit a parse tree produced by StarRocksSQLParser#resumeWarehouseStatement. VisitResumeWarehouseStatement(ctx *ResumeWarehouseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setWarehouseStatement. + // Visit a parse tree produced by StarRocksSQLParser#setWarehouseStatement. VisitSetWarehouseStatement(ctx *SetWarehouseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showWarehousesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showWarehousesStatement. VisitShowWarehousesStatement(ctx *ShowWarehousesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showClustersStatement. + // Visit a parse tree produced by StarRocksSQLParser#showClustersStatement. VisitShowClustersStatement(ctx *ShowClustersStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#showNodesStatement. + // Visit a parse tree produced by StarRocksSQLParser#showNodesStatement. VisitShowNodesStatement(ctx *ShowNodesStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterWarehouseStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterWarehouseStatement. VisitAlterWarehouseStatement(ctx *AlterWarehouseStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#createCNGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#createCNGroupStatement. VisitCreateCNGroupStatement(ctx *CreateCNGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dropCNGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#dropCNGroupStatement. VisitDropCNGroupStatement(ctx *DropCNGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#enableCNGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#enableCNGroupStatement. VisitEnableCNGroupStatement(ctx *EnableCNGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#disableCNGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#disableCNGroupStatement. VisitDisableCNGroupStatement(ctx *DisableCNGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#alterCNGroupStatement. + // Visit a parse tree produced by StarRocksSQLParser#alterCNGroupStatement. VisitAlterCNGroupStatement(ctx *AlterCNGroupStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#beginStatement. + // Visit a parse tree produced by StarRocksSQLParser#beginStatement. VisitBeginStatement(ctx *BeginStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#commitStatement. + // Visit a parse tree produced by StarRocksSQLParser#commitStatement. VisitCommitStatement(ctx *CommitStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rollbackStatement. + // Visit a parse tree produced by StarRocksSQLParser#rollbackStatement. VisitRollbackStatement(ctx *RollbackStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#translateStatement. + // Visit a parse tree produced by StarRocksSQLParser#translateStatement. VisitTranslateStatement(ctx *TranslateStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dialect. + // Visit a parse tree produced by StarRocksSQLParser#dialect. VisitDialect(ctx *DialectContext) interface{} - // Visit a parse tree produced by DorisSQLParser#translateSQL. + // Visit a parse tree produced by StarRocksSQLParser#translateSQL. VisitTranslateSQL(ctx *TranslateSQLContext) interface{} - // Visit a parse tree produced by DorisSQLParser#queryStatement. + // Visit a parse tree produced by StarRocksSQLParser#queryStatement. VisitQueryStatement(ctx *QueryStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#queryRelation. + // Visit a parse tree produced by StarRocksSQLParser#queryRelation. VisitQueryRelation(ctx *QueryRelationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#withClause. + // Visit a parse tree produced by StarRocksSQLParser#withClause. VisitWithClause(ctx *WithClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#queryNoWith. + // Visit a parse tree produced by StarRocksSQLParser#queryNoWith. VisitQueryNoWith(ctx *QueryNoWithContext) interface{} - // Visit a parse tree produced by DorisSQLParser#queryPeriod. + // Visit a parse tree produced by StarRocksSQLParser#queryPeriod. VisitQueryPeriod(ctx *QueryPeriodContext) interface{} - // Visit a parse tree produced by DorisSQLParser#periodType. + // Visit a parse tree produced by StarRocksSQLParser#periodType. VisitPeriodType(ctx *PeriodTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#queryWithParentheses. + // Visit a parse tree produced by StarRocksSQLParser#queryWithParentheses. VisitQueryWithParentheses(ctx *QueryWithParenthesesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setOperation. + // Visit a parse tree produced by StarRocksSQLParser#setOperation. VisitSetOperation(ctx *SetOperationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#queryPrimaryDefault. + // Visit a parse tree produced by StarRocksSQLParser#queryPrimaryDefault. VisitQueryPrimaryDefault(ctx *QueryPrimaryDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#subquery. + // Visit a parse tree produced by StarRocksSQLParser#subquery. VisitSubquery(ctx *SubqueryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rowConstructor. + // Visit a parse tree produced by StarRocksSQLParser#rowConstructor. VisitRowConstructor(ctx *RowConstructorContext) interface{} - // Visit a parse tree produced by DorisSQLParser#sortItem. + // Visit a parse tree produced by StarRocksSQLParser#sortItem. VisitSortItem(ctx *SortItemContext) interface{} - // Visit a parse tree produced by DorisSQLParser#limitConstExpr. + // Visit a parse tree produced by StarRocksSQLParser#limitConstExpr. VisitLimitConstExpr(ctx *LimitConstExprContext) interface{} - // Visit a parse tree produced by DorisSQLParser#limitElement. + // Visit a parse tree produced by StarRocksSQLParser#limitElement. VisitLimitElement(ctx *LimitElementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#querySpecification. + // Visit a parse tree produced by StarRocksSQLParser#querySpecification. VisitQuerySpecification(ctx *QuerySpecificationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#from. + // Visit a parse tree produced by StarRocksSQLParser#from. VisitFrom(ctx *FromContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dual. + // Visit a parse tree produced by StarRocksSQLParser#dual. VisitDual(ctx *DualContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rollup. + // Visit a parse tree produced by StarRocksSQLParser#rollup. VisitRollup(ctx *RollupContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cube. + // Visit a parse tree produced by StarRocksSQLParser#cube. VisitCube(ctx *CubeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#multipleGroupingSets. + // Visit a parse tree produced by StarRocksSQLParser#multipleGroupingSets. VisitMultipleGroupingSets(ctx *MultipleGroupingSetsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#singleGroupingSet. + // Visit a parse tree produced by StarRocksSQLParser#singleGroupingSet. VisitSingleGroupingSet(ctx *SingleGroupingSetContext) interface{} - // Visit a parse tree produced by DorisSQLParser#groupingSet. + // Visit a parse tree produced by StarRocksSQLParser#groupingSet. VisitGroupingSet(ctx *GroupingSetContext) interface{} - // Visit a parse tree produced by DorisSQLParser#commonTableExpression. + // Visit a parse tree produced by StarRocksSQLParser#commonTableExpression. VisitCommonTableExpression(ctx *CommonTableExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#setQuantifier. + // Visit a parse tree produced by StarRocksSQLParser#setQuantifier. VisitSetQuantifier(ctx *SetQuantifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#selectSingle. + // Visit a parse tree produced by StarRocksSQLParser#selectSingle. VisitSelectSingle(ctx *SelectSingleContext) interface{} - // Visit a parse tree produced by DorisSQLParser#selectAll. + // Visit a parse tree produced by StarRocksSQLParser#selectAll. VisitSelectAll(ctx *SelectAllContext) interface{} - // Visit a parse tree produced by DorisSQLParser#excludeClause. + // Visit a parse tree produced by StarRocksSQLParser#excludeClause. VisitExcludeClause(ctx *ExcludeClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#relations. + // Visit a parse tree produced by StarRocksSQLParser#relations. VisitRelations(ctx *RelationsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#relationLateralView. + // Visit a parse tree produced by StarRocksSQLParser#relationLateralView. VisitRelationLateralView(ctx *RelationLateralViewContext) interface{} - // Visit a parse tree produced by DorisSQLParser#lateralView. + // Visit a parse tree produced by StarRocksSQLParser#lateralView. VisitLateralView(ctx *LateralViewContext) interface{} - // Visit a parse tree produced by DorisSQLParser#generatorFunction. + // Visit a parse tree produced by StarRocksSQLParser#generatorFunction. VisitGeneratorFunction(ctx *GeneratorFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#relation. + // Visit a parse tree produced by StarRocksSQLParser#relation. VisitRelation(ctx *RelationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tableAtom. + // Visit a parse tree produced by StarRocksSQLParser#tableAtom. VisitTableAtom(ctx *TableAtomContext) interface{} - // Visit a parse tree produced by DorisSQLParser#inlineTable. + // Visit a parse tree produced by StarRocksSQLParser#inlineTable. VisitInlineTable(ctx *InlineTableContext) interface{} - // Visit a parse tree produced by DorisSQLParser#subqueryWithAlias. + // Visit a parse tree produced by StarRocksSQLParser#subqueryWithAlias. VisitSubqueryWithAlias(ctx *SubqueryWithAliasContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tableFunction. + // Visit a parse tree produced by StarRocksSQLParser#tableFunction. VisitTableFunction(ctx *TableFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#normalizedTableFunction. + // Visit a parse tree produced by StarRocksSQLParser#normalizedTableFunction. VisitNormalizedTableFunction(ctx *NormalizedTableFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#fileTableFunction. + // Visit a parse tree produced by StarRocksSQLParser#fileTableFunction. VisitFileTableFunction(ctx *FileTableFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#parenthesizedRelation. + // Visit a parse tree produced by StarRocksSQLParser#parenthesizedRelation. VisitParenthesizedRelation(ctx *ParenthesizedRelationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#pivotClause. + // Visit a parse tree produced by StarRocksSQLParser#pivotClause. VisitPivotClause(ctx *PivotClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#pivotAggregationExpression. + // Visit a parse tree produced by StarRocksSQLParser#pivotAggregationExpression. VisitPivotAggregationExpression(ctx *PivotAggregationExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#pivotValue. + // Visit a parse tree produced by StarRocksSQLParser#pivotValue. VisitPivotValue(ctx *PivotValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#sampleClause. + // Visit a parse tree produced by StarRocksSQLParser#sampleClause. VisitSampleClause(ctx *SampleClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#argumentList. + // Visit a parse tree produced by StarRocksSQLParser#argumentList. VisitArgumentList(ctx *ArgumentListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#namedArgumentList. + // Visit a parse tree produced by StarRocksSQLParser#namedArgumentList. VisitNamedArgumentList(ctx *NamedArgumentListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#namedArguments. + // Visit a parse tree produced by StarRocksSQLParser#namedArguments. VisitNamedArguments(ctx *NamedArgumentsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#joinRelation. + // Visit a parse tree produced by StarRocksSQLParser#joinRelation. VisitJoinRelation(ctx *JoinRelationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#crossOrInnerJoinType. + // Visit a parse tree produced by StarRocksSQLParser#crossOrInnerJoinType. VisitCrossOrInnerJoinType(ctx *CrossOrInnerJoinTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#outerAndSemiJoinType. + // Visit a parse tree produced by StarRocksSQLParser#outerAndSemiJoinType. VisitOuterAndSemiJoinType(ctx *OuterAndSemiJoinTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#bracketHint. + // Visit a parse tree produced by StarRocksSQLParser#bracketHint. VisitBracketHint(ctx *BracketHintContext) interface{} - // Visit a parse tree produced by DorisSQLParser#hintMap. + // Visit a parse tree produced by StarRocksSQLParser#hintMap. VisitHintMap(ctx *HintMapContext) interface{} - // Visit a parse tree produced by DorisSQLParser#joinCriteria. + // Visit a parse tree produced by StarRocksSQLParser#joinCriteria. VisitJoinCriteria(ctx *JoinCriteriaContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnAliases. + // Visit a parse tree produced by StarRocksSQLParser#columnAliases. VisitColumnAliases(ctx *ColumnAliasesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnAliasesWithoutParentheses. + // Visit a parse tree produced by StarRocksSQLParser#columnAliasesWithoutParentheses. VisitColumnAliasesWithoutParentheses(ctx *ColumnAliasesWithoutParenthesesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionNames. + // Visit a parse tree produced by StarRocksSQLParser#partitionNames. VisitPartitionNames(ctx *PartitionNamesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#keyPartitionList. + // Visit a parse tree produced by StarRocksSQLParser#keyPartitionList. VisitKeyPartitionList(ctx *KeyPartitionListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tabletList. + // Visit a parse tree produced by StarRocksSQLParser#tabletList. VisitTabletList(ctx *TabletListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#prepareStatement. + // Visit a parse tree produced by StarRocksSQLParser#prepareStatement. VisitPrepareStatement(ctx *PrepareStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#prepareSql. + // Visit a parse tree produced by StarRocksSQLParser#prepareSql. VisitPrepareSql(ctx *PrepareSqlContext) interface{} - // Visit a parse tree produced by DorisSQLParser#executeStatement. + // Visit a parse tree produced by StarRocksSQLParser#executeStatement. VisitExecuteStatement(ctx *ExecuteStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#deallocateStatement. + // Visit a parse tree produced by StarRocksSQLParser#deallocateStatement. VisitDeallocateStatement(ctx *DeallocateStatementContext) interface{} - // Visit a parse tree produced by DorisSQLParser#replicaList. + // Visit a parse tree produced by StarRocksSQLParser#replicaList. VisitReplicaList(ctx *ReplicaListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#expressionsWithDefault. + // Visit a parse tree produced by StarRocksSQLParser#expressionsWithDefault. VisitExpressionsWithDefault(ctx *ExpressionsWithDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#expressionOrDefault. + // Visit a parse tree produced by StarRocksSQLParser#expressionOrDefault. VisitExpressionOrDefault(ctx *ExpressionOrDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#mapExpressionList. + // Visit a parse tree produced by StarRocksSQLParser#mapExpressionList. VisitMapExpressionList(ctx *MapExpressionListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#mapExpression. + // Visit a parse tree produced by StarRocksSQLParser#mapExpression. VisitMapExpression(ctx *MapExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#expressionSingleton. + // Visit a parse tree produced by StarRocksSQLParser#expressionSingleton. VisitExpressionSingleton(ctx *ExpressionSingletonContext) interface{} - // Visit a parse tree produced by DorisSQLParser#expressionDefault. + // Visit a parse tree produced by StarRocksSQLParser#expressionDefault. VisitExpressionDefault(ctx *ExpressionDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#logicalNot. + // Visit a parse tree produced by StarRocksSQLParser#logicalNot. VisitLogicalNot(ctx *LogicalNotContext) interface{} - // Visit a parse tree produced by DorisSQLParser#logicalBinary. + // Visit a parse tree produced by StarRocksSQLParser#logicalBinary. VisitLogicalBinary(ctx *LogicalBinaryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#expressionList. + // Visit a parse tree produced by StarRocksSQLParser#expressionList. VisitExpressionList(ctx *ExpressionListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#comparison. + // Visit a parse tree produced by StarRocksSQLParser#comparison. VisitComparison(ctx *ComparisonContext) interface{} - // Visit a parse tree produced by DorisSQLParser#booleanExpressionDefault. + // Visit a parse tree produced by StarRocksSQLParser#booleanExpressionDefault. VisitBooleanExpressionDefault(ctx *BooleanExpressionDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#isNull. + // Visit a parse tree produced by StarRocksSQLParser#isNull. VisitIsNull(ctx *IsNullContext) interface{} - // Visit a parse tree produced by DorisSQLParser#scalarSubquery. + // Visit a parse tree produced by StarRocksSQLParser#scalarSubquery. VisitScalarSubquery(ctx *ScalarSubqueryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#predicate. + // Visit a parse tree produced by StarRocksSQLParser#predicate. VisitPredicate(ctx *PredicateContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tupleInSubquery. + // Visit a parse tree produced by StarRocksSQLParser#tupleInSubquery. VisitTupleInSubquery(ctx *TupleInSubqueryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#inSubquery. + // Visit a parse tree produced by StarRocksSQLParser#inSubquery. VisitInSubquery(ctx *InSubqueryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#inList. + // Visit a parse tree produced by StarRocksSQLParser#inList. VisitInList(ctx *InListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#between. + // Visit a parse tree produced by StarRocksSQLParser#between. VisitBetween(ctx *BetweenContext) interface{} - // Visit a parse tree produced by DorisSQLParser#like. + // Visit a parse tree produced by StarRocksSQLParser#like. VisitLike(ctx *LikeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#valueExpressionDefault. + // Visit a parse tree produced by StarRocksSQLParser#valueExpressionDefault. VisitValueExpressionDefault(ctx *ValueExpressionDefaultContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arithmeticBinary. + // Visit a parse tree produced by StarRocksSQLParser#arithmeticBinary. VisitArithmeticBinary(ctx *ArithmeticBinaryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dereference. + // Visit a parse tree produced by StarRocksSQLParser#dereference. VisitDereference(ctx *DereferenceContext) interface{} - // Visit a parse tree produced by DorisSQLParser#odbcFunctionCallExpression. + // Visit a parse tree produced by StarRocksSQLParser#odbcFunctionCallExpression. VisitOdbcFunctionCallExpression(ctx *OdbcFunctionCallExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#matchExpr. + // Visit a parse tree produced by StarRocksSQLParser#matchExpr. VisitMatchExpr(ctx *MatchExprContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnRef. + // Visit a parse tree produced by StarRocksSQLParser#columnRef. VisitColumnRef(ctx *ColumnRefContext) interface{} - // Visit a parse tree produced by DorisSQLParser#convert. + // Visit a parse tree produced by StarRocksSQLParser#convert. VisitConvert(ctx *ConvertContext) interface{} - // Visit a parse tree produced by DorisSQLParser#collectionSubscript. + // Visit a parse tree produced by StarRocksSQLParser#collectionSubscript. VisitCollectionSubscript(ctx *CollectionSubscriptContext) interface{} - // Visit a parse tree produced by DorisSQLParser#literal. + // Visit a parse tree produced by StarRocksSQLParser#literal. VisitLiteral(ctx *LiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#cast. + // Visit a parse tree produced by StarRocksSQLParser#cast. VisitCast(ctx *CastContext) interface{} - // Visit a parse tree produced by DorisSQLParser#parenthesizedExpression. + // Visit a parse tree produced by StarRocksSQLParser#parenthesizedExpression. VisitParenthesizedExpression(ctx *ParenthesizedExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#userVariableExpression. + // Visit a parse tree produced by StarRocksSQLParser#userVariableExpression. VisitUserVariableExpression(ctx *UserVariableExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#functionCallExpression. + // Visit a parse tree produced by StarRocksSQLParser#functionCallExpression. VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#simpleCase. + // Visit a parse tree produced by StarRocksSQLParser#simpleCase. VisitSimpleCase(ctx *SimpleCaseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arrowExpression. + // Visit a parse tree produced by StarRocksSQLParser#arrowExpression. VisitArrowExpression(ctx *ArrowExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arrayExpr. + // Visit a parse tree produced by StarRocksSQLParser#arrayExpr. VisitArrayExpr(ctx *ArrayExprContext) interface{} - // Visit a parse tree produced by DorisSQLParser#systemVariableExpression. + // Visit a parse tree produced by StarRocksSQLParser#systemVariableExpression. VisitSystemVariableExpression(ctx *SystemVariableExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#concat. + // Visit a parse tree produced by StarRocksSQLParser#concat. VisitConcat(ctx *ConcatContext) interface{} - // Visit a parse tree produced by DorisSQLParser#subqueryExpression. + // Visit a parse tree produced by StarRocksSQLParser#subqueryExpression. VisitSubqueryExpression(ctx *SubqueryExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#lambdaFunctionExpr. + // Visit a parse tree produced by StarRocksSQLParser#lambdaFunctionExpr. VisitLambdaFunctionExpr(ctx *LambdaFunctionExprContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dictionaryGetExpr. + // Visit a parse tree produced by StarRocksSQLParser#dictionaryGetExpr. VisitDictionaryGetExpr(ctx *DictionaryGetExprContext) interface{} - // Visit a parse tree produced by DorisSQLParser#collate. + // Visit a parse tree produced by StarRocksSQLParser#collate. VisitCollate(ctx *CollateContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arrayConstructor. + // Visit a parse tree produced by StarRocksSQLParser#arrayConstructor. VisitArrayConstructor(ctx *ArrayConstructorContext) interface{} - // Visit a parse tree produced by DorisSQLParser#mapConstructor. + // Visit a parse tree produced by StarRocksSQLParser#mapConstructor. VisitMapConstructor(ctx *MapConstructorContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arraySlice. + // Visit a parse tree produced by StarRocksSQLParser#arraySlice. VisitArraySlice(ctx *ArraySliceContext) interface{} - // Visit a parse tree produced by DorisSQLParser#exists. + // Visit a parse tree produced by StarRocksSQLParser#exists. VisitExists(ctx *ExistsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#searchedCase. + // Visit a parse tree produced by StarRocksSQLParser#searchedCase. VisitSearchedCase(ctx *SearchedCaseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arithmeticUnary. + // Visit a parse tree produced by StarRocksSQLParser#arithmeticUnary. VisitArithmeticUnary(ctx *ArithmeticUnaryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#nullLiteral. + // Visit a parse tree produced by StarRocksSQLParser#nullLiteral. VisitNullLiteral(ctx *NullLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#booleanLiteral. + // Visit a parse tree produced by StarRocksSQLParser#booleanLiteral. VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#numericLiteral. + // Visit a parse tree produced by StarRocksSQLParser#numericLiteral. VisitNumericLiteral(ctx *NumericLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#dateLiteral. + // Visit a parse tree produced by StarRocksSQLParser#dateLiteral. VisitDateLiteral(ctx *DateLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#stringLiteral. + // Visit a parse tree produced by StarRocksSQLParser#stringLiteral. VisitStringLiteral(ctx *StringLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#intervalLiteral. + // Visit a parse tree produced by StarRocksSQLParser#intervalLiteral. VisitIntervalLiteral(ctx *IntervalLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#unitBoundaryLiteral. + // Visit a parse tree produced by StarRocksSQLParser#unitBoundaryLiteral. VisitUnitBoundaryLiteral(ctx *UnitBoundaryLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#binaryLiteral. + // Visit a parse tree produced by StarRocksSQLParser#binaryLiteral. VisitBinaryLiteral(ctx *BinaryLiteralContext) interface{} - // Visit a parse tree produced by DorisSQLParser#Parameter. + // Visit a parse tree produced by StarRocksSQLParser#Parameter. VisitParameter(ctx *ParameterContext) interface{} - // Visit a parse tree produced by DorisSQLParser#extract. + // Visit a parse tree produced by StarRocksSQLParser#extract. VisitExtract(ctx *ExtractContext) interface{} - // Visit a parse tree produced by DorisSQLParser#groupingOperation. + // Visit a parse tree produced by StarRocksSQLParser#groupingOperation. VisitGroupingOperation(ctx *GroupingOperationContext) interface{} - // Visit a parse tree produced by DorisSQLParser#informationFunction. + // Visit a parse tree produced by StarRocksSQLParser#informationFunction. VisitInformationFunction(ctx *InformationFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#specialDateTime. + // Visit a parse tree produced by StarRocksSQLParser#specialDateTime. VisitSpecialDateTime(ctx *SpecialDateTimeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#specialFunction. + // Visit a parse tree produced by StarRocksSQLParser#specialFunction. VisitSpecialFunction(ctx *SpecialFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#aggregationFunctionCall. + // Visit a parse tree produced by StarRocksSQLParser#aggregationFunctionCall. VisitAggregationFunctionCall(ctx *AggregationFunctionCallContext) interface{} - // Visit a parse tree produced by DorisSQLParser#windowFunctionCall. + // Visit a parse tree produced by StarRocksSQLParser#windowFunctionCall. VisitWindowFunctionCall(ctx *WindowFunctionCallContext) interface{} - // Visit a parse tree produced by DorisSQLParser#translateFunctionCall. + // Visit a parse tree produced by StarRocksSQLParser#translateFunctionCall. VisitTranslateFunctionCall(ctx *TranslateFunctionCallContext) interface{} - // Visit a parse tree produced by DorisSQLParser#simpleFunctionCall. + // Visit a parse tree produced by StarRocksSQLParser#simpleFunctionCall. VisitSimpleFunctionCall(ctx *SimpleFunctionCallContext) interface{} - // Visit a parse tree produced by DorisSQLParser#aggregationFunction. + // Visit a parse tree produced by StarRocksSQLParser#aggregationFunction. VisitAggregationFunction(ctx *AggregationFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#userVariable. + // Visit a parse tree produced by StarRocksSQLParser#userVariable. VisitUserVariable(ctx *UserVariableContext) interface{} - // Visit a parse tree produced by DorisSQLParser#systemVariable. + // Visit a parse tree produced by StarRocksSQLParser#systemVariable. VisitSystemVariable(ctx *SystemVariableContext) interface{} - // Visit a parse tree produced by DorisSQLParser#columnReference. + // Visit a parse tree produced by StarRocksSQLParser#columnReference. VisitColumnReference(ctx *ColumnReferenceContext) interface{} - // Visit a parse tree produced by DorisSQLParser#informationFunctionExpression. + // Visit a parse tree produced by StarRocksSQLParser#informationFunctionExpression. VisitInformationFunctionExpression(ctx *InformationFunctionExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#specialDateTimeExpression. + // Visit a parse tree produced by StarRocksSQLParser#specialDateTimeExpression. VisitSpecialDateTimeExpression(ctx *SpecialDateTimeExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#specialFunctionExpression. + // Visit a parse tree produced by StarRocksSQLParser#specialFunctionExpression. VisitSpecialFunctionExpression(ctx *SpecialFunctionExpressionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#windowFunction. + // Visit a parse tree produced by StarRocksSQLParser#windowFunction. VisitWindowFunction(ctx *WindowFunctionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#whenClause. + // Visit a parse tree produced by StarRocksSQLParser#whenClause. VisitWhenClause(ctx *WhenClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#over. + // Visit a parse tree produced by StarRocksSQLParser#over. VisitOver(ctx *OverContext) interface{} - // Visit a parse tree produced by DorisSQLParser#ignoreNulls. + // Visit a parse tree produced by StarRocksSQLParser#ignoreNulls. VisitIgnoreNulls(ctx *IgnoreNullsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#windowFrame. + // Visit a parse tree produced by StarRocksSQLParser#windowFrame. VisitWindowFrame(ctx *WindowFrameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#unboundedFrame. + // Visit a parse tree produced by StarRocksSQLParser#unboundedFrame. VisitUnboundedFrame(ctx *UnboundedFrameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#currentRowBound. + // Visit a parse tree produced by StarRocksSQLParser#currentRowBound. VisitCurrentRowBound(ctx *CurrentRowBoundContext) interface{} - // Visit a parse tree produced by DorisSQLParser#boundedFrame. + // Visit a parse tree produced by StarRocksSQLParser#boundedFrame. VisitBoundedFrame(ctx *BoundedFrameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#backupRestoreObjectDesc. + // Visit a parse tree produced by StarRocksSQLParser#backupRestoreObjectDesc. VisitBackupRestoreObjectDesc(ctx *BackupRestoreObjectDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tableDesc. + // Visit a parse tree produced by StarRocksSQLParser#tableDesc. VisitTableDesc(ctx *TableDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#backupRestoreTableDesc. + // Visit a parse tree produced by StarRocksSQLParser#backupRestoreTableDesc. VisitBackupRestoreTableDesc(ctx *BackupRestoreTableDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#explainDesc. + // Visit a parse tree produced by StarRocksSQLParser#explainDesc. VisitExplainDesc(ctx *ExplainDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#optimizerTrace. + // Visit a parse tree produced by StarRocksSQLParser#optimizerTrace. VisitOptimizerTrace(ctx *OptimizerTraceContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionExpr. + // Visit a parse tree produced by StarRocksSQLParser#partitionExpr. VisitPartitionExpr(ctx *PartitionExprContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionDesc. + // Visit a parse tree produced by StarRocksSQLParser#partitionDesc. VisitPartitionDesc(ctx *PartitionDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#listPartitionDesc. + // Visit a parse tree produced by StarRocksSQLParser#listPartitionDesc. VisitListPartitionDesc(ctx *ListPartitionDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#singleItemListPartitionDesc. + // Visit a parse tree produced by StarRocksSQLParser#singleItemListPartitionDesc. VisitSingleItemListPartitionDesc(ctx *SingleItemListPartitionDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#multiItemListPartitionDesc. + // Visit a parse tree produced by StarRocksSQLParser#multiItemListPartitionDesc. VisitMultiItemListPartitionDesc(ctx *MultiItemListPartitionDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#multiListPartitionValues. + // Visit a parse tree produced by StarRocksSQLParser#multiListPartitionValues. VisitMultiListPartitionValues(ctx *MultiListPartitionValuesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#singleListPartitionValues. + // Visit a parse tree produced by StarRocksSQLParser#singleListPartitionValues. VisitSingleListPartitionValues(ctx *SingleListPartitionValuesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#listPartitionValues. + // Visit a parse tree produced by StarRocksSQLParser#listPartitionValues. VisitListPartitionValues(ctx *ListPartitionValuesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#listPartitionValue. + // Visit a parse tree produced by StarRocksSQLParser#listPartitionValue. VisitListPartitionValue(ctx *ListPartitionValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#stringList. + // Visit a parse tree produced by StarRocksSQLParser#stringList. VisitStringList(ctx *StringListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#literalExpressionList. + // Visit a parse tree produced by StarRocksSQLParser#literalExpressionList. VisitLiteralExpressionList(ctx *LiteralExpressionListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#rangePartitionDesc. + // Visit a parse tree produced by StarRocksSQLParser#rangePartitionDesc. VisitRangePartitionDesc(ctx *RangePartitionDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#singleRangePartition. + // Visit a parse tree produced by StarRocksSQLParser#singleRangePartition. VisitSingleRangePartition(ctx *SingleRangePartitionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#multiRangePartition. + // Visit a parse tree produced by StarRocksSQLParser#multiRangePartition. VisitMultiRangePartition(ctx *MultiRangePartitionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionRangeDesc. + // Visit a parse tree produced by StarRocksSQLParser#partitionRangeDesc. VisitPartitionRangeDesc(ctx *PartitionRangeDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionKeyDesc. + // Visit a parse tree produced by StarRocksSQLParser#partitionKeyDesc. VisitPartitionKeyDesc(ctx *PartitionKeyDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionValueList. + // Visit a parse tree produced by StarRocksSQLParser#partitionValueList. VisitPartitionValueList(ctx *PartitionValueListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#keyPartition. + // Visit a parse tree produced by StarRocksSQLParser#keyPartition. VisitKeyPartition(ctx *KeyPartitionContext) interface{} - // Visit a parse tree produced by DorisSQLParser#partitionValue. + // Visit a parse tree produced by StarRocksSQLParser#partitionValue. VisitPartitionValue(ctx *PartitionValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#distributionClause. + // Visit a parse tree produced by StarRocksSQLParser#distributionClause. VisitDistributionClause(ctx *DistributionClauseContext) interface{} - // Visit a parse tree produced by DorisSQLParser#distributionDesc. + // Visit a parse tree produced by StarRocksSQLParser#distributionDesc. VisitDistributionDesc(ctx *DistributionDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#refreshSchemeDesc. + // Visit a parse tree produced by StarRocksSQLParser#refreshSchemeDesc. VisitRefreshSchemeDesc(ctx *RefreshSchemeDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#statusDesc. + // Visit a parse tree produced by StarRocksSQLParser#statusDesc. VisitStatusDesc(ctx *StatusDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#properties. + // Visit a parse tree produced by StarRocksSQLParser#properties. VisitProperties(ctx *PropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#extProperties. + // Visit a parse tree produced by StarRocksSQLParser#extProperties. VisitExtProperties(ctx *ExtPropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#propertyList. + // Visit a parse tree produced by StarRocksSQLParser#propertyList. VisitPropertyList(ctx *PropertyListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#userPropertyList. + // Visit a parse tree produced by StarRocksSQLParser#userPropertyList. VisitUserPropertyList(ctx *UserPropertyListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#property. + // Visit a parse tree produced by StarRocksSQLParser#property. VisitProperty(ctx *PropertyContext) interface{} - // Visit a parse tree produced by DorisSQLParser#inlineProperties. + // Visit a parse tree produced by StarRocksSQLParser#inlineProperties. VisitInlineProperties(ctx *InlinePropertiesContext) interface{} - // Visit a parse tree produced by DorisSQLParser#inlineProperty. + // Visit a parse tree produced by StarRocksSQLParser#inlineProperty. VisitInlineProperty(ctx *InlinePropertyContext) interface{} - // Visit a parse tree produced by DorisSQLParser#varType. + // Visit a parse tree produced by StarRocksSQLParser#varType. VisitVarType(ctx *VarTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#comment. + // Visit a parse tree produced by StarRocksSQLParser#comment. VisitComment(ctx *CommentContext) interface{} - // Visit a parse tree produced by DorisSQLParser#outfile. + // Visit a parse tree produced by StarRocksSQLParser#outfile. VisitOutfile(ctx *OutfileContext) interface{} - // Visit a parse tree produced by DorisSQLParser#fileFormat. + // Visit a parse tree produced by StarRocksSQLParser#fileFormat. VisitFileFormat(ctx *FileFormatContext) interface{} - // Visit a parse tree produced by DorisSQLParser#string. + // Visit a parse tree produced by StarRocksSQLParser#string. VisitString(ctx *StringContext) interface{} - // Visit a parse tree produced by DorisSQLParser#binary. + // Visit a parse tree produced by StarRocksSQLParser#binary. VisitBinary(ctx *BinaryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#comparisonOperator. + // Visit a parse tree produced by StarRocksSQLParser#comparisonOperator. VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{} - // Visit a parse tree produced by DorisSQLParser#booleanValue. + // Visit a parse tree produced by StarRocksSQLParser#booleanValue. VisitBooleanValue(ctx *BooleanValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#interval. + // Visit a parse tree produced by StarRocksSQLParser#interval. VisitInterval(ctx *IntervalContext) interface{} - // Visit a parse tree produced by DorisSQLParser#taskInterval. + // Visit a parse tree produced by StarRocksSQLParser#taskInterval. VisitTaskInterval(ctx *TaskIntervalContext) interface{} - // Visit a parse tree produced by DorisSQLParser#taskUnitIdentifier. + // Visit a parse tree produced by StarRocksSQLParser#taskUnitIdentifier. VisitTaskUnitIdentifier(ctx *TaskUnitIdentifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#unitIdentifier. + // Visit a parse tree produced by StarRocksSQLParser#unitIdentifier. VisitUnitIdentifier(ctx *UnitIdentifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#unitBoundary. + // Visit a parse tree produced by StarRocksSQLParser#unitBoundary. VisitUnitBoundary(ctx *UnitBoundaryContext) interface{} - // Visit a parse tree produced by DorisSQLParser#type. + // Visit a parse tree produced by StarRocksSQLParser#type. VisitType(ctx *TypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#arrayType. + // Visit a parse tree produced by StarRocksSQLParser#arrayType. VisitArrayType(ctx *ArrayTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#mapType. + // Visit a parse tree produced by StarRocksSQLParser#mapType. VisitMapType(ctx *MapTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#subfieldDesc. + // Visit a parse tree produced by StarRocksSQLParser#subfieldDesc. VisitSubfieldDesc(ctx *SubfieldDescContext) interface{} - // Visit a parse tree produced by DorisSQLParser#subfieldDescs. + // Visit a parse tree produced by StarRocksSQLParser#subfieldDescs. VisitSubfieldDescs(ctx *SubfieldDescsContext) interface{} - // Visit a parse tree produced by DorisSQLParser#structType. + // Visit a parse tree produced by StarRocksSQLParser#structType. VisitStructType(ctx *StructTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#typeParameter. + // Visit a parse tree produced by StarRocksSQLParser#typeParameter. VisitTypeParameter(ctx *TypeParameterContext) interface{} - // Visit a parse tree produced by DorisSQLParser#baseType. + // Visit a parse tree produced by StarRocksSQLParser#baseType. VisitBaseType(ctx *BaseTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#decimalType. + // Visit a parse tree produced by StarRocksSQLParser#decimalType. VisitDecimalType(ctx *DecimalTypeContext) interface{} - // Visit a parse tree produced by DorisSQLParser#qualifiedName. + // Visit a parse tree produced by StarRocksSQLParser#qualifiedName. VisitQualifiedName(ctx *QualifiedNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#tableName. + // Visit a parse tree produced by StarRocksSQLParser#tableName. VisitTableName(ctx *TableNameContext) interface{} - // Visit a parse tree produced by DorisSQLParser#writeBranch. + // Visit a parse tree produced by StarRocksSQLParser#writeBranch. VisitWriteBranch(ctx *WriteBranchContext) interface{} - // Visit a parse tree produced by DorisSQLParser#unquotedIdentifier. + // Visit a parse tree produced by StarRocksSQLParser#unquotedIdentifier. VisitUnquotedIdentifier(ctx *UnquotedIdentifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#digitIdentifier. + // Visit a parse tree produced by StarRocksSQLParser#digitIdentifier. VisitDigitIdentifier(ctx *DigitIdentifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#backQuotedIdentifier. + // Visit a parse tree produced by StarRocksSQLParser#backQuotedIdentifier. VisitBackQuotedIdentifier(ctx *BackQuotedIdentifierContext) interface{} - // Visit a parse tree produced by DorisSQLParser#identifierWithAlias. + // Visit a parse tree produced by StarRocksSQLParser#identifierWithAlias. VisitIdentifierWithAlias(ctx *IdentifierWithAliasContext) interface{} - // Visit a parse tree produced by DorisSQLParser#identifierWithAliasList. + // Visit a parse tree produced by StarRocksSQLParser#identifierWithAliasList. VisitIdentifierWithAliasList(ctx *IdentifierWithAliasListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#identifierList. + // Visit a parse tree produced by StarRocksSQLParser#identifierList. VisitIdentifierList(ctx *IdentifierListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#identifierOrString. + // Visit a parse tree produced by StarRocksSQLParser#identifierOrString. VisitIdentifierOrString(ctx *IdentifierOrStringContext) interface{} - // Visit a parse tree produced by DorisSQLParser#identifierOrStringList. + // Visit a parse tree produced by StarRocksSQLParser#identifierOrStringList. VisitIdentifierOrStringList(ctx *IdentifierOrStringListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#identifierOrStringOrStar. + // Visit a parse tree produced by StarRocksSQLParser#identifierOrStringOrStar. VisitIdentifierOrStringOrStar(ctx *IdentifierOrStringOrStarContext) interface{} - // Visit a parse tree produced by DorisSQLParser#userWithoutHost. + // Visit a parse tree produced by StarRocksSQLParser#userWithoutHost. VisitUserWithoutHost(ctx *UserWithoutHostContext) interface{} - // Visit a parse tree produced by DorisSQLParser#userWithHost. + // Visit a parse tree produced by StarRocksSQLParser#userWithHost. VisitUserWithHost(ctx *UserWithHostContext) interface{} - // Visit a parse tree produced by DorisSQLParser#userWithHostAndBlanket. + // Visit a parse tree produced by StarRocksSQLParser#userWithHostAndBlanket. VisitUserWithHostAndBlanket(ctx *UserWithHostAndBlanketContext) interface{} - // Visit a parse tree produced by DorisSQLParser#assignment. + // Visit a parse tree produced by StarRocksSQLParser#assignment. VisitAssignment(ctx *AssignmentContext) interface{} - // Visit a parse tree produced by DorisSQLParser#assignmentList. + // Visit a parse tree produced by StarRocksSQLParser#assignmentList. VisitAssignmentList(ctx *AssignmentListContext) interface{} - // Visit a parse tree produced by DorisSQLParser#decimalValue. + // Visit a parse tree produced by StarRocksSQLParser#decimalValue. VisitDecimalValue(ctx *DecimalValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#doubleValue. + // Visit a parse tree produced by StarRocksSQLParser#doubleValue. VisitDoubleValue(ctx *DoubleValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#integerValue. + // Visit a parse tree produced by StarRocksSQLParser#integerValue. VisitIntegerValue(ctx *IntegerValueContext) interface{} - // Visit a parse tree produced by DorisSQLParser#nonReserved. + // Visit a parse tree produced by StarRocksSQLParser#nonReserved. VisitNonReserved(ctx *NonReservedContext) interface{} } diff --git a/doris/dorissqllex_lexer.go b/starrocks/starrockssqllex_lexer.go similarity index 88% rename from doris/dorissqllex_lexer.go rename to starrocks/starrockssqllex_lexer.go index b31f494..62250a0 100644 --- a/doris/dorissqllex_lexer.go +++ b/starrocks/starrockssqllex_lexer.go @@ -1,6 +1,6 @@ -// Code generated from DorisSQLLex.g4 by ANTLR 4.13.2. DO NOT EDIT. +// Code generated from StarRocksSQLLex.g4 by ANTLR 4.13.2. DO NOT EDIT. -package doris +package starrocks import ( "fmt" @@ -14,14 +14,14 @@ var _ = fmt.Printf var _ = sync.Once{} var _ = unicode.IsLetter -type DorisSQLLex struct { +type StarRocksSQLLex struct { *antlr.BaseLexer channelNames []string modeNames []string // TODO: EOF string } -var DorisSQLLexLexerStaticData struct { +var StarRocksSQLLexLexerStaticData struct { once sync.Once serializedATN []int32 ChannelNames []string @@ -34,8 +34,8 @@ var DorisSQLLexLexerStaticData struct { decisionToDFA []*antlr.DFA } -func dorissqllexLexerInit() { - staticData := &DorisSQLLexLexerStaticData +func starrockssqllexLexerInit() { + staticData := &StarRocksSQLLexLexerStaticData staticData.ChannelNames = []string{ "DEFAULT_TOKEN_CHANNEL", "HIDDEN", } @@ -2695,576 +2695,576 @@ func dorissqllexLexerInit() { } } -// DorisSQLLexInit initializes any static state used to implement DorisSQLLex. By default the +// StarRocksSQLLexInit initializes any static state used to implement StarRocksSQLLex. By default the // static state used to implement the lexer is lazily initialized during the first call to -// NewDorisSQLLex(). You can call this function if you wish to initialize the static state ahead +// NewStarRocksSQLLex(). You can call this function if you wish to initialize the static state ahead // of time. -func DorisSQLLexInit() { - staticData := &DorisSQLLexLexerStaticData - staticData.once.Do(dorissqllexLexerInit) +func StarRocksSQLLexInit() { + staticData := &StarRocksSQLLexLexerStaticData + staticData.once.Do(starrockssqllexLexerInit) } -// NewDorisSQLLex produces a new lexer instance for the optional input antlr.CharStream. -func NewDorisSQLLex(input antlr.CharStream) *DorisSQLLex { - DorisSQLLexInit() - l := new(DorisSQLLex) +// NewStarRocksSQLLex produces a new lexer instance for the optional input antlr.CharStream. +func NewStarRocksSQLLex(input antlr.CharStream) *StarRocksSQLLex { + StarRocksSQLLexInit() + l := new(StarRocksSQLLex) l.BaseLexer = antlr.NewBaseLexer(input) - staticData := &DorisSQLLexLexerStaticData + staticData := &StarRocksSQLLexLexerStaticData l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) l.channelNames = staticData.ChannelNames l.modeNames = staticData.ModeNames l.RuleNames = staticData.RuleNames l.LiteralNames = staticData.LiteralNames l.SymbolicNames = staticData.SymbolicNames - l.GrammarFileName = "DorisSQLLex.g4" + l.GrammarFileName = "StarRocksSQLLex.g4" // TODO: l.EOF = antlr.TokenEOF return l } -// DorisSQLLex tokens. +// StarRocksSQLLex tokens. const ( - DorisSQLLexCONCAT = 1 - DorisSQLLexACCESS = 2 - DorisSQLLexACTIVE = 3 - DorisSQLLexADD = 4 - DorisSQLLexADMIN = 5 - DorisSQLLexADVISOR = 6 - DorisSQLLexAFTER = 7 - DorisSQLLexAGGREGATE = 8 - DorisSQLLexALL = 9 - DorisSQLLexALTER = 10 - DorisSQLLexANALYZE = 11 - DorisSQLLexAND = 12 - DorisSQLLexANTI = 13 - DorisSQLLexAPPLY = 14 - DorisSQLLexARRAY = 15 - DorisSQLLexARRAY_AGG = 16 - DorisSQLLexARRAY_AGG_DISTINCT = 17 - DorisSQLLexAS = 18 - DorisSQLLexASC = 19 - DorisSQLLexASYNC = 20 - DorisSQLLexAUTHORS = 21 - DorisSQLLexAUTHENTICATION = 22 - DorisSQLLexAUTOMATED = 23 - DorisSQLLexAUTO_INCREMENT = 24 - DorisSQLLexAVG = 25 - DorisSQLLexBACKEND = 26 - DorisSQLLexBACKENDS = 27 - DorisSQLLexBACKUP = 28 - DorisSQLLexBASE = 29 - DorisSQLLexBASELINE = 30 - DorisSQLLexBEGIN = 31 - DorisSQLLexBETWEEN = 32 - DorisSQLLexBIGINT = 33 - DorisSQLLexBINARY = 34 - DorisSQLLexBITMAP = 35 - DorisSQLLexBITMAP_UNION = 36 - DorisSQLLexBLACKHOLE = 37 - DorisSQLLexBLACKLIST = 38 - DorisSQLLexBODY = 39 - DorisSQLLexBOOLEAN = 40 - DorisSQLLexBOTH = 41 - DorisSQLLexBRANCH = 42 - DorisSQLLexBROKER = 43 - DorisSQLLexBUCKETS = 44 - DorisSQLLexBUILTIN = 45 - DorisSQLLexBY = 46 - DorisSQLLexCACHE = 47 - DorisSQLLexCANCEL = 48 - DorisSQLLexCASE = 49 - DorisSQLLexCAST = 50 - DorisSQLLexCATALOG = 51 - DorisSQLLexCATALOGS = 52 - DorisSQLLexCEIL = 53 - DorisSQLLexCHAIN = 54 - DorisSQLLexCHAR = 55 - DorisSQLLexCHARACTER = 56 - DorisSQLLexCHARSET = 57 - DorisSQLLexCHECK = 58 - DorisSQLLexCLEAN = 59 - DorisSQLLexCLEAR = 60 - DorisSQLLexCLUSTER = 61 - DorisSQLLexCLUSTERS = 62 - DorisSQLLexCNGROUP = 63 - DorisSQLLexCNGROUPS = 64 - DorisSQLLexCOLLATE = 65 - DorisSQLLexCOLLATION = 66 - DorisSQLLexCOLUMN = 67 - DorisSQLLexCOLUMNS = 68 - DorisSQLLexCOMMENT = 69 - DorisSQLLexCOMMIT = 70 - DorisSQLLexCOMMITTED = 71 - DorisSQLLexCOMPACT = 72 - DorisSQLLexCOMPACTION = 73 - DorisSQLLexCOMPUTE = 74 - DorisSQLLexCONFIG = 75 - DorisSQLLexCONNECTION = 76 - DorisSQLLexCONSISTENT = 77 - DorisSQLLexCONVERT = 78 - DorisSQLLexCOSTS = 79 - DorisSQLLexCOUNT = 80 - DorisSQLLexCREATE = 81 - DorisSQLLexCROSS = 82 - DorisSQLLexCUBE = 83 - DorisSQLLexCUME_DIST = 84 - DorisSQLLexCUMULATIVE = 85 - DorisSQLLexCURRENT = 86 - DorisSQLLexCURRENT_DATE = 87 - DorisSQLLexCURRENT_GROUP = 88 - DorisSQLLexCURRENT_ROLE = 89 - DorisSQLLexCURRENT_TIME = 90 - DorisSQLLexCURRENT_TIMESTAMP = 91 - DorisSQLLexCURRENT_USER = 92 - DorisSQLLexDATA = 93 - DorisSQLLexDATACACHE = 94 - DorisSQLLexDATABASE = 95 - DorisSQLLexDATABASES = 96 - DorisSQLLexDATE = 97 - DorisSQLLexDATETIME = 98 - DorisSQLLexDAY = 99 - DorisSQLLexDAYS = 100 - DorisSQLLexDEALLOCATE = 101 - DorisSQLLexDECIMAL = 102 - DorisSQLLexDECIMALV2 = 103 - DorisSQLLexDECIMAL32 = 104 - DorisSQLLexDECIMAL64 = 105 - DorisSQLLexDECIMAL128 = 106 - DorisSQLLexDECOMMISSION = 107 - DorisSQLLexDEFAULT = 108 - DorisSQLLexDELETE = 109 - DorisSQLLexDENSE_RANK = 110 - DorisSQLLexDEFERRED = 111 - DorisSQLLexDIALECT = 112 - DorisSQLLexDICTIONARY = 113 - DorisSQLLexDICTIONARY_GET = 114 - DorisSQLLexNTILE = 115 - DorisSQLLexDESC = 116 - DorisSQLLexDESCRIBE = 117 - DorisSQLLexDISABLE = 118 - DorisSQLLexDISTINCT = 119 - DorisSQLLexDISTRIBUTED = 120 - DorisSQLLexDISTRIBUTION = 121 - DorisSQLLexDOUBLE = 122 - DorisSQLLexDROP = 123 - DorisSQLLexDUAL = 124 - DorisSQLLexDUPLICATE = 125 - DorisSQLLexDYNAMIC = 126 - DorisSQLLexELSE = 127 - DorisSQLLexENABLE = 128 - DorisSQLLexENCLOSE = 129 - DorisSQLLexEND = 130 - DorisSQLLexENGINE = 131 - DorisSQLLexENGINES = 132 - DorisSQLLexERRORS = 133 - DorisSQLLexESCAPE = 134 - DorisSQLLexEVENTS = 135 - DorisSQLLexEXCEPT = 136 - DorisSQLLexEXCLUDE = 137 - DorisSQLLexEXECUTE = 138 - DorisSQLLexEXISTS = 139 - DorisSQLLexEXPLAIN = 140 - DorisSQLLexEXPLODE = 141 - DorisSQLLexEXPLODE_SPLIT = 142 - DorisSQLLexEXPORT = 143 - DorisSQLLexEXTERNAL = 144 - DorisSQLLexEXTRACT = 145 - DorisSQLLexEVERY = 146 - DorisSQLLexFAILPOINT = 147 - DorisSQLLexFAILPOINTS = 148 - DorisSQLLexFALSE = 149 - DorisSQLLexFIELDS = 150 - DorisSQLLexFILE = 151 - DorisSQLLexFILES = 152 - DorisSQLLexFILTER = 153 - DorisSQLLexFIRST = 154 - DorisSQLLexFIRST_VALUE = 155 - DorisSQLLexFLOAT = 156 - DorisSQLLexFLOOR = 157 - DorisSQLLexFN = 158 - DorisSQLLexFOLLOWING = 159 - DorisSQLLexFOLLOWER = 160 - DorisSQLLexFOR = 161 - DorisSQLLexFORCE = 162 - DorisSQLLexFORMAT = 163 - DorisSQLLexFREE = 164 - DorisSQLLexFROM = 165 - DorisSQLLexFRONTEND = 166 - DorisSQLLexFRONTENDS = 167 - DorisSQLLexFULL = 168 - DorisSQLLexFUNCTION = 169 - DorisSQLLexFUNCTIONS = 170 - DorisSQLLexGLOBAL = 171 - DorisSQLLexGRANT = 172 - DorisSQLLexGRANTS = 173 - DorisSQLLexGROUP = 174 - DorisSQLLexGROUPS = 175 - DorisSQLLexGROUPING = 176 - DorisSQLLexGROUPING_ID = 177 - DorisSQLLexGROUP_CONCAT = 178 - DorisSQLLexHASH = 179 - DorisSQLLexHAVING = 180 - DorisSQLLexHELP = 181 - DorisSQLLexHISTOGRAM = 182 - DorisSQLLexHLL = 183 - DorisSQLLexHLL_UNION = 184 - DorisSQLLexHOST = 185 - DorisSQLLexHOUR = 186 - DorisSQLLexHOURS = 187 - DorisSQLLexHUB = 188 - DorisSQLLexIDENTIFIED = 189 - DorisSQLLexIF = 190 - DorisSQLLexIMPERSONATE = 191 - DorisSQLLexIMMEDIATE = 192 - DorisSQLLexIGNORE = 193 - DorisSQLLexIMAGE = 194 - DorisSQLLexIN = 195 - DorisSQLLexINACTIVE = 196 - DorisSQLLexINCREMENTAL = 197 - DorisSQLLexINDEX = 198 - DorisSQLLexINDEXES = 199 - DorisSQLLexINFILE = 200 - DorisSQLLexINNER = 201 - DorisSQLLexINSTALL = 202 - DorisSQLLexINSERT = 203 - DorisSQLLexINT = 204 - DorisSQLLexINTEGER = 205 - DorisSQLLexINTEGRATION = 206 - DorisSQLLexINTEGRATIONS = 207 - DorisSQLLexINTERMEDIATE = 208 - DorisSQLLexINTERSECT = 209 - DorisSQLLexINTERVAL = 210 - DorisSQLLexINTO = 211 - DorisSQLLexINVOKER = 212 - DorisSQLLexGIN = 213 - DorisSQLLexOVERWRITE = 214 - DorisSQLLexIS = 215 - DorisSQLLexISOLATION = 216 - DorisSQLLexJOB = 217 - DorisSQLLexJOIN = 218 - DorisSQLLexJSON = 219 - DorisSQLLexKEY = 220 - DorisSQLLexKEYS = 221 - DorisSQLLexKILL = 222 - DorisSQLLexLABEL = 223 - DorisSQLLexLAG = 224 - DorisSQLLexLARGEINT = 225 - DorisSQLLexLAST = 226 - DorisSQLLexLAST_VALUE = 227 - DorisSQLLexLATERAL = 228 - DorisSQLLexLEAD = 229 - DorisSQLLexLEFT = 230 - DorisSQLLexLESS = 231 - DorisSQLLexLEVEL = 232 - DorisSQLLexLIKE = 233 - DorisSQLLexLIMIT = 234 - DorisSQLLexLIST = 235 - DorisSQLLexLOAD = 236 - DorisSQLLexLOCAL = 237 - DorisSQLLexLOCALTIME = 238 - DorisSQLLexLOCALTIMESTAMP = 239 - DorisSQLLexLOCATION = 240 - DorisSQLLexLOCATIONS = 241 - DorisSQLLexLOGS = 242 - DorisSQLLexLOGICAL = 243 - DorisSQLLexMANUAL = 244 - DorisSQLLexMAP = 245 - DorisSQLLexMAPPING = 246 - DorisSQLLexMAPPINGS = 247 - DorisSQLLexMASKING = 248 - DorisSQLLexMATCH = 249 - DorisSQLLexMATERIALIZED = 250 - DorisSQLLexMAX = 251 - DorisSQLLexMAXVALUE = 252 - DorisSQLLexMERGE = 253 - DorisSQLLexMICROSECOND = 254 - DorisSQLLexMILLISECOND = 255 - DorisSQLLexMIN = 256 - DorisSQLLexMINUTE = 257 - DorisSQLLexMINUTES = 258 - DorisSQLLexMINUS = 259 - DorisSQLLexMETA = 260 - DorisSQLLexMOD = 261 - DorisSQLLexMODE = 262 - DorisSQLLexMODIFY = 263 - DorisSQLLexMONTH = 264 - DorisSQLLexMULTIPLE = 265 - DorisSQLLexNAME = 266 - DorisSQLLexNAMES = 267 - DorisSQLLexNEGATIVE = 268 - DorisSQLLexNGRAMBF = 269 - DorisSQLLexNO = 270 - DorisSQLLexNODE = 271 - DorisSQLLexNODES = 272 - DorisSQLLexNONE = 273 - DorisSQLLexNOT = 274 - DorisSQLLexNULL = 275 - DorisSQLLexNULLS = 276 - DorisSQLLexNUMBER = 277 - DorisSQLLexNUMERIC = 278 - DorisSQLLexOBSERVER = 279 - DorisSQLLexOF = 280 - DorisSQLLexOFF = 281 - DorisSQLLexOFFSET = 282 - DorisSQLLexON = 283 - DorisSQLLexONLY = 284 - DorisSQLLexOPEN = 285 - DorisSQLLexOPERATE = 286 - DorisSQLLexOPTIMIZE = 287 - DorisSQLLexOPTIMIZER = 288 - DorisSQLLexOPTION = 289 - DorisSQLLexOR = 290 - DorisSQLLexORDER = 291 - DorisSQLLexOUTER = 292 - DorisSQLLexOUTFILE = 293 - DorisSQLLexOVER = 294 - DorisSQLLexPARAMETER = 295 - DorisSQLLexPARTITION = 296 - DorisSQLLexPARTITIONS = 297 - DorisSQLLexPASSWORD = 298 - DorisSQLLexPATH = 299 - DorisSQLLexPAUSE = 300 - DorisSQLLexPENDING = 301 - DorisSQLLexPERCENT_RANK = 302 - DorisSQLLexPERCENTILE = 303 - DorisSQLLexPERCENTILE_UNION = 304 - DorisSQLLexPLAN = 305 - DorisSQLLexPLUGIN = 306 - DorisSQLLexPLUGINS = 307 - DorisSQLLexPIPE = 308 - DorisSQLLexPIPES = 309 - DorisSQLLexPIVOT = 310 - DorisSQLLexPOLICY = 311 - DorisSQLLexPOLICIES = 312 - DorisSQLLexPRECEDING = 313 - DorisSQLLexPREDICATE = 314 - DorisSQLLexPREPARE = 315 - DorisSQLLexPRIMARY = 316 - DorisSQLLexPRIORITY = 317 - DorisSQLLexPRIVILEGES = 318 - DorisSQLLexPROBABILITY = 319 - DorisSQLLexPROC = 320 - DorisSQLLexPROCEDURE = 321 - DorisSQLLexPROCESSLIST = 322 - DorisSQLLexPROFILE = 323 - DorisSQLLexPROFILELIST = 324 - DorisSQLLexPROPERTIES = 325 - DorisSQLLexPROPERTY = 326 - DorisSQLLexPROVIDER = 327 - DorisSQLLexPROVIDERS = 328 - DorisSQLLexQUALIFY = 329 - DorisSQLLexQUARTER = 330 - DorisSQLLexQUERY = 331 - DorisSQLLexQUERIES = 332 - DorisSQLLexQUEUE = 333 - DorisSQLLexQUOTA = 334 - DorisSQLLexRANDOM = 335 - DorisSQLLexRANGE = 336 - DorisSQLLexRANK = 337 - DorisSQLLexREAD = 338 - DorisSQLLexREASON = 339 - DorisSQLLexRECOVER = 340 - DorisSQLLexREFRESH = 341 - DorisSQLLexREWRITE = 342 - DorisSQLLexREGEXP = 343 - DorisSQLLexRELEASE = 344 - DorisSQLLexREMOVE = 345 - DorisSQLLexRENAME = 346 - DorisSQLLexREPAIR = 347 - DorisSQLLexREPEATABLE = 348 - DorisSQLLexREPLACE = 349 - DorisSQLLexREPLACE_IF_NOT_NULL = 350 - DorisSQLLexREPLICA = 351 - DorisSQLLexREPOSITORY = 352 - DorisSQLLexREPOSITORIES = 353 - DorisSQLLexRESOURCE = 354 - DorisSQLLexRESOURCES = 355 - DorisSQLLexRESTORE = 356 - DorisSQLLexRESUME = 357 - DorisSQLLexRETAIN = 358 - DorisSQLLexRETENTION = 359 - DorisSQLLexRETURNS = 360 - DorisSQLLexRETRY = 361 - DorisSQLLexREVOKE = 362 - DorisSQLLexREVERT = 363 - DorisSQLLexRIGHT = 364 - DorisSQLLexRLIKE = 365 - DorisSQLLexROLE = 366 - DorisSQLLexROLES = 367 - DorisSQLLexROLLBACK = 368 - DorisSQLLexROLLUP = 369 - DorisSQLLexROUTINE = 370 - DorisSQLLexROW = 371 - DorisSQLLexROWS = 372 - DorisSQLLexROW_NUMBER = 373 - DorisSQLLexRULE = 374 - DorisSQLLexRULES = 375 - DorisSQLLexRUNNING = 376 - DorisSQLLexSAMPLE = 377 - DorisSQLLexSCHEDULE = 378 - DorisSQLLexSCHEDULER = 379 - DorisSQLLexSCHEMA = 380 - DorisSQLLexSCHEMAS = 381 - DorisSQLLexSECOND = 382 - DorisSQLLexSECURITY = 383 - DorisSQLLexSELECT = 384 - DorisSQLLexSEMI = 385 - DorisSQLLexSEPARATOR = 386 - DorisSQLLexSERIALIZABLE = 387 - DorisSQLLexSESSION = 388 - DorisSQLLexSET = 389 - DorisSQLLexSETS = 390 - DorisSQLLexSET_VAR = 391 - DorisSQLLexSIGNED = 392 - DorisSQLLexSKIP_HEADER = 393 - DorisSQLLexSHOW = 394 - DorisSQLLexSMALLINT = 395 - DorisSQLLexSNAPSHOT = 396 - DorisSQLLexSNAPSHOTS = 397 - DorisSQLLexSQLBLACKLIST = 398 - DorisSQLLexSTART = 399 - DorisSQLLexSTATS = 400 - DorisSQLLexSTATUS = 401 - DorisSQLLexSTOP = 402 - DorisSQLLexSTORAGE = 403 - DorisSQLLexSTREAM = 404 - DorisSQLLexSTRING = 405 - DorisSQLLexTEXT = 406 - DorisSQLLexSUBMIT = 407 - DorisSQLLexSUM = 408 - DorisSQLLexSUSPEND = 409 - DorisSQLLexSYNC = 410 - DorisSQLLexSYSTEM = 411 - DorisSQLLexSYSTEM_TIME = 412 - DorisSQLLexSWAP = 413 - DorisSQLLexSTRUCT = 414 - DorisSQLLexTABLE = 415 - DorisSQLLexTABLES = 416 - DorisSQLLexTABLET = 417 - DorisSQLLexTABLETS = 418 - DorisSQLLexTAG = 419 - DorisSQLLexTASK = 420 - DorisSQLLexTEMPORARY = 421 - DorisSQLLexTERMINATED = 422 - DorisSQLLexTHAN = 423 - DorisSQLLexTHEN = 424 - DorisSQLLexTIME = 425 - DorisSQLLexTIMES = 426 - DorisSQLLexTIMESTAMP = 427 - DorisSQLLexTIMESTAMPADD = 428 - DorisSQLLexTIMESTAMPDIFF = 429 - DorisSQLLexTINYINT = 430 - DorisSQLLexTRANSACTION = 431 - DorisSQLLexTRANSLATE = 432 - DorisSQLLexTO = 433 - DorisSQLLexTRACE = 434 - DorisSQLLexTRIGGERS = 435 - DorisSQLLexTRIM_SPACE = 436 - DorisSQLLexTRUE = 437 - DorisSQLLexTRUNCATE = 438 - DorisSQLLexTYPE = 439 - DorisSQLLexTYPES = 440 - DorisSQLLexUNBOUNDED = 441 - DorisSQLLexUNCOMMITTED = 442 - DorisSQLLexUNION = 443 - DorisSQLLexUNIQUE = 444 - DorisSQLLexUNINSTALL = 445 - DorisSQLLexUNSET = 446 - DorisSQLLexUNSIGNED = 447 - DorisSQLLexUPDATE = 448 - DorisSQLLexUSAGE = 449 - DorisSQLLexUSE = 450 - DorisSQLLexUSER = 451 - DorisSQLLexUSERS = 452 - DorisSQLLexUSING = 453 - DorisSQLLexVALUE = 454 - DorisSQLLexVALUES = 455 - DorisSQLLexVARBINARY = 456 - DorisSQLLexVARCHAR = 457 - DorisSQLLexVARIABLES = 458 - DorisSQLLexVECTOR = 459 - DorisSQLLexVERBOSE = 460 - DorisSQLLexVERSION = 461 - DorisSQLLexVIEW = 462 - DorisSQLLexVIEWS = 463 - DorisSQLLexVOLUME = 464 - DorisSQLLexVOLUMES = 465 - DorisSQLLexWAREHOUSE = 466 - DorisSQLLexWAREHOUSES = 467 - DorisSQLLexWARNINGS = 468 - DorisSQLLexWEEK = 469 - DorisSQLLexWHEN = 470 - DorisSQLLexWHERE = 471 - DorisSQLLexWHITELIST = 472 - DorisSQLLexWITH = 473 - DorisSQLLexWORK = 474 - DorisSQLLexWRITE = 475 - DorisSQLLexYEAR = 476 - DorisSQLLexLOCK = 477 - DorisSQLLexUNLOCK = 478 - DorisSQLLexLOW_PRIORITY = 479 - DorisSQLLexDISK = 480 - DorisSQLLexDISKS = 481 - DorisSQLLexBEFORE = 482 - DorisSQLLexDOUBLE_DOLLAR = 483 - DorisSQLLexFIELD = 484 - DorisSQLLexPERSISTENT = 485 - DorisSQLLexSKEW = 486 - DorisSQLLexENCRYPT = 487 - DorisSQLLexCACHED = 488 - DorisSQLLexLIGHT = 489 - DorisSQLLexRECYCLE = 490 - DorisSQLLexBIN = 491 - DorisSQLLexTRASH = 492 - DorisSQLLexWORKLOAD = 493 - DorisSQLLexSQL = 494 - DorisSQLLexBLOCK = 495 - DorisSQLLexTASKS = 496 - DorisSQLLexCHANGE = 497 - DorisSQLLexPROCESS = 498 - DorisSQLLexMIGRATIONS = 499 - DorisSQLLexEQ = 500 - DorisSQLLexNEQ = 501 - DorisSQLLexLT = 502 - DorisSQLLexLTE = 503 - DorisSQLLexGT = 504 - DorisSQLLexGTE = 505 - DorisSQLLexEQ_FOR_NULL = 506 - DorisSQLLexARRAY_ELEMENT = 507 - DorisSQLLexPLUS_SYMBOL = 508 - DorisSQLLexMINUS_SYMBOL = 509 - DorisSQLLexASTERISK_SYMBOL = 510 - DorisSQLLexSLASH_SYMBOL = 511 - DorisSQLLexPERCENT_SYMBOL = 512 - DorisSQLLexLOGICAL_OR = 513 - DorisSQLLexLOGICAL_AND = 514 - DorisSQLLexLOGICAL_NOT = 515 - DorisSQLLexINT_DIV = 516 - DorisSQLLexBITAND = 517 - DorisSQLLexBITOR = 518 - DorisSQLLexBITXOR = 519 - DorisSQLLexBITNOT = 520 - DorisSQLLexBIT_SHIFT_LEFT = 521 - DorisSQLLexBIT_SHIFT_RIGHT = 522 - DorisSQLLexBIT_SHIFT_RIGHT_LOGICAL = 523 - DorisSQLLexARROW = 524 - DorisSQLLexAT = 525 - DorisSQLLexINTEGER_VALUE = 526 - DorisSQLLexDECIMAL_VALUE = 527 - DorisSQLLexDOUBLE_VALUE = 528 - DorisSQLLexSINGLE_QUOTED_TEXT = 529 - DorisSQLLexDOUBLE_QUOTED_TEXT = 530 - DorisSQLLexBINARY_SINGLE_QUOTED_TEXT = 531 - DorisSQLLexBINARY_DOUBLE_QUOTED_TEXT = 532 - DorisSQLLexLETTER_IDENTIFIER = 533 - DorisSQLLexDIGIT_IDENTIFIER = 534 - DorisSQLLexBACKQUOTED_IDENTIFIER = 535 - DorisSQLLexDOT_IDENTIFIER = 536 - DorisSQLLexSIMPLE_COMMENT = 537 - DorisSQLLexBRACKETED_COMMENT = 538 - DorisSQLLexOPTIMIZER_HINT = 539 - DorisSQLLexSEMICOLON = 540 - DorisSQLLexDOTDOTDOT = 541 - DorisSQLLexWS = 542 - DorisSQLLexATTACHMENT = 543 + StarRocksSQLLexCONCAT = 1 + StarRocksSQLLexACCESS = 2 + StarRocksSQLLexACTIVE = 3 + StarRocksSQLLexADD = 4 + StarRocksSQLLexADMIN = 5 + StarRocksSQLLexADVISOR = 6 + StarRocksSQLLexAFTER = 7 + StarRocksSQLLexAGGREGATE = 8 + StarRocksSQLLexALL = 9 + StarRocksSQLLexALTER = 10 + StarRocksSQLLexANALYZE = 11 + StarRocksSQLLexAND = 12 + StarRocksSQLLexANTI = 13 + StarRocksSQLLexAPPLY = 14 + StarRocksSQLLexARRAY = 15 + StarRocksSQLLexARRAY_AGG = 16 + StarRocksSQLLexARRAY_AGG_DISTINCT = 17 + StarRocksSQLLexAS = 18 + StarRocksSQLLexASC = 19 + StarRocksSQLLexASYNC = 20 + StarRocksSQLLexAUTHORS = 21 + StarRocksSQLLexAUTHENTICATION = 22 + StarRocksSQLLexAUTOMATED = 23 + StarRocksSQLLexAUTO_INCREMENT = 24 + StarRocksSQLLexAVG = 25 + StarRocksSQLLexBACKEND = 26 + StarRocksSQLLexBACKENDS = 27 + StarRocksSQLLexBACKUP = 28 + StarRocksSQLLexBASE = 29 + StarRocksSQLLexBASELINE = 30 + StarRocksSQLLexBEGIN = 31 + StarRocksSQLLexBETWEEN = 32 + StarRocksSQLLexBIGINT = 33 + StarRocksSQLLexBINARY = 34 + StarRocksSQLLexBITMAP = 35 + StarRocksSQLLexBITMAP_UNION = 36 + StarRocksSQLLexBLACKHOLE = 37 + StarRocksSQLLexBLACKLIST = 38 + StarRocksSQLLexBODY = 39 + StarRocksSQLLexBOOLEAN = 40 + StarRocksSQLLexBOTH = 41 + StarRocksSQLLexBRANCH = 42 + StarRocksSQLLexBROKER = 43 + StarRocksSQLLexBUCKETS = 44 + StarRocksSQLLexBUILTIN = 45 + StarRocksSQLLexBY = 46 + StarRocksSQLLexCACHE = 47 + StarRocksSQLLexCANCEL = 48 + StarRocksSQLLexCASE = 49 + StarRocksSQLLexCAST = 50 + StarRocksSQLLexCATALOG = 51 + StarRocksSQLLexCATALOGS = 52 + StarRocksSQLLexCEIL = 53 + StarRocksSQLLexCHAIN = 54 + StarRocksSQLLexCHAR = 55 + StarRocksSQLLexCHARACTER = 56 + StarRocksSQLLexCHARSET = 57 + StarRocksSQLLexCHECK = 58 + StarRocksSQLLexCLEAN = 59 + StarRocksSQLLexCLEAR = 60 + StarRocksSQLLexCLUSTER = 61 + StarRocksSQLLexCLUSTERS = 62 + StarRocksSQLLexCNGROUP = 63 + StarRocksSQLLexCNGROUPS = 64 + StarRocksSQLLexCOLLATE = 65 + StarRocksSQLLexCOLLATION = 66 + StarRocksSQLLexCOLUMN = 67 + StarRocksSQLLexCOLUMNS = 68 + StarRocksSQLLexCOMMENT = 69 + StarRocksSQLLexCOMMIT = 70 + StarRocksSQLLexCOMMITTED = 71 + StarRocksSQLLexCOMPACT = 72 + StarRocksSQLLexCOMPACTION = 73 + StarRocksSQLLexCOMPUTE = 74 + StarRocksSQLLexCONFIG = 75 + StarRocksSQLLexCONNECTION = 76 + StarRocksSQLLexCONSISTENT = 77 + StarRocksSQLLexCONVERT = 78 + StarRocksSQLLexCOSTS = 79 + StarRocksSQLLexCOUNT = 80 + StarRocksSQLLexCREATE = 81 + StarRocksSQLLexCROSS = 82 + StarRocksSQLLexCUBE = 83 + StarRocksSQLLexCUME_DIST = 84 + StarRocksSQLLexCUMULATIVE = 85 + StarRocksSQLLexCURRENT = 86 + StarRocksSQLLexCURRENT_DATE = 87 + StarRocksSQLLexCURRENT_GROUP = 88 + StarRocksSQLLexCURRENT_ROLE = 89 + StarRocksSQLLexCURRENT_TIME = 90 + StarRocksSQLLexCURRENT_TIMESTAMP = 91 + StarRocksSQLLexCURRENT_USER = 92 + StarRocksSQLLexDATA = 93 + StarRocksSQLLexDATACACHE = 94 + StarRocksSQLLexDATABASE = 95 + StarRocksSQLLexDATABASES = 96 + StarRocksSQLLexDATE = 97 + StarRocksSQLLexDATETIME = 98 + StarRocksSQLLexDAY = 99 + StarRocksSQLLexDAYS = 100 + StarRocksSQLLexDEALLOCATE = 101 + StarRocksSQLLexDECIMAL = 102 + StarRocksSQLLexDECIMALV2 = 103 + StarRocksSQLLexDECIMAL32 = 104 + StarRocksSQLLexDECIMAL64 = 105 + StarRocksSQLLexDECIMAL128 = 106 + StarRocksSQLLexDECOMMISSION = 107 + StarRocksSQLLexDEFAULT = 108 + StarRocksSQLLexDELETE = 109 + StarRocksSQLLexDENSE_RANK = 110 + StarRocksSQLLexDEFERRED = 111 + StarRocksSQLLexDIALECT = 112 + StarRocksSQLLexDICTIONARY = 113 + StarRocksSQLLexDICTIONARY_GET = 114 + StarRocksSQLLexNTILE = 115 + StarRocksSQLLexDESC = 116 + StarRocksSQLLexDESCRIBE = 117 + StarRocksSQLLexDISABLE = 118 + StarRocksSQLLexDISTINCT = 119 + StarRocksSQLLexDISTRIBUTED = 120 + StarRocksSQLLexDISTRIBUTION = 121 + StarRocksSQLLexDOUBLE = 122 + StarRocksSQLLexDROP = 123 + StarRocksSQLLexDUAL = 124 + StarRocksSQLLexDUPLICATE = 125 + StarRocksSQLLexDYNAMIC = 126 + StarRocksSQLLexELSE = 127 + StarRocksSQLLexENABLE = 128 + StarRocksSQLLexENCLOSE = 129 + StarRocksSQLLexEND = 130 + StarRocksSQLLexENGINE = 131 + StarRocksSQLLexENGINES = 132 + StarRocksSQLLexERRORS = 133 + StarRocksSQLLexESCAPE = 134 + StarRocksSQLLexEVENTS = 135 + StarRocksSQLLexEXCEPT = 136 + StarRocksSQLLexEXCLUDE = 137 + StarRocksSQLLexEXECUTE = 138 + StarRocksSQLLexEXISTS = 139 + StarRocksSQLLexEXPLAIN = 140 + StarRocksSQLLexEXPLODE = 141 + StarRocksSQLLexEXPLODE_SPLIT = 142 + StarRocksSQLLexEXPORT = 143 + StarRocksSQLLexEXTERNAL = 144 + StarRocksSQLLexEXTRACT = 145 + StarRocksSQLLexEVERY = 146 + StarRocksSQLLexFAILPOINT = 147 + StarRocksSQLLexFAILPOINTS = 148 + StarRocksSQLLexFALSE = 149 + StarRocksSQLLexFIELDS = 150 + StarRocksSQLLexFILE = 151 + StarRocksSQLLexFILES = 152 + StarRocksSQLLexFILTER = 153 + StarRocksSQLLexFIRST = 154 + StarRocksSQLLexFIRST_VALUE = 155 + StarRocksSQLLexFLOAT = 156 + StarRocksSQLLexFLOOR = 157 + StarRocksSQLLexFN = 158 + StarRocksSQLLexFOLLOWING = 159 + StarRocksSQLLexFOLLOWER = 160 + StarRocksSQLLexFOR = 161 + StarRocksSQLLexFORCE = 162 + StarRocksSQLLexFORMAT = 163 + StarRocksSQLLexFREE = 164 + StarRocksSQLLexFROM = 165 + StarRocksSQLLexFRONTEND = 166 + StarRocksSQLLexFRONTENDS = 167 + StarRocksSQLLexFULL = 168 + StarRocksSQLLexFUNCTION = 169 + StarRocksSQLLexFUNCTIONS = 170 + StarRocksSQLLexGLOBAL = 171 + StarRocksSQLLexGRANT = 172 + StarRocksSQLLexGRANTS = 173 + StarRocksSQLLexGROUP = 174 + StarRocksSQLLexGROUPS = 175 + StarRocksSQLLexGROUPING = 176 + StarRocksSQLLexGROUPING_ID = 177 + StarRocksSQLLexGROUP_CONCAT = 178 + StarRocksSQLLexHASH = 179 + StarRocksSQLLexHAVING = 180 + StarRocksSQLLexHELP = 181 + StarRocksSQLLexHISTOGRAM = 182 + StarRocksSQLLexHLL = 183 + StarRocksSQLLexHLL_UNION = 184 + StarRocksSQLLexHOST = 185 + StarRocksSQLLexHOUR = 186 + StarRocksSQLLexHOURS = 187 + StarRocksSQLLexHUB = 188 + StarRocksSQLLexIDENTIFIED = 189 + StarRocksSQLLexIF = 190 + StarRocksSQLLexIMPERSONATE = 191 + StarRocksSQLLexIMMEDIATE = 192 + StarRocksSQLLexIGNORE = 193 + StarRocksSQLLexIMAGE = 194 + StarRocksSQLLexIN = 195 + StarRocksSQLLexINACTIVE = 196 + StarRocksSQLLexINCREMENTAL = 197 + StarRocksSQLLexINDEX = 198 + StarRocksSQLLexINDEXES = 199 + StarRocksSQLLexINFILE = 200 + StarRocksSQLLexINNER = 201 + StarRocksSQLLexINSTALL = 202 + StarRocksSQLLexINSERT = 203 + StarRocksSQLLexINT = 204 + StarRocksSQLLexINTEGER = 205 + StarRocksSQLLexINTEGRATION = 206 + StarRocksSQLLexINTEGRATIONS = 207 + StarRocksSQLLexINTERMEDIATE = 208 + StarRocksSQLLexINTERSECT = 209 + StarRocksSQLLexINTERVAL = 210 + StarRocksSQLLexINTO = 211 + StarRocksSQLLexINVOKER = 212 + StarRocksSQLLexGIN = 213 + StarRocksSQLLexOVERWRITE = 214 + StarRocksSQLLexIS = 215 + StarRocksSQLLexISOLATION = 216 + StarRocksSQLLexJOB = 217 + StarRocksSQLLexJOIN = 218 + StarRocksSQLLexJSON = 219 + StarRocksSQLLexKEY = 220 + StarRocksSQLLexKEYS = 221 + StarRocksSQLLexKILL = 222 + StarRocksSQLLexLABEL = 223 + StarRocksSQLLexLAG = 224 + StarRocksSQLLexLARGEINT = 225 + StarRocksSQLLexLAST = 226 + StarRocksSQLLexLAST_VALUE = 227 + StarRocksSQLLexLATERAL = 228 + StarRocksSQLLexLEAD = 229 + StarRocksSQLLexLEFT = 230 + StarRocksSQLLexLESS = 231 + StarRocksSQLLexLEVEL = 232 + StarRocksSQLLexLIKE = 233 + StarRocksSQLLexLIMIT = 234 + StarRocksSQLLexLIST = 235 + StarRocksSQLLexLOAD = 236 + StarRocksSQLLexLOCAL = 237 + StarRocksSQLLexLOCALTIME = 238 + StarRocksSQLLexLOCALTIMESTAMP = 239 + StarRocksSQLLexLOCATION = 240 + StarRocksSQLLexLOCATIONS = 241 + StarRocksSQLLexLOGS = 242 + StarRocksSQLLexLOGICAL = 243 + StarRocksSQLLexMANUAL = 244 + StarRocksSQLLexMAP = 245 + StarRocksSQLLexMAPPING = 246 + StarRocksSQLLexMAPPINGS = 247 + StarRocksSQLLexMASKING = 248 + StarRocksSQLLexMATCH = 249 + StarRocksSQLLexMATERIALIZED = 250 + StarRocksSQLLexMAX = 251 + StarRocksSQLLexMAXVALUE = 252 + StarRocksSQLLexMERGE = 253 + StarRocksSQLLexMICROSECOND = 254 + StarRocksSQLLexMILLISECOND = 255 + StarRocksSQLLexMIN = 256 + StarRocksSQLLexMINUTE = 257 + StarRocksSQLLexMINUTES = 258 + StarRocksSQLLexMINUS = 259 + StarRocksSQLLexMETA = 260 + StarRocksSQLLexMOD = 261 + StarRocksSQLLexMODE = 262 + StarRocksSQLLexMODIFY = 263 + StarRocksSQLLexMONTH = 264 + StarRocksSQLLexMULTIPLE = 265 + StarRocksSQLLexNAME = 266 + StarRocksSQLLexNAMES = 267 + StarRocksSQLLexNEGATIVE = 268 + StarRocksSQLLexNGRAMBF = 269 + StarRocksSQLLexNO = 270 + StarRocksSQLLexNODE = 271 + StarRocksSQLLexNODES = 272 + StarRocksSQLLexNONE = 273 + StarRocksSQLLexNOT = 274 + StarRocksSQLLexNULL = 275 + StarRocksSQLLexNULLS = 276 + StarRocksSQLLexNUMBER = 277 + StarRocksSQLLexNUMERIC = 278 + StarRocksSQLLexOBSERVER = 279 + StarRocksSQLLexOF = 280 + StarRocksSQLLexOFF = 281 + StarRocksSQLLexOFFSET = 282 + StarRocksSQLLexON = 283 + StarRocksSQLLexONLY = 284 + StarRocksSQLLexOPEN = 285 + StarRocksSQLLexOPERATE = 286 + StarRocksSQLLexOPTIMIZE = 287 + StarRocksSQLLexOPTIMIZER = 288 + StarRocksSQLLexOPTION = 289 + StarRocksSQLLexOR = 290 + StarRocksSQLLexORDER = 291 + StarRocksSQLLexOUTER = 292 + StarRocksSQLLexOUTFILE = 293 + StarRocksSQLLexOVER = 294 + StarRocksSQLLexPARAMETER = 295 + StarRocksSQLLexPARTITION = 296 + StarRocksSQLLexPARTITIONS = 297 + StarRocksSQLLexPASSWORD = 298 + StarRocksSQLLexPATH = 299 + StarRocksSQLLexPAUSE = 300 + StarRocksSQLLexPENDING = 301 + StarRocksSQLLexPERCENT_RANK = 302 + StarRocksSQLLexPERCENTILE = 303 + StarRocksSQLLexPERCENTILE_UNION = 304 + StarRocksSQLLexPLAN = 305 + StarRocksSQLLexPLUGIN = 306 + StarRocksSQLLexPLUGINS = 307 + StarRocksSQLLexPIPE = 308 + StarRocksSQLLexPIPES = 309 + StarRocksSQLLexPIVOT = 310 + StarRocksSQLLexPOLICY = 311 + StarRocksSQLLexPOLICIES = 312 + StarRocksSQLLexPRECEDING = 313 + StarRocksSQLLexPREDICATE = 314 + StarRocksSQLLexPREPARE = 315 + StarRocksSQLLexPRIMARY = 316 + StarRocksSQLLexPRIORITY = 317 + StarRocksSQLLexPRIVILEGES = 318 + StarRocksSQLLexPROBABILITY = 319 + StarRocksSQLLexPROC = 320 + StarRocksSQLLexPROCEDURE = 321 + StarRocksSQLLexPROCESSLIST = 322 + StarRocksSQLLexPROFILE = 323 + StarRocksSQLLexPROFILELIST = 324 + StarRocksSQLLexPROPERTIES = 325 + StarRocksSQLLexPROPERTY = 326 + StarRocksSQLLexPROVIDER = 327 + StarRocksSQLLexPROVIDERS = 328 + StarRocksSQLLexQUALIFY = 329 + StarRocksSQLLexQUARTER = 330 + StarRocksSQLLexQUERY = 331 + StarRocksSQLLexQUERIES = 332 + StarRocksSQLLexQUEUE = 333 + StarRocksSQLLexQUOTA = 334 + StarRocksSQLLexRANDOM = 335 + StarRocksSQLLexRANGE = 336 + StarRocksSQLLexRANK = 337 + StarRocksSQLLexREAD = 338 + StarRocksSQLLexREASON = 339 + StarRocksSQLLexRECOVER = 340 + StarRocksSQLLexREFRESH = 341 + StarRocksSQLLexREWRITE = 342 + StarRocksSQLLexREGEXP = 343 + StarRocksSQLLexRELEASE = 344 + StarRocksSQLLexREMOVE = 345 + StarRocksSQLLexRENAME = 346 + StarRocksSQLLexREPAIR = 347 + StarRocksSQLLexREPEATABLE = 348 + StarRocksSQLLexREPLACE = 349 + StarRocksSQLLexREPLACE_IF_NOT_NULL = 350 + StarRocksSQLLexREPLICA = 351 + StarRocksSQLLexREPOSITORY = 352 + StarRocksSQLLexREPOSITORIES = 353 + StarRocksSQLLexRESOURCE = 354 + StarRocksSQLLexRESOURCES = 355 + StarRocksSQLLexRESTORE = 356 + StarRocksSQLLexRESUME = 357 + StarRocksSQLLexRETAIN = 358 + StarRocksSQLLexRETENTION = 359 + StarRocksSQLLexRETURNS = 360 + StarRocksSQLLexRETRY = 361 + StarRocksSQLLexREVOKE = 362 + StarRocksSQLLexREVERT = 363 + StarRocksSQLLexRIGHT = 364 + StarRocksSQLLexRLIKE = 365 + StarRocksSQLLexROLE = 366 + StarRocksSQLLexROLES = 367 + StarRocksSQLLexROLLBACK = 368 + StarRocksSQLLexROLLUP = 369 + StarRocksSQLLexROUTINE = 370 + StarRocksSQLLexROW = 371 + StarRocksSQLLexROWS = 372 + StarRocksSQLLexROW_NUMBER = 373 + StarRocksSQLLexRULE = 374 + StarRocksSQLLexRULES = 375 + StarRocksSQLLexRUNNING = 376 + StarRocksSQLLexSAMPLE = 377 + StarRocksSQLLexSCHEDULE = 378 + StarRocksSQLLexSCHEDULER = 379 + StarRocksSQLLexSCHEMA = 380 + StarRocksSQLLexSCHEMAS = 381 + StarRocksSQLLexSECOND = 382 + StarRocksSQLLexSECURITY = 383 + StarRocksSQLLexSELECT = 384 + StarRocksSQLLexSEMI = 385 + StarRocksSQLLexSEPARATOR = 386 + StarRocksSQLLexSERIALIZABLE = 387 + StarRocksSQLLexSESSION = 388 + StarRocksSQLLexSET = 389 + StarRocksSQLLexSETS = 390 + StarRocksSQLLexSET_VAR = 391 + StarRocksSQLLexSIGNED = 392 + StarRocksSQLLexSKIP_HEADER = 393 + StarRocksSQLLexSHOW = 394 + StarRocksSQLLexSMALLINT = 395 + StarRocksSQLLexSNAPSHOT = 396 + StarRocksSQLLexSNAPSHOTS = 397 + StarRocksSQLLexSQLBLACKLIST = 398 + StarRocksSQLLexSTART = 399 + StarRocksSQLLexSTATS = 400 + StarRocksSQLLexSTATUS = 401 + StarRocksSQLLexSTOP = 402 + StarRocksSQLLexSTORAGE = 403 + StarRocksSQLLexSTREAM = 404 + StarRocksSQLLexSTRING = 405 + StarRocksSQLLexTEXT = 406 + StarRocksSQLLexSUBMIT = 407 + StarRocksSQLLexSUM = 408 + StarRocksSQLLexSUSPEND = 409 + StarRocksSQLLexSYNC = 410 + StarRocksSQLLexSYSTEM = 411 + StarRocksSQLLexSYSTEM_TIME = 412 + StarRocksSQLLexSWAP = 413 + StarRocksSQLLexSTRUCT = 414 + StarRocksSQLLexTABLE = 415 + StarRocksSQLLexTABLES = 416 + StarRocksSQLLexTABLET = 417 + StarRocksSQLLexTABLETS = 418 + StarRocksSQLLexTAG = 419 + StarRocksSQLLexTASK = 420 + StarRocksSQLLexTEMPORARY = 421 + StarRocksSQLLexTERMINATED = 422 + StarRocksSQLLexTHAN = 423 + StarRocksSQLLexTHEN = 424 + StarRocksSQLLexTIME = 425 + StarRocksSQLLexTIMES = 426 + StarRocksSQLLexTIMESTAMP = 427 + StarRocksSQLLexTIMESTAMPADD = 428 + StarRocksSQLLexTIMESTAMPDIFF = 429 + StarRocksSQLLexTINYINT = 430 + StarRocksSQLLexTRANSACTION = 431 + StarRocksSQLLexTRANSLATE = 432 + StarRocksSQLLexTO = 433 + StarRocksSQLLexTRACE = 434 + StarRocksSQLLexTRIGGERS = 435 + StarRocksSQLLexTRIM_SPACE = 436 + StarRocksSQLLexTRUE = 437 + StarRocksSQLLexTRUNCATE = 438 + StarRocksSQLLexTYPE = 439 + StarRocksSQLLexTYPES = 440 + StarRocksSQLLexUNBOUNDED = 441 + StarRocksSQLLexUNCOMMITTED = 442 + StarRocksSQLLexUNION = 443 + StarRocksSQLLexUNIQUE = 444 + StarRocksSQLLexUNINSTALL = 445 + StarRocksSQLLexUNSET = 446 + StarRocksSQLLexUNSIGNED = 447 + StarRocksSQLLexUPDATE = 448 + StarRocksSQLLexUSAGE = 449 + StarRocksSQLLexUSE = 450 + StarRocksSQLLexUSER = 451 + StarRocksSQLLexUSERS = 452 + StarRocksSQLLexUSING = 453 + StarRocksSQLLexVALUE = 454 + StarRocksSQLLexVALUES = 455 + StarRocksSQLLexVARBINARY = 456 + StarRocksSQLLexVARCHAR = 457 + StarRocksSQLLexVARIABLES = 458 + StarRocksSQLLexVECTOR = 459 + StarRocksSQLLexVERBOSE = 460 + StarRocksSQLLexVERSION = 461 + StarRocksSQLLexVIEW = 462 + StarRocksSQLLexVIEWS = 463 + StarRocksSQLLexVOLUME = 464 + StarRocksSQLLexVOLUMES = 465 + StarRocksSQLLexWAREHOUSE = 466 + StarRocksSQLLexWAREHOUSES = 467 + StarRocksSQLLexWARNINGS = 468 + StarRocksSQLLexWEEK = 469 + StarRocksSQLLexWHEN = 470 + StarRocksSQLLexWHERE = 471 + StarRocksSQLLexWHITELIST = 472 + StarRocksSQLLexWITH = 473 + StarRocksSQLLexWORK = 474 + StarRocksSQLLexWRITE = 475 + StarRocksSQLLexYEAR = 476 + StarRocksSQLLexLOCK = 477 + StarRocksSQLLexUNLOCK = 478 + StarRocksSQLLexLOW_PRIORITY = 479 + StarRocksSQLLexDISK = 480 + StarRocksSQLLexDISKS = 481 + StarRocksSQLLexBEFORE = 482 + StarRocksSQLLexDOUBLE_DOLLAR = 483 + StarRocksSQLLexFIELD = 484 + StarRocksSQLLexPERSISTENT = 485 + StarRocksSQLLexSKEW = 486 + StarRocksSQLLexENCRYPT = 487 + StarRocksSQLLexCACHED = 488 + StarRocksSQLLexLIGHT = 489 + StarRocksSQLLexRECYCLE = 490 + StarRocksSQLLexBIN = 491 + StarRocksSQLLexTRASH = 492 + StarRocksSQLLexWORKLOAD = 493 + StarRocksSQLLexSQL = 494 + StarRocksSQLLexBLOCK = 495 + StarRocksSQLLexTASKS = 496 + StarRocksSQLLexCHANGE = 497 + StarRocksSQLLexPROCESS = 498 + StarRocksSQLLexMIGRATIONS = 499 + StarRocksSQLLexEQ = 500 + StarRocksSQLLexNEQ = 501 + StarRocksSQLLexLT = 502 + StarRocksSQLLexLTE = 503 + StarRocksSQLLexGT = 504 + StarRocksSQLLexGTE = 505 + StarRocksSQLLexEQ_FOR_NULL = 506 + StarRocksSQLLexARRAY_ELEMENT = 507 + StarRocksSQLLexPLUS_SYMBOL = 508 + StarRocksSQLLexMINUS_SYMBOL = 509 + StarRocksSQLLexASTERISK_SYMBOL = 510 + StarRocksSQLLexSLASH_SYMBOL = 511 + StarRocksSQLLexPERCENT_SYMBOL = 512 + StarRocksSQLLexLOGICAL_OR = 513 + StarRocksSQLLexLOGICAL_AND = 514 + StarRocksSQLLexLOGICAL_NOT = 515 + StarRocksSQLLexINT_DIV = 516 + StarRocksSQLLexBITAND = 517 + StarRocksSQLLexBITOR = 518 + StarRocksSQLLexBITXOR = 519 + StarRocksSQLLexBITNOT = 520 + StarRocksSQLLexBIT_SHIFT_LEFT = 521 + StarRocksSQLLexBIT_SHIFT_RIGHT = 522 + StarRocksSQLLexBIT_SHIFT_RIGHT_LOGICAL = 523 + StarRocksSQLLexARROW = 524 + StarRocksSQLLexAT = 525 + StarRocksSQLLexINTEGER_VALUE = 526 + StarRocksSQLLexDECIMAL_VALUE = 527 + StarRocksSQLLexDOUBLE_VALUE = 528 + StarRocksSQLLexSINGLE_QUOTED_TEXT = 529 + StarRocksSQLLexDOUBLE_QUOTED_TEXT = 530 + StarRocksSQLLexBINARY_SINGLE_QUOTED_TEXT = 531 + StarRocksSQLLexBINARY_DOUBLE_QUOTED_TEXT = 532 + StarRocksSQLLexLETTER_IDENTIFIER = 533 + StarRocksSQLLexDIGIT_IDENTIFIER = 534 + StarRocksSQLLexBACKQUOTED_IDENTIFIER = 535 + StarRocksSQLLexDOT_IDENTIFIER = 536 + StarRocksSQLLexSIMPLE_COMMENT = 537 + StarRocksSQLLexBRACKETED_COMMENT = 538 + StarRocksSQLLexOPTIMIZER_HINT = 539 + StarRocksSQLLexSEMICOLON = 540 + StarRocksSQLLexDOTDOTDOT = 541 + StarRocksSQLLexWS = 542 + StarRocksSQLLexATTACHMENT = 543 )