Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.shardingsphere.sql.parser.autogen.OpenGaussStatementParser Maven / Gradle / Ivy
// Generated from org/apache/shardingsphere/sql/parser/autogen/OpenGaussStatement.g4 by ANTLR 4.10.1
package org.apache.shardingsphere.sql.parser.autogen;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class OpenGaussStatementParser extends Parser {
static { RuntimeMetaData.checkVersion("4.10.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, BLOCK_COMMENT=2, INLINE_COMMENT=3, AND_=4, OR_=5, NOT_=6, TILDE_=7,
VERTICAL_BAR_=8, AMPERSAND_=9, SIGNED_LEFT_SHIFT_=10, SIGNED_RIGHT_SHIFT_=11,
CARET_=12, MOD_=13, COLON_=14, PLUS_=15, MINUS_=16, ASTERISK_=17, SLASH_=18,
BACKSLASH_=19, DOT_=20, DOT_ASTERISK_=21, SAFE_EQ_=22, DEQ_=23, EQ_=24,
CQ_=25, NEQ_=26, GT_=27, GTE_=28, LT_=29, LTE_=30, POUND_=31, LP_=32,
RP_=33, LBE_=34, RBE_=35, LBT_=36, RBT_=37, COMMA_=38, DQ_=39, SQ_=40,
BQ_=41, QUESTION_=42, DOLLAR_=43, AT_=44, SEMI_=45, TILDE_TILDE_=46, NOT_TILDE_TILDE_=47,
TYPE_CAST_=48, ILIKE_=49, NOT_ILIKE_=50, UNICODE_ESCAPE=51, JSON_EXTRACT_=52,
JSON_EXTRACT_TEXT_=53, JSON_PATH_EXTRACT_=54, JSON_PATH_EXTRACT_TEXT_=55,
JSONB_CONTAIN_RIGHT_=56, JSONB_CONTAIN_LEFT_=57, JSONB_CONTAIN_ALL_TOP_KEY_=58,
JSONB_PATH_DELETE_=59, JSONB_PATH_CONTAIN_ANY_VALUE_=60, JSONB_PATH_PREDICATE_CHECK_=61,
GEOMETRIC_LENGTH_=62, GEOMETRIC_DISTANCE_=63, GEOMETRIC_EXTEND_RIGHT_=64,
GEOMETRIC_EXTEND_LEFT_=65, GEOMETRIC_STRICT_BELOW_=66, GEOMETRIC_STRICT_ABOVE_=67,
GEOMETRIC_EXTEND_ABOVE_=68, GEOMETRIC_EXTEND_BELOW_=69, GEOMETRIC_BELOW_=70,
GEOMETRIC_ABOVE_=71, GEOMETRIC_INTERSECT_=72, GEOMETRIC_PERPENDICULAR_=73,
GEOMETRIC_SAME_AS_=74, WS=75, SELECT=76, INSERT=77, UPDATE=78, DELETE=79,
CREATE=80, ALTER=81, DROP=82, TRUNCATE=83, SCHEMA=84, GRANT=85, REVOKE=86,
ADD=87, SET=88, TABLE=89, COLUMN=90, INDEX=91, CONSTRAINT=92, PRIMARY=93,
UNIQUE=94, FOREIGN=95, KEY=96, POSITION=97, PRECISION=98, FUNCTION=99,
TRIGGER=100, PROCEDURE=101, VIEW=102, INTO=103, VALUES=104, WITH=105,
UNION=106, DISTINCT=107, MAXSIZE=108, CASE=109, WHEN=110, CAST=111, TRIM=112,
SUBSTRING=113, FROM=114, NATURAL=115, JOIN=116, FULL=117, INNER=118, OUTER=119,
LEFT=120, RIGHT=121, CROSS=122, USING=123, WHERE=124, AS=125, ON=126,
IF=127, ELSE=128, THEN=129, FOR=130, TO=131, AND=132, OR=133, IS=134,
NOT=135, NULL=136, TRUE=137, FALSE=138, EXISTS=139, BETWEEN=140, IN=141,
ALL=142, ANY=143, LIKE=144, ORDER=145, GROUP=146, BY=147, ASC=148, DESC=149,
HAVING=150, LIMIT=151, OFFSET=152, BEGIN=153, COMMIT=154, ROLLBACK=155,
SAVEPOINT=156, BOOLEAN=157, DOUBLE=158, CHAR=159, CHARACTER=160, ARRAY=161,
INTERVAL=162, DATE=163, TIME=164, TIMESTAMP=165, LOCALTIME=166, LOCALTIMESTAMP=167,
YEAR=168, QUARTER=169, MONTH=170, WEEK=171, DAY=172, HOUR=173, MINUTE=174,
SECOND=175, MICROSECOND=176, DEFAULT=177, CURRENT=178, ENABLE=179, DISABLE=180,
CALL=181, INSTANCE=182, PRESERVE=183, DO=184, DEFINER=185, CURRENT_USER=186,
SQL=187, CASCADED=188, LOCAL=189, CLOSE=190, OPEN=191, NEXT=192, NAME=193,
COLLATION=194, NAMES=195, INTEGER=196, REAL=197, DECIMAL=198, TYPE=199,
SMALLINT=200, BIGINT=201, NUMERIC=202, TEXT=203, REPEATABLE=204, CURRENT_DATE=205,
CURRENT_TIME=206, CURRENT_TIMESTAMP=207, NULLIF=208, VARYING=209, NATIONAL=210,
NCHAR=211, VALUE=212, BOTH=213, LEADING=214, TRAILING=215, COALESCE=216,
INTERSECT=217, EXCEPT=218, PACKAGE=219, MINUS=220, TIES=221, FETCH=222,
CUBE=223, GROUPING=224, SETS=225, WINDOW=226, OTHERS=227, OVERLAPS=228,
SOME=229, AT=230, DEC=231, END=232, LESS=233, THAN=234, MAXVALUE=235,
FOR_GENERATOR=236, ADMIN=237, BINARY=238, ESCAPE=239, EXCLUDE=240, MOD=241,
PARTITION=242, ROW=243, UNKNOWN=244, ALWAYS=245, CASCADE=246, CHECK=247,
GENERATED=248, ISOLATION=249, LEVEL=250, NO=251, OPTION=252, PRIVILEGES=253,
READ=254, REFERENCES=255, ROLE=256, ROWS=257, START=258, TRANSACTION=259,
USER=260, ACTION=261, CACHE=262, CHARACTERISTICS=263, CLUSTER=264, COLLATE=265,
COMMENTS=266, CONCURRENTLY=267, CONNECT=268, CONSTRAINTS=269, CYCLE=270,
DATA=271, DATABASE=272, DEFAULTS=273, DEFERRABLE=274, DEFERRED=275, DEPENDS=276,
DOMAIN=277, EXCLUDING=278, EXECUTE=279, EXTENDED=280, EXTENSION=281, EXTERNAL=282,
EXTRACT=283, FILTER=284, FIRST=285, FOLLOWING=286, FORCE=287, GLOBAL=288,
IDENTITY=289, IMMEDIATE=290, INCLUDING=291, INCREMENT=292, INDEXES=293,
INHERIT=294, INHERITS=295, INITIALLY=296, INCLUDE=297, LANGUAGE=298, LARGE=299,
LAST=300, LOGGED=301, MAIN=302, MATCH=303, MINVALUE=304, NOTHING=305,
NULLS=306, OBJECT=307, OIDS=308, ONLY=309, OVER=310, OWNED=311, OWNER=312,
PARTIAL=313, PLAIN=314, PRECEDING=315, RANGE=316, RENAME=317, REPLICA=318,
RESET=319, RESTART=320, RESTRICT=321, ROUTINE=322, SYNONYM=323, RULE=324,
SECURITY=325, SEQUENCE=326, SESSION=327, SESSION_USER=328, SHOW=329, SIMPLE=330,
STATISTICS=331, STORAGE=332, TABLESPACE=333, TEMP=334, TEMPORARY=335,
UNBOUNDED=336, UNLOGGED=337, USAGE=338, VALID=339, VALIDATE=340, WITHIN=341,
WITHOUT=342, ZONE=343, OF=344, UESCAPE=345, GROUPS=346, RECURSIVE=347,
INT=348, INT2=349, INT4=350, INT8=351, FLOAT=352, FLOAT4=353, FLOAT8=354,
SMALLSERIAL=355, SERIAL=356, BIGSERIAL=357, VARCHAR=358, BYTEA=359, ENUM=360,
POINT=361, LINE=362, LSEG=363, BOX=364, PATH=365, POLYGON=366, CIRCLE=367,
CIDR=368, INET=369, MACADDR=370, MACADDR8=371, BIT=372, VARBIT=373, TSVECTOR=374,
TSQUERY=375, XML=376, JSON=377, INT4RANGE=378, INT8RANGE=379, NUMRANGE=380,
TSRANGE=381, TSTZRANGE=382, DATERANGE=383, TABLESAMPLE=384, ORDINALITY=385,
CURRENT_ROLE=386, CURRENT_CATALOG=387, CURRENT_SCHEMA=388, NORMALIZE=389,
OVERLAY=390, XMLCONCAT=391, XMLELEMENT=392, XMLEXISTS=393, XMLFOREST=394,
XMLPARSE=395, XMLPI=396, XMLROOT=397, XMLSERIALIZE=398, TREAT=399, SETOF=400,
NFC=401, NFD=402, NFKC=403, NFKD=404, XMLATTRIBUTES=405, REF=406, PASSING=407,
VERSION=408, YES=409, STANDALONE=410, GREATEST=411, LEAST=412, MATERIALIZED=413,
OPERATOR=414, SHARE=415, ROLLUP=416, ILIKE=417, SIMILAR=418, ISNULL=419,
NOTNULL=420, SYMMETRIC=421, DOCUMENT=422, NORMALIZED=423, ASYMMETRIC=424,
VARIADIC=425, NOWAIT=426, LOCKED=427, XMLTABLE=428, COLUMNS=429, CONTENT=430,
STRIP=431, WHITESPACE=432, XMLNAMESPACES=433, PLACING=434, RETURNING=435,
LATERAL=436, NONE=437, ANALYSE=438, ANALYZE=439, CONFLICT=440, OVERRIDING=441,
SYSTEM=442, ABORT=443, ABSOLUTE=444, ACCESS=445, AFTER=446, AGGREGATE=447,
ALSO=448, ATTACH=449, ATTRIBUTE=450, BACKWARD=451, BEFORE=452, ASSERTION=453,
ASSIGNMENT=454, CONTINUE=455, CONVERSION=456, COPY=457, COST=458, CSV=459,
CALLED=460, CATALOG=461, CHAIN=462, CHECKPOINT=463, CLASS=464, CONFIGURATION=465,
COMMENT=466, DETACH=467, DICTIONARY=468, DIRECTORY=469, EXPRESSION=470,
INSENSITIVE=471, DISCARD=472, OFF=473, INSTEAD=474, EXPLAIN=475, INPUT=476,
INLINE=477, PARALLEL=478, LEAKPROOF=479, COMMITTED=480, ENCODING=481,
IMPLICIT=482, DELIMITER=483, CURSOR=484, EACH=485, EVENT=486, DEALLOCATE=487,
CONNECTION=488, DECLARE=489, FAMILY=490, FORWARD=491, EXCLUSIVE=492, FUNCTIONS=493,
LOCATION=494, LABEL=495, DELIMITERS=496, HANDLER=497, HEADER=498, IMMUTABLE=499,
GRANTED=500, HOLD=501, MAPPING=502, OLD=503, METHOD=504, LOAD=505, LISTEN=506,
MODE=507, MOVE=508, PROCEDURAL=509, PARSER=510, PROCEDURES=511, ENCRYPTED=512,
PUBLICATION=513, PROGRAM=514, REFERENCING=515, PLANS=516, REINDEX=517,
PRIOR=518, PASSWORD=519, RELATIVE=520, QUOTE=521, ROUTINES=522, REPLACE=523,
SNAPSHOT=524, REFRESH=525, PREPARE=526, OPTIONS=527, IMPORT=528, INVOKER=529,
NEW=530, PREPARED=531, SCROLL=532, SEQUENCES=533, SYSID=534, REASSIGN=535,
SERVER=536, SUBSCRIPTION=537, SEARCH=538, SCHEMAS=539, RECHECK=540, POLICY=541,
NOTIFY=542, LOCK=543, RELEASE=544, SERIALIZABLE=545, RETURNS=546, STATEMENT=547,
STDIN=548, STDOUT=549, TABLES=550, SUPPORT=551, STABLE=552, TEMPLATE=553,
UNENCRYPTED=554, VIEWS=555, UNCOMMITTED=556, TRANSFORM=557, UNLISTEN=558,
TRUSTED=559, VALIDATOR=560, UNTIL=561, VACUUM=562, VOLATILE=563, STORED=564,
WRITE=565, STRICT=566, TYPES=567, WRAPPER=568, WORK=569, FREEZE=570, AUTHORIZATION=571,
VERBOSE=572, PERFORMANCE=573, PARAM=574, OUT=575, INOUT=576, DUPLICATE=577,
IDENTIFIER_=578, STRING_=579, NUMBER_=580, HEX_DIGIT_=581, BIT_NUM_=582,
FILESIZE_LITERAL=583;
public static final int
RULE_execute = 0, RULE_setTransaction = 1, RULE_beginTransaction = 2,
RULE_commit = 3, RULE_savepoint = 4, RULE_abort = 5, RULE_startTransaction = 6,
RULE_end = 7, RULE_rollback = 8, RULE_releaseSavepoint = 9, RULE_rollbackToSavepoint = 10,
RULE_prepareTransaction = 11, RULE_commitPrepared = 12, RULE_rollbackPrepared = 13,
RULE_setConstraints = 14, RULE_constraintsSetMode = 15, RULE_constraintsSetList = 16,
RULE_insert = 17, RULE_insertTarget = 18, RULE_insertRest = 19, RULE_overrideKind = 20,
RULE_insertColumnList = 21, RULE_insertColumnItem = 22, RULE_optOnDuplicateKey = 23,
RULE_assignment = 24, RULE_update = 25, RULE_setClauseList = 26, RULE_setClause = 27,
RULE_setTarget = 28, RULE_setTargetList = 29, RULE_returningClause = 30,
RULE_delete = 31, RULE_relationExprOptAlias = 32, RULE_usingClause = 33,
RULE_select = 34, RULE_selectWithParens = 35, RULE_selectNoParens = 36,
RULE_selectClauseN = 37, RULE_simpleSelect = 38, RULE_withClause = 39,
RULE_intoClause = 40, RULE_optTempTableName = 41, RULE_cteList = 42, RULE_commonTableExpr = 43,
RULE_optMaterialized = 44, RULE_optNameList = 45, RULE_preparableStmt = 46,
RULE_forLockingClause = 47, RULE_forLockingItems = 48, RULE_forLockingItem = 49,
RULE_nowaitOrSkip = 50, RULE_forLockingStrength = 51, RULE_lockedRelsList = 52,
RULE_qualifiedNameList = 53, RULE_selectLimit = 54, RULE_valuesClause = 55,
RULE_limitClause = 56, RULE_offsetClause = 57, RULE_selectLimitValue = 58,
RULE_selectOffsetValue = 59, RULE_selectFetchValue = 60, RULE_rowOrRows = 61,
RULE_firstOrNext = 62, RULE_onlyOrWithTies = 63, RULE_targetList = 64,
RULE_targetEl = 65, RULE_groupClause = 66, RULE_groupByList = 67, RULE_groupByItem = 68,
RULE_emptyGroupingSet = 69, RULE_rollupClause = 70, RULE_cubeClause = 71,
RULE_groupingSetsClause = 72, RULE_windowClause = 73, RULE_windowDefinitionList = 74,
RULE_windowDefinition = 75, RULE_windowSpecification = 76, RULE_existingWindowName = 77,
RULE_partitionClause = 78, RULE_frameClause = 79, RULE_frameExtent = 80,
RULE_frameBound = 81, RULE_optWindowExclusionClause = 82, RULE_alias = 83,
RULE_fromClause = 84, RULE_fromList = 85, RULE_tableReference = 86, RULE_joinedTable = 87,
RULE_crossJoinType = 88, RULE_innerJoinType = 89, RULE_outerJoinType = 90,
RULE_naturalJoinType = 91, RULE_joinQual = 92, RULE_relationExpr = 93,
RULE_whereClause = 94, RULE_whereOrCurrentClause = 95, RULE_havingClause = 96,
RULE_doStatement = 97, RULE_dostmtOptList = 98, RULE_dostmtOptItem = 99,
RULE_lock = 100, RULE_lockType = 101, RULE_checkpoint = 102, RULE_copy = 103,
RULE_copyOptions = 104, RULE_copyGenericOptList = 105, RULE_copyGenericOptElem = 106,
RULE_copyGenericOptArg = 107, RULE_copyGenericOptArgList = 108, RULE_copyGenericOptArgListItem = 109,
RULE_copyOptList = 110, RULE_copyOptItem = 111, RULE_copyDelimiter = 112,
RULE_parameterMarker = 113, RULE_reservedKeyword = 114, RULE_numberLiterals = 115,
RULE_literalsType = 116, RULE_identifier = 117, RULE_uescape = 118, RULE_unreservedWord = 119,
RULE_typeFuncNameKeyword = 120, RULE_schemaName = 121, RULE_synonymName = 122,
RULE_objectName = 123, RULE_tableName = 124, RULE_columnName = 125, RULE_owner = 126,
RULE_name = 127, RULE_tableNames = 128, RULE_columnNames = 129, RULE_collationName = 130,
RULE_indexName = 131, RULE_constraintName = 132, RULE_primaryKey = 133,
RULE_andOperator = 134, RULE_orOperator = 135, RULE_comparisonOperator = 136,
RULE_patternMatchingOperator = 137, RULE_cursorName = 138, RULE_aExpr = 139,
RULE_bExpr = 140, RULE_cExpr = 141, RULE_indirection = 142, RULE_optIndirection = 143,
RULE_indirectionEl = 144, RULE_sliceBound = 145, RULE_inExpr = 146, RULE_caseExpr = 147,
RULE_whenClauseList = 148, RULE_whenClause = 149, RULE_caseDefault = 150,
RULE_caseArg = 151, RULE_columnref = 152, RULE_qualOp = 153, RULE_subqueryOp = 154,
RULE_allOp = 155, RULE_op = 156, RULE_mathOperator = 157, RULE_jsonOperator = 158,
RULE_geometricOperator = 159, RULE_qualAllOp = 160, RULE_ascDesc = 161,
RULE_anyOperator = 162, RULE_windowExclusionClause = 163, RULE_row = 164,
RULE_explicitRow = 165, RULE_implicitRow = 166, RULE_subType = 167, RULE_arrayExpr = 168,
RULE_arrayExprList = 169, RULE_funcArgList = 170, RULE_paramName = 171,
RULE_funcArgExpr = 172, RULE_typeList = 173, RULE_funcApplication = 174,
RULE_funcName = 175, RULE_aexprConst = 176, RULE_numberConst = 177, RULE_qualifiedName = 178,
RULE_colId = 179, RULE_typeFunctionName = 180, RULE_functionTable = 181,
RULE_xmlTable = 182, RULE_xmlTableColumnList = 183, RULE_xmlTableColumnEl = 184,
RULE_xmlTableColumnOptionList = 185, RULE_xmlTableColumnOptionEl = 186,
RULE_xmlNamespaceList = 187, RULE_xmlNamespaceEl = 188, RULE_funcExpr = 189,
RULE_withinGroupClause = 190, RULE_filterClause = 191, RULE_functionExprWindowless = 192,
RULE_ordinality = 193, RULE_functionExprCommonSubexpr = 194, RULE_typeName = 195,
RULE_simpleTypeName = 196, RULE_constTypeName = 197, RULE_exprList = 198,
RULE_extractList = 199, RULE_extractArg = 200, RULE_genericType = 201,
RULE_typeModifiers = 202, RULE_numeric = 203, RULE_constDatetime = 204,
RULE_timezone = 205, RULE_character = 206, RULE_characterWithLength = 207,
RULE_characterWithoutLength = 208, RULE_characterClause = 209, RULE_optFloat = 210,
RULE_attrs = 211, RULE_attrName = 212, RULE_colLable = 213, RULE_bit = 214,
RULE_bitWithLength = 215, RULE_bitWithoutLength = 216, RULE_constInterval = 217,
RULE_optInterval = 218, RULE_optArrayBounds = 219, RULE_intervalSecond = 220,
RULE_unicodeNormalForm = 221, RULE_trimList = 222, RULE_overlayList = 223,
RULE_overlayPlacing = 224, RULE_substrFrom = 225, RULE_substrFor = 226,
RULE_positionList = 227, RULE_substrList = 228, RULE_xmlAttributes = 229,
RULE_xmlAttributeList = 230, RULE_xmlAttributeEl = 231, RULE_xmlExistsArgument = 232,
RULE_xmlPassingMech = 233, RULE_documentOrContent = 234, RULE_xmlWhitespaceOption = 235,
RULE_xmlRootVersion = 236, RULE_xmlRootStandalone = 237, RULE_rowsFromItem = 238,
RULE_rowsFromList = 239, RULE_columnDefList = 240, RULE_tableFuncElementList = 241,
RULE_tableFuncElement = 242, RULE_collateClause = 243, RULE_anyName = 244,
RULE_aliasClause = 245, RULE_directoryName = 246, RULE_packageName = 247,
RULE_pathString = 248, RULE_nameList = 249, RULE_funcAliasClause = 250,
RULE_tablesampleClause = 251, RULE_repeatableClause = 252, RULE_allOrDistinct = 253,
RULE_sortClause = 254, RULE_sortbyList = 255, RULE_sortby = 256, RULE_nullsOrder = 257,
RULE_distinctClause = 258, RULE_distinct = 259, RULE_overClause = 260,
RULE_windowName = 261, RULE_indexParams = 262, RULE_indexElemOptions = 263,
RULE_indexElem = 264, RULE_collate = 265, RULE_optClass = 266, RULE_reloptions = 267,
RULE_reloptionList = 268, RULE_reloptionElem = 269, RULE_defArg = 270,
RULE_funcType = 271, RULE_dataType = 272, RULE_dataTypeName = 273, RULE_dataTypeLength = 274,
RULE_characterSet = 275, RULE_ignoredIdentifier = 276, RULE_ignoredIdentifiers = 277,
RULE_signedIconst = 278, RULE_booleanOrString = 279, RULE_nonReservedWord = 280,
RULE_colNameKeyword = 281, RULE_databaseName = 282, RULE_roleSpec = 283,
RULE_varName = 284, RULE_varList = 285, RULE_varValue = 286, RULE_zoneValue = 287,
RULE_numericOnly = 288, RULE_isoLevel = 289, RULE_columnDef = 290, RULE_colQualList = 291,
RULE_colConstraint = 292, RULE_constraintAttr = 293, RULE_colConstraintElem = 294,
RULE_parenthesizedSeqOptList = 295, RULE_seqOptList = 296, RULE_seqOptElem = 297,
RULE_optColumnList = 298, RULE_columnElem = 299, RULE_columnList = 300,
RULE_generatedWhen = 301, RULE_noInherit = 302, RULE_consTableSpace = 303,
RULE_definition = 304, RULE_defList = 305, RULE_defElem = 306, RULE_colLabel = 307,
RULE_keyActions = 308, RULE_keyDelete = 309, RULE_keyUpdate = 310, RULE_keyAction = 311,
RULE_keyMatch = 312, RULE_createGenericOptions = 313, RULE_genericOptionList = 314,
RULE_genericOptionElem = 315, RULE_genericOptionArg = 316, RULE_genericOptionName = 317,
RULE_replicaIdentity = 318, RULE_operArgtypes = 319, RULE_funcArg = 320,
RULE_argClass = 321, RULE_funcArgsList = 322, RULE_nonReservedWordOrSconst = 323,
RULE_fileName = 324, RULE_roleList = 325, RULE_setResetClause = 326, RULE_setRest = 327,
RULE_transactionModeList = 328, RULE_transactionModeItem = 329, RULE_setRestMore = 330,
RULE_encoding = 331, RULE_genericSet = 332, RULE_variableResetStmt = 333,
RULE_resetRest = 334, RULE_genericReset = 335, RULE_relationExprList = 336,
RULE_commonFuncOptItem = 337, RULE_functionSetResetClause = 338, RULE_rowSecurityCmd = 339,
RULE_event = 340, RULE_typeNameList = 341, RULE_ifNotExists = 342, RULE_ifExists = 343,
RULE_grant = 344, RULE_revoke = 345, RULE_optionForClause = 346, RULE_createUser = 347,
RULE_createOptRoleElem = 348, RULE_alterOptRoleElem = 349, RULE_dropUser = 350,
RULE_alterUser = 351, RULE_alterUserClauses = 352, RULE_alterOptRoleList = 353,
RULE_createRole = 354, RULE_dropRole = 355, RULE_alterRole = 356, RULE_createGroup = 357,
RULE_dropDroup = 358, RULE_reassignOwned = 359, RULE_createTable = 360,
RULE_executeParamClause = 361, RULE_partitionBoundSpec = 362, RULE_hashPartbound = 363,
RULE_hashPartboundElem = 364, RULE_typedTableElementList = 365, RULE_typedTableElement = 366,
RULE_columnOptions = 367, RULE_withData = 368, RULE_tableSpace = 369,
RULE_onCommitOption = 370, RULE_withOption = 371, RULE_tableAccessMethodClause = 372,
RULE_accessMethod = 373, RULE_createIndex = 374, RULE_include = 375, RULE_indexIncludingParams = 376,
RULE_accessMethodClause = 377, RULE_createDatabase = 378, RULE_createView = 379,
RULE_dropDatabase = 380, RULE_dropDirectory = 381, RULE_createDatabaseSpecification = 382,
RULE_createdbOptName = 383, RULE_alterTable = 384, RULE_alterIndex = 385,
RULE_dropTable = 386, RULE_dropTableOpt = 387, RULE_dropIndex = 388, RULE_dropIndexOpt = 389,
RULE_truncateTable = 390, RULE_restartSeqs = 391, RULE_createTableSpecification = 392,
RULE_createDefinitionClause = 393, RULE_createDefinition = 394, RULE_columnDefinition = 395,
RULE_columnConstraint = 396, RULE_constraintClause = 397, RULE_columnConstraintOption = 398,
RULE_checkOption = 399, RULE_defaultExpr = 400, RULE_sequenceOptions = 401,
RULE_sequenceOption = 402, RULE_indexParameters = 403, RULE_action = 404,
RULE_constraintOptionalParam = 405, RULE_likeOption = 406, RULE_tableConstraint = 407,
RULE_tableConstraintOption = 408, RULE_exclusionWhereClause = 409, RULE_exclusionConstraintList = 410,
RULE_exclusionConstraintElem = 411, RULE_inheritClause = 412, RULE_partitionSpec = 413,
RULE_partParams = 414, RULE_partElem = 415, RULE_funcExprWindowless = 416,
RULE_partStrategy = 417, RULE_createIndexSpecification = 418, RULE_concurrentlyClause = 419,
RULE_onlyClause = 420, RULE_fileSizeLiteral = 421, RULE_asteriskClause = 422,
RULE_alterDefinitionClause = 423, RULE_partitionCmd = 424, RULE_alterIndexDefinitionClause = 425,
RULE_indexPartitionCmd = 426, RULE_renameIndexSpecification = 427, RULE_alterIndexDependsOnExtension = 428,
RULE_alterIndexSetTableSpace = 429, RULE_tableNamesClause = 430, RULE_tableNameClause = 431,
RULE_alterTableActions = 432, RULE_alterTableAction = 433, RULE_addColumnSpecification = 434,
RULE_dropColumnSpecification = 435, RULE_modifyColumnSpecification = 436,
RULE_modifyColumn = 437, RULE_alterColumnSetOption = 438, RULE_attributeOptions = 439,
RULE_attributeOption = 440, RULE_addConstraintSpecification = 441, RULE_tableConstraintUsingIndex = 442,
RULE_modifyConstraintSpecification = 443, RULE_validateConstraintSpecification = 444,
RULE_dropConstraintSpecification = 445, RULE_storageParameterWithValue = 446,
RULE_storageParameter = 447, RULE_renameColumnSpecification = 448, RULE_renameConstraint = 449,
RULE_renameTableSpecification = 450, RULE_indexNames = 451, RULE_alterDatabase = 452,
RULE_alterDatabaseClause = 453, RULE_createdbOptItems = 454, RULE_createdbOptItem = 455,
RULE_alterTableCmds = 456, RULE_alterTableCmd = 457, RULE_constraintAttributeSpec = 458,
RULE_constraintAttributeElem = 459, RULE_alterGenericOptions = 460, RULE_alterGenericOptionList = 461,
RULE_alterGenericOptionElem = 462, RULE_dropBehavior = 463, RULE_alterUsing = 464,
RULE_setData = 465, RULE_alterIdentityColumnOptionList = 466, RULE_alterIdentityColumnOption = 467,
RULE_alterColumnDefault = 468, RULE_alterOperator = 469, RULE_alterOperatorClass = 470,
RULE_alterOperatorClassClauses = 471, RULE_alterOperatorFamily = 472,
RULE_alterOperatorFamilyClauses = 473, RULE_opclassItemList = 474, RULE_opclassItem = 475,
RULE_opclassPurpose = 476, RULE_alterOperatorClauses = 477, RULE_operatorDefList = 478,
RULE_operatorDefElem = 479, RULE_operatorDefArg = 480, RULE_operatorWithArgtypes = 481,
RULE_alterAggregate = 482, RULE_aggregateSignature = 483, RULE_aggrArgs = 484,
RULE_aggrArgsList = 485, RULE_aggrArg = 486, RULE_alterAggregateDefinitionClause = 487,
RULE_alterCollation = 488, RULE_alterCollationClause = 489, RULE_alterSynonym = 490,
RULE_alterDirectory = 491, RULE_alterConversion = 492, RULE_alterConversionClause = 493,
RULE_alterDefaultPrivileges = 494, RULE_defACLAction = 495, RULE_grantGrantOption = 496,
RULE_granteeList = 497, RULE_grantee = 498, RULE_defaclPrivilegeTarget = 499,
RULE_privileges = 500, RULE_privilegeList = 501, RULE_privilege = 502,
RULE_defACLOptionList = 503, RULE_defACLOption = 504, RULE_schemaNameList = 505,
RULE_alterDomain = 506, RULE_alterDomainClause = 507, RULE_alterEventTrigger = 508,
RULE_alterEventTriggerClause = 509, RULE_tiggerName = 510, RULE_alterExtension = 511,
RULE_createSynonym = 512, RULE_alterExtensionClauses = 513, RULE_functionWithArgtypes = 514,
RULE_funcArgs = 515, RULE_aggregateWithArgtypes = 516, RULE_alterExtensionOptList = 517,
RULE_alterExtensionOptItem = 518, RULE_alterForeignDataWrapper = 519,
RULE_alterForeignDataWrapperClauses = 520, RULE_fdwOptions = 521, RULE_fdwOption = 522,
RULE_handlerName = 523, RULE_alterGroup = 524, RULE_alterGroupClauses = 525,
RULE_alterLanguage = 526, RULE_alterLargeObject = 527, RULE_alterMaterializedView = 528,
RULE_alterMaterializedViewClauses = 529, RULE_declare = 530, RULE_cursor = 531,
RULE_cursorOptions = 532, RULE_cursorOption = 533, RULE_executeStmt = 534,
RULE_createMaterializedView = 535, RULE_createMvTarget = 536, RULE_refreshMatViewStmt = 537,
RULE_alterPolicy = 538, RULE_alterPolicyClauses = 539, RULE_alterProcedure = 540,
RULE_alterProcedureClauses = 541, RULE_alterfuncOptList = 542, RULE_alterFunction = 543,
RULE_alterFunctionClauses = 544, RULE_alterPublication = 545, RULE_alterRoutine = 546,
RULE_alterRule = 547, RULE_alterSequence = 548, RULE_alterSequenceClauses = 549,
RULE_alterServer = 550, RULE_foreignServerVersion = 551, RULE_alterStatistics = 552,
RULE_alterSubscription = 553, RULE_publicationNameList = 554, RULE_publicationNameItem = 555,
RULE_alterSystem = 556, RULE_alterTablespace = 557, RULE_alterTextSearchConfiguration = 558,
RULE_alterTextSearchConfigurationClauses = 559, RULE_anyNameList = 560,
RULE_alterTextSearchDictionary = 561, RULE_alterTextSearchParser = 562,
RULE_alterTextSearchTemplate = 563, RULE_alterTrigger = 564, RULE_alterType = 565,
RULE_alterTypeClauses = 566, RULE_alterTypeCmds = 567, RULE_alterTypeCmd = 568,
RULE_alterUserMapping = 569, RULE_authIdent = 570, RULE_alterView = 571,
RULE_alterViewClauses = 572, RULE_close = 573, RULE_cluster = 574, RULE_clusterIndexSpecification = 575,
RULE_comment = 576, RULE_commentClauses = 577, RULE_objectTypeNameOnAnyName = 578,
RULE_objectTypeName = 579, RULE_dropTypeName = 580, RULE_objectTypeAnyName = 581,
RULE_commentText = 582, RULE_createAccessMethod = 583, RULE_createAggregate = 584,
RULE_oldAggrDefinition = 585, RULE_oldAggrList = 586, RULE_oldAggrElem = 587,
RULE_createCast = 588, RULE_castContext = 589, RULE_createCollation = 590,
RULE_createConversion = 591, RULE_createDomain = 592, RULE_createEventTrigger = 593,
RULE_eventTriggerWhenList = 594, RULE_eventTriggerWhenItem = 595, RULE_eventTriggerValueList = 596,
RULE_createExtension = 597, RULE_createExtensionOptList = 598, RULE_createExtensionOptItem = 599,
RULE_createForeignDataWrapper = 600, RULE_createForeignTable = 601, RULE_createForeignTableClauses = 602,
RULE_tableElementList = 603, RULE_tableElement = 604, RULE_tableLikeClause = 605,
RULE_tableLikeOptionList = 606, RULE_tableLikeOption = 607, RULE_createFunction = 608,
RULE_tableFuncColumnList = 609, RULE_tableFuncColumn = 610, RULE_createfuncOptList = 611,
RULE_createfuncOptItem = 612, RULE_transformTypeList = 613, RULE_funcAs = 614,
RULE_funcReturn = 615, RULE_funcArgsWithDefaults = 616, RULE_funcArgsWithDefaultsList = 617,
RULE_funcArgWithDefault = 618, RULE_createLanguage = 619, RULE_transformElementList = 620,
RULE_validatorClause = 621, RULE_createPolicy = 622, RULE_createProcedure = 623,
RULE_createPublication = 624, RULE_publicationForTables = 625, RULE_createRule = 626,
RULE_ruleActionList = 627, RULE_ruleActionStmt = 628, RULE_ruleActionMulti = 629,
RULE_notifyStmt = 630, RULE_createTrigger = 631, RULE_triggerEvents = 632,
RULE_triggerOneEvent = 633, RULE_triggerActionTime = 634, RULE_triggerFuncArgs = 635,
RULE_triggerFuncArg = 636, RULE_triggerWhen = 637, RULE_triggerForSpec = 638,
RULE_triggerReferencing = 639, RULE_triggerTransitions = 640, RULE_triggerTransition = 641,
RULE_transitionRelName = 642, RULE_transitionRowOrTable = 643, RULE_transitionOldOrNew = 644,
RULE_createSequence = 645, RULE_tempOption = 646, RULE_createServer = 647,
RULE_createStatistics = 648, RULE_createSubscription = 649, RULE_createTablespace = 650,
RULE_createTextSearch = 651, RULE_createTransform = 652, RULE_createType = 653,
RULE_createTypeClauses = 654, RULE_enumValList = 655, RULE_createUserMapping = 656,
RULE_discard = 657, RULE_dropAccessMethod = 658, RULE_dropAggregate = 659,
RULE_aggregateWithArgtypesList = 660, RULE_dropCast = 661, RULE_dropCollation = 662,
RULE_dropConversion = 663, RULE_dropDomain = 664, RULE_dropEventTrigger = 665,
RULE_dropExtension = 666, RULE_dropForeignDataWrapper = 667, RULE_dropForeignTable = 668,
RULE_dropFunction = 669, RULE_functionWithArgtypesList = 670, RULE_dropLanguage = 671,
RULE_dropMaterializedView = 672, RULE_dropOperator = 673, RULE_operatorWithArgtypesList = 674,
RULE_dropOperatorClass = 675, RULE_dropOperatorFamily = 676, RULE_dropOwned = 677,
RULE_dropPolicy = 678, RULE_dropProcedure = 679, RULE_dropPublication = 680,
RULE_dropRoutine = 681, RULE_dropRule = 682, RULE_dropSequence = 683,
RULE_dropSynonym = 684, RULE_dropServer = 685, RULE_dropStatistics = 686,
RULE_dropSubscription = 687, RULE_dropTablespace = 688, RULE_dropTextSearch = 689,
RULE_dropTransform = 690, RULE_dropTrigger = 691, RULE_dropType = 692,
RULE_dropUserMapping = 693, RULE_dropView = 694, RULE_importForeignSchema = 695,
RULE_importQualification = 696, RULE_importQualificationType = 697, RULE_listen = 698,
RULE_move = 699, RULE_prepare = 700, RULE_deallocate = 701, RULE_prepTypeClause = 702,
RULE_refreshMaterializedView = 703, RULE_reIndex = 704, RULE_reIndexClauses = 705,
RULE_reindexOptionList = 706, RULE_reindexOptionElem = 707, RULE_reindexTargetMultitable = 708,
RULE_reindexTargetType = 709, RULE_alterForeignTable = 710, RULE_alterForeignTableClauses = 711,
RULE_createOperator = 712, RULE_createOperatorClass = 713, RULE_createOperatorFamily = 714,
RULE_securityLabelStmt = 715, RULE_securityLabel = 716, RULE_securityLabelClausces = 717,
RULE_unlisten = 718, RULE_createSchema = 719, RULE_createSchemaClauses = 720,
RULE_schemaEltList = 721, RULE_schemaStmt = 722, RULE_privilegeClause = 723,
RULE_roleClause = 724, RULE_privilegeTypes = 725, RULE_onObjectClause = 726,
RULE_numericOnlyList = 727, RULE_privilegeLevel = 728, RULE_routineName = 729,
RULE_privilegeType = 730, RULE_createDirectory = 731, RULE_alterSchema = 732,
RULE_dropSchema = 733, RULE_fetch = 734, RULE_alterPackage = 735, RULE_direction = 736,
RULE_show = 737, RULE_set = 738, RULE_runtimeScope = 739, RULE_timeZoneClause = 740,
RULE_configurationParameterClause = 741, RULE_resetParameter = 742, RULE_explain = 743,
RULE_explainableStmt = 744, RULE_explainOptionList = 745, RULE_explainOptionElem = 746,
RULE_explainOptionArg = 747, RULE_explainOptionName = 748, RULE_analyzeKeyword = 749,
RULE_analyzeTable = 750, RULE_vacuumRelationList = 751, RULE_vacuumRelation = 752,
RULE_vacAnalyzeOptionList = 753, RULE_vacAnalyzeOptionElem = 754, RULE_vacAnalyzeOptionArg = 755,
RULE_vacAnalyzeOptionName = 756, RULE_load = 757, RULE_vacuum = 758, RULE_emptyStatement = 759,
RULE_call = 760, RULE_callClauses = 761;
private static String[] makeRuleNames() {
return new String[] {
"execute", "setTransaction", "beginTransaction", "commit", "savepoint",
"abort", "startTransaction", "end", "rollback", "releaseSavepoint", "rollbackToSavepoint",
"prepareTransaction", "commitPrepared", "rollbackPrepared", "setConstraints",
"constraintsSetMode", "constraintsSetList", "insert", "insertTarget",
"insertRest", "overrideKind", "insertColumnList", "insertColumnItem",
"optOnDuplicateKey", "assignment", "update", "setClauseList", "setClause",
"setTarget", "setTargetList", "returningClause", "delete", "relationExprOptAlias",
"usingClause", "select", "selectWithParens", "selectNoParens", "selectClauseN",
"simpleSelect", "withClause", "intoClause", "optTempTableName", "cteList",
"commonTableExpr", "optMaterialized", "optNameList", "preparableStmt",
"forLockingClause", "forLockingItems", "forLockingItem", "nowaitOrSkip",
"forLockingStrength", "lockedRelsList", "qualifiedNameList", "selectLimit",
"valuesClause", "limitClause", "offsetClause", "selectLimitValue", "selectOffsetValue",
"selectFetchValue", "rowOrRows", "firstOrNext", "onlyOrWithTies", "targetList",
"targetEl", "groupClause", "groupByList", "groupByItem", "emptyGroupingSet",
"rollupClause", "cubeClause", "groupingSetsClause", "windowClause", "windowDefinitionList",
"windowDefinition", "windowSpecification", "existingWindowName", "partitionClause",
"frameClause", "frameExtent", "frameBound", "optWindowExclusionClause",
"alias", "fromClause", "fromList", "tableReference", "joinedTable", "crossJoinType",
"innerJoinType", "outerJoinType", "naturalJoinType", "joinQual", "relationExpr",
"whereClause", "whereOrCurrentClause", "havingClause", "doStatement",
"dostmtOptList", "dostmtOptItem", "lock", "lockType", "checkpoint", "copy",
"copyOptions", "copyGenericOptList", "copyGenericOptElem", "copyGenericOptArg",
"copyGenericOptArgList", "copyGenericOptArgListItem", "copyOptList",
"copyOptItem", "copyDelimiter", "parameterMarker", "reservedKeyword",
"numberLiterals", "literalsType", "identifier", "uescape", "unreservedWord",
"typeFuncNameKeyword", "schemaName", "synonymName", "objectName", "tableName",
"columnName", "owner", "name", "tableNames", "columnNames", "collationName",
"indexName", "constraintName", "primaryKey", "andOperator", "orOperator",
"comparisonOperator", "patternMatchingOperator", "cursorName", "aExpr",
"bExpr", "cExpr", "indirection", "optIndirection", "indirectionEl", "sliceBound",
"inExpr", "caseExpr", "whenClauseList", "whenClause", "caseDefault",
"caseArg", "columnref", "qualOp", "subqueryOp", "allOp", "op", "mathOperator",
"jsonOperator", "geometricOperator", "qualAllOp", "ascDesc", "anyOperator",
"windowExclusionClause", "row", "explicitRow", "implicitRow", "subType",
"arrayExpr", "arrayExprList", "funcArgList", "paramName", "funcArgExpr",
"typeList", "funcApplication", "funcName", "aexprConst", "numberConst",
"qualifiedName", "colId", "typeFunctionName", "functionTable", "xmlTable",
"xmlTableColumnList", "xmlTableColumnEl", "xmlTableColumnOptionList",
"xmlTableColumnOptionEl", "xmlNamespaceList", "xmlNamespaceEl", "funcExpr",
"withinGroupClause", "filterClause", "functionExprWindowless", "ordinality",
"functionExprCommonSubexpr", "typeName", "simpleTypeName", "constTypeName",
"exprList", "extractList", "extractArg", "genericType", "typeModifiers",
"numeric", "constDatetime", "timezone", "character", "characterWithLength",
"characterWithoutLength", "characterClause", "optFloat", "attrs", "attrName",
"colLable", "bit", "bitWithLength", "bitWithoutLength", "constInterval",
"optInterval", "optArrayBounds", "intervalSecond", "unicodeNormalForm",
"trimList", "overlayList", "overlayPlacing", "substrFrom", "substrFor",
"positionList", "substrList", "xmlAttributes", "xmlAttributeList", "xmlAttributeEl",
"xmlExistsArgument", "xmlPassingMech", "documentOrContent", "xmlWhitespaceOption",
"xmlRootVersion", "xmlRootStandalone", "rowsFromItem", "rowsFromList",
"columnDefList", "tableFuncElementList", "tableFuncElement", "collateClause",
"anyName", "aliasClause", "directoryName", "packageName", "pathString",
"nameList", "funcAliasClause", "tablesampleClause", "repeatableClause",
"allOrDistinct", "sortClause", "sortbyList", "sortby", "nullsOrder",
"distinctClause", "distinct", "overClause", "windowName", "indexParams",
"indexElemOptions", "indexElem", "collate", "optClass", "reloptions",
"reloptionList", "reloptionElem", "defArg", "funcType", "dataType", "dataTypeName",
"dataTypeLength", "characterSet", "ignoredIdentifier", "ignoredIdentifiers",
"signedIconst", "booleanOrString", "nonReservedWord", "colNameKeyword",
"databaseName", "roleSpec", "varName", "varList", "varValue", "zoneValue",
"numericOnly", "isoLevel", "columnDef", "colQualList", "colConstraint",
"constraintAttr", "colConstraintElem", "parenthesizedSeqOptList", "seqOptList",
"seqOptElem", "optColumnList", "columnElem", "columnList", "generatedWhen",
"noInherit", "consTableSpace", "definition", "defList", "defElem", "colLabel",
"keyActions", "keyDelete", "keyUpdate", "keyAction", "keyMatch", "createGenericOptions",
"genericOptionList", "genericOptionElem", "genericOptionArg", "genericOptionName",
"replicaIdentity", "operArgtypes", "funcArg", "argClass", "funcArgsList",
"nonReservedWordOrSconst", "fileName", "roleList", "setResetClause",
"setRest", "transactionModeList", "transactionModeItem", "setRestMore",
"encoding", "genericSet", "variableResetStmt", "resetRest", "genericReset",
"relationExprList", "commonFuncOptItem", "functionSetResetClause", "rowSecurityCmd",
"event", "typeNameList", "ifNotExists", "ifExists", "grant", "revoke",
"optionForClause", "createUser", "createOptRoleElem", "alterOptRoleElem",
"dropUser", "alterUser", "alterUserClauses", "alterOptRoleList", "createRole",
"dropRole", "alterRole", "createGroup", "dropDroup", "reassignOwned",
"createTable", "executeParamClause", "partitionBoundSpec", "hashPartbound",
"hashPartboundElem", "typedTableElementList", "typedTableElement", "columnOptions",
"withData", "tableSpace", "onCommitOption", "withOption", "tableAccessMethodClause",
"accessMethod", "createIndex", "include", "indexIncludingParams", "accessMethodClause",
"createDatabase", "createView", "dropDatabase", "dropDirectory", "createDatabaseSpecification",
"createdbOptName", "alterTable", "alterIndex", "dropTable", "dropTableOpt",
"dropIndex", "dropIndexOpt", "truncateTable", "restartSeqs", "createTableSpecification",
"createDefinitionClause", "createDefinition", "columnDefinition", "columnConstraint",
"constraintClause", "columnConstraintOption", "checkOption", "defaultExpr",
"sequenceOptions", "sequenceOption", "indexParameters", "action", "constraintOptionalParam",
"likeOption", "tableConstraint", "tableConstraintOption", "exclusionWhereClause",
"exclusionConstraintList", "exclusionConstraintElem", "inheritClause",
"partitionSpec", "partParams", "partElem", "funcExprWindowless", "partStrategy",
"createIndexSpecification", "concurrentlyClause", "onlyClause", "fileSizeLiteral",
"asteriskClause", "alterDefinitionClause", "partitionCmd", "alterIndexDefinitionClause",
"indexPartitionCmd", "renameIndexSpecification", "alterIndexDependsOnExtension",
"alterIndexSetTableSpace", "tableNamesClause", "tableNameClause", "alterTableActions",
"alterTableAction", "addColumnSpecification", "dropColumnSpecification",
"modifyColumnSpecification", "modifyColumn", "alterColumnSetOption",
"attributeOptions", "attributeOption", "addConstraintSpecification",
"tableConstraintUsingIndex", "modifyConstraintSpecification", "validateConstraintSpecification",
"dropConstraintSpecification", "storageParameterWithValue", "storageParameter",
"renameColumnSpecification", "renameConstraint", "renameTableSpecification",
"indexNames", "alterDatabase", "alterDatabaseClause", "createdbOptItems",
"createdbOptItem", "alterTableCmds", "alterTableCmd", "constraintAttributeSpec",
"constraintAttributeElem", "alterGenericOptions", "alterGenericOptionList",
"alterGenericOptionElem", "dropBehavior", "alterUsing", "setData", "alterIdentityColumnOptionList",
"alterIdentityColumnOption", "alterColumnDefault", "alterOperator", "alterOperatorClass",
"alterOperatorClassClauses", "alterOperatorFamily", "alterOperatorFamilyClauses",
"opclassItemList", "opclassItem", "opclassPurpose", "alterOperatorClauses",
"operatorDefList", "operatorDefElem", "operatorDefArg", "operatorWithArgtypes",
"alterAggregate", "aggregateSignature", "aggrArgs", "aggrArgsList", "aggrArg",
"alterAggregateDefinitionClause", "alterCollation", "alterCollationClause",
"alterSynonym", "alterDirectory", "alterConversion", "alterConversionClause",
"alterDefaultPrivileges", "defACLAction", "grantGrantOption", "granteeList",
"grantee", "defaclPrivilegeTarget", "privileges", "privilegeList", "privilege",
"defACLOptionList", "defACLOption", "schemaNameList", "alterDomain",
"alterDomainClause", "alterEventTrigger", "alterEventTriggerClause",
"tiggerName", "alterExtension", "createSynonym", "alterExtensionClauses",
"functionWithArgtypes", "funcArgs", "aggregateWithArgtypes", "alterExtensionOptList",
"alterExtensionOptItem", "alterForeignDataWrapper", "alterForeignDataWrapperClauses",
"fdwOptions", "fdwOption", "handlerName", "alterGroup", "alterGroupClauses",
"alterLanguage", "alterLargeObject", "alterMaterializedView", "alterMaterializedViewClauses",
"declare", "cursor", "cursorOptions", "cursorOption", "executeStmt",
"createMaterializedView", "createMvTarget", "refreshMatViewStmt", "alterPolicy",
"alterPolicyClauses", "alterProcedure", "alterProcedureClauses", "alterfuncOptList",
"alterFunction", "alterFunctionClauses", "alterPublication", "alterRoutine",
"alterRule", "alterSequence", "alterSequenceClauses", "alterServer",
"foreignServerVersion", "alterStatistics", "alterSubscription", "publicationNameList",
"publicationNameItem", "alterSystem", "alterTablespace", "alterTextSearchConfiguration",
"alterTextSearchConfigurationClauses", "anyNameList", "alterTextSearchDictionary",
"alterTextSearchParser", "alterTextSearchTemplate", "alterTrigger", "alterType",
"alterTypeClauses", "alterTypeCmds", "alterTypeCmd", "alterUserMapping",
"authIdent", "alterView", "alterViewClauses", "close", "cluster", "clusterIndexSpecification",
"comment", "commentClauses", "objectTypeNameOnAnyName", "objectTypeName",
"dropTypeName", "objectTypeAnyName", "commentText", "createAccessMethod",
"createAggregate", "oldAggrDefinition", "oldAggrList", "oldAggrElem",
"createCast", "castContext", "createCollation", "createConversion", "createDomain",
"createEventTrigger", "eventTriggerWhenList", "eventTriggerWhenItem",
"eventTriggerValueList", "createExtension", "createExtensionOptList",
"createExtensionOptItem", "createForeignDataWrapper", "createForeignTable",
"createForeignTableClauses", "tableElementList", "tableElement", "tableLikeClause",
"tableLikeOptionList", "tableLikeOption", "createFunction", "tableFuncColumnList",
"tableFuncColumn", "createfuncOptList", "createfuncOptItem", "transformTypeList",
"funcAs", "funcReturn", "funcArgsWithDefaults", "funcArgsWithDefaultsList",
"funcArgWithDefault", "createLanguage", "transformElementList", "validatorClause",
"createPolicy", "createProcedure", "createPublication", "publicationForTables",
"createRule", "ruleActionList", "ruleActionStmt", "ruleActionMulti",
"notifyStmt", "createTrigger", "triggerEvents", "triggerOneEvent", "triggerActionTime",
"triggerFuncArgs", "triggerFuncArg", "triggerWhen", "triggerForSpec",
"triggerReferencing", "triggerTransitions", "triggerTransition", "transitionRelName",
"transitionRowOrTable", "transitionOldOrNew", "createSequence", "tempOption",
"createServer", "createStatistics", "createSubscription", "createTablespace",
"createTextSearch", "createTransform", "createType", "createTypeClauses",
"enumValList", "createUserMapping", "discard", "dropAccessMethod", "dropAggregate",
"aggregateWithArgtypesList", "dropCast", "dropCollation", "dropConversion",
"dropDomain", "dropEventTrigger", "dropExtension", "dropForeignDataWrapper",
"dropForeignTable", "dropFunction", "functionWithArgtypesList", "dropLanguage",
"dropMaterializedView", "dropOperator", "operatorWithArgtypesList", "dropOperatorClass",
"dropOperatorFamily", "dropOwned", "dropPolicy", "dropProcedure", "dropPublication",
"dropRoutine", "dropRule", "dropSequence", "dropSynonym", "dropServer",
"dropStatistics", "dropSubscription", "dropTablespace", "dropTextSearch",
"dropTransform", "dropTrigger", "dropType", "dropUserMapping", "dropView",
"importForeignSchema", "importQualification", "importQualificationType",
"listen", "move", "prepare", "deallocate", "prepTypeClause", "refreshMaterializedView",
"reIndex", "reIndexClauses", "reindexOptionList", "reindexOptionElem",
"reindexTargetMultitable", "reindexTargetType", "alterForeignTable",
"alterForeignTableClauses", "createOperator", "createOperatorClass",
"createOperatorFamily", "securityLabelStmt", "securityLabel", "securityLabelClausces",
"unlisten", "createSchema", "createSchemaClauses", "schemaEltList", "schemaStmt",
"privilegeClause", "roleClause", "privilegeTypes", "onObjectClause",
"numericOnlyList", "privilegeLevel", "routineName", "privilegeType",
"createDirectory", "alterSchema", "dropSchema", "fetch", "alterPackage",
"direction", "show", "set", "runtimeScope", "timeZoneClause", "configurationParameterClause",
"resetParameter", "explain", "explainableStmt", "explainOptionList",
"explainOptionElem", "explainOptionArg", "explainOptionName", "analyzeKeyword",
"analyzeTable", "vacuumRelationList", "vacuumRelation", "vacAnalyzeOptionList",
"vacAnalyzeOptionElem", "vacAnalyzeOptionArg", "vacAnalyzeOptionName",
"load", "vacuum", "emptyStatement", "call", "callClauses"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'skip'", null, null, "'&&'", "'||'", "'!'", "'~'", "'|'", "'&'",
"'<<'", "'>>'", "'^'", "'%'", "':'", "'+'", "'-'", "'*'", "'/'", "'\\'",
"'.'", "'.*'", "'<=>'", "'=='", "'='", "':='", null, "'>'", "'>='", "'<'",
"'<='", "'#'", "'('", "')'", "'{'", "'}'", "'['", "']'", "','", "'\"'",
"'''", "'`'", "'?'", "'$'", "'@'", "';'", "'~~'", "'!~~'", "'::'", "'~~*'",
"'!~~*'", null, "'->'", "'->>'", "'#>'", "'#>>'", "'@>'", "'<@'", "'?&'",
"'#-'", "'@?'", "'@@'", "'@-@'", "'<->'", "'&<'", "'&>'", "'<<|'", "'|>>'",
"'&<|'", "'|&>'", "'<^'", "'>^'", "'?#'", "'?-|'", "'~='", null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, "'DO NOT MATCH ANY THING, JUST FOR GENERATOR'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, "BLOCK_COMMENT", "INLINE_COMMENT", "AND_", "OR_", "NOT_",
"TILDE_", "VERTICAL_BAR_", "AMPERSAND_", "SIGNED_LEFT_SHIFT_", "SIGNED_RIGHT_SHIFT_",
"CARET_", "MOD_", "COLON_", "PLUS_", "MINUS_", "ASTERISK_", "SLASH_",
"BACKSLASH_", "DOT_", "DOT_ASTERISK_", "SAFE_EQ_", "DEQ_", "EQ_", "CQ_",
"NEQ_", "GT_", "GTE_", "LT_", "LTE_", "POUND_", "LP_", "RP_", "LBE_",
"RBE_", "LBT_", "RBT_", "COMMA_", "DQ_", "SQ_", "BQ_", "QUESTION_", "DOLLAR_",
"AT_", "SEMI_", "TILDE_TILDE_", "NOT_TILDE_TILDE_", "TYPE_CAST_", "ILIKE_",
"NOT_ILIKE_", "UNICODE_ESCAPE", "JSON_EXTRACT_", "JSON_EXTRACT_TEXT_",
"JSON_PATH_EXTRACT_", "JSON_PATH_EXTRACT_TEXT_", "JSONB_CONTAIN_RIGHT_",
"JSONB_CONTAIN_LEFT_", "JSONB_CONTAIN_ALL_TOP_KEY_", "JSONB_PATH_DELETE_",
"JSONB_PATH_CONTAIN_ANY_VALUE_", "JSONB_PATH_PREDICATE_CHECK_", "GEOMETRIC_LENGTH_",
"GEOMETRIC_DISTANCE_", "GEOMETRIC_EXTEND_RIGHT_", "GEOMETRIC_EXTEND_LEFT_",
"GEOMETRIC_STRICT_BELOW_", "GEOMETRIC_STRICT_ABOVE_", "GEOMETRIC_EXTEND_ABOVE_",
"GEOMETRIC_EXTEND_BELOW_", "GEOMETRIC_BELOW_", "GEOMETRIC_ABOVE_", "GEOMETRIC_INTERSECT_",
"GEOMETRIC_PERPENDICULAR_", "GEOMETRIC_SAME_AS_", "WS", "SELECT", "INSERT",
"UPDATE", "DELETE", "CREATE", "ALTER", "DROP", "TRUNCATE", "SCHEMA",
"GRANT", "REVOKE", "ADD", "SET", "TABLE", "COLUMN", "INDEX", "CONSTRAINT",
"PRIMARY", "UNIQUE", "FOREIGN", "KEY", "POSITION", "PRECISION", "FUNCTION",
"TRIGGER", "PROCEDURE", "VIEW", "INTO", "VALUES", "WITH", "UNION", "DISTINCT",
"MAXSIZE", "CASE", "WHEN", "CAST", "TRIM", "SUBSTRING", "FROM", "NATURAL",
"JOIN", "FULL", "INNER", "OUTER", "LEFT", "RIGHT", "CROSS", "USING",
"WHERE", "AS", "ON", "IF", "ELSE", "THEN", "FOR", "TO", "AND", "OR",
"IS", "NOT", "NULL", "TRUE", "FALSE", "EXISTS", "BETWEEN", "IN", "ALL",
"ANY", "LIKE", "ORDER", "GROUP", "BY", "ASC", "DESC", "HAVING", "LIMIT",
"OFFSET", "BEGIN", "COMMIT", "ROLLBACK", "SAVEPOINT", "BOOLEAN", "DOUBLE",
"CHAR", "CHARACTER", "ARRAY", "INTERVAL", "DATE", "TIME", "TIMESTAMP",
"LOCALTIME", "LOCALTIMESTAMP", "YEAR", "QUARTER", "MONTH", "WEEK", "DAY",
"HOUR", "MINUTE", "SECOND", "MICROSECOND", "DEFAULT", "CURRENT", "ENABLE",
"DISABLE", "CALL", "INSTANCE", "PRESERVE", "DO", "DEFINER", "CURRENT_USER",
"SQL", "CASCADED", "LOCAL", "CLOSE", "OPEN", "NEXT", "NAME", "COLLATION",
"NAMES", "INTEGER", "REAL", "DECIMAL", "TYPE", "SMALLINT", "BIGINT",
"NUMERIC", "TEXT", "REPEATABLE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
"NULLIF", "VARYING", "NATIONAL", "NCHAR", "VALUE", "BOTH", "LEADING",
"TRAILING", "COALESCE", "INTERSECT", "EXCEPT", "PACKAGE", "MINUS", "TIES",
"FETCH", "CUBE", "GROUPING", "SETS", "WINDOW", "OTHERS", "OVERLAPS",
"SOME", "AT", "DEC", "END", "LESS", "THAN", "MAXVALUE", "FOR_GENERATOR",
"ADMIN", "BINARY", "ESCAPE", "EXCLUDE", "MOD", "PARTITION", "ROW", "UNKNOWN",
"ALWAYS", "CASCADE", "CHECK", "GENERATED", "ISOLATION", "LEVEL", "NO",
"OPTION", "PRIVILEGES", "READ", "REFERENCES", "ROLE", "ROWS", "START",
"TRANSACTION", "USER", "ACTION", "CACHE", "CHARACTERISTICS", "CLUSTER",
"COLLATE", "COMMENTS", "CONCURRENTLY", "CONNECT", "CONSTRAINTS", "CYCLE",
"DATA", "DATABASE", "DEFAULTS", "DEFERRABLE", "DEFERRED", "DEPENDS",
"DOMAIN", "EXCLUDING", "EXECUTE", "EXTENDED", "EXTENSION", "EXTERNAL",
"EXTRACT", "FILTER", "FIRST", "FOLLOWING", "FORCE", "GLOBAL", "IDENTITY",
"IMMEDIATE", "INCLUDING", "INCREMENT", "INDEXES", "INHERIT", "INHERITS",
"INITIALLY", "INCLUDE", "LANGUAGE", "LARGE", "LAST", "LOGGED", "MAIN",
"MATCH", "MINVALUE", "NOTHING", "NULLS", "OBJECT", "OIDS", "ONLY", "OVER",
"OWNED", "OWNER", "PARTIAL", "PLAIN", "PRECEDING", "RANGE", "RENAME",
"REPLICA", "RESET", "RESTART", "RESTRICT", "ROUTINE", "SYNONYM", "RULE",
"SECURITY", "SEQUENCE", "SESSION", "SESSION_USER", "SHOW", "SIMPLE",
"STATISTICS", "STORAGE", "TABLESPACE", "TEMP", "TEMPORARY", "UNBOUNDED",
"UNLOGGED", "USAGE", "VALID", "VALIDATE", "WITHIN", "WITHOUT", "ZONE",
"OF", "UESCAPE", "GROUPS", "RECURSIVE", "INT", "INT2", "INT4", "INT8",
"FLOAT", "FLOAT4", "FLOAT8", "SMALLSERIAL", "SERIAL", "BIGSERIAL", "VARCHAR",
"BYTEA", "ENUM", "POINT", "LINE", "LSEG", "BOX", "PATH", "POLYGON", "CIRCLE",
"CIDR", "INET", "MACADDR", "MACADDR8", "BIT", "VARBIT", "TSVECTOR", "TSQUERY",
"XML", "JSON", "INT4RANGE", "INT8RANGE", "NUMRANGE", "TSRANGE", "TSTZRANGE",
"DATERANGE", "TABLESAMPLE", "ORDINALITY", "CURRENT_ROLE", "CURRENT_CATALOG",
"CURRENT_SCHEMA", "NORMALIZE", "OVERLAY", "XMLCONCAT", "XMLELEMENT",
"XMLEXISTS", "XMLFOREST", "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE",
"TREAT", "SETOF", "NFC", "NFD", "NFKC", "NFKD", "XMLATTRIBUTES", "REF",
"PASSING", "VERSION", "YES", "STANDALONE", "GREATEST", "LEAST", "MATERIALIZED",
"OPERATOR", "SHARE", "ROLLUP", "ILIKE", "SIMILAR", "ISNULL", "NOTNULL",
"SYMMETRIC", "DOCUMENT", "NORMALIZED", "ASYMMETRIC", "VARIADIC", "NOWAIT",
"LOCKED", "XMLTABLE", "COLUMNS", "CONTENT", "STRIP", "WHITESPACE", "XMLNAMESPACES",
"PLACING", "RETURNING", "LATERAL", "NONE", "ANALYSE", "ANALYZE", "CONFLICT",
"OVERRIDING", "SYSTEM", "ABORT", "ABSOLUTE", "ACCESS", "AFTER", "AGGREGATE",
"ALSO", "ATTACH", "ATTRIBUTE", "BACKWARD", "BEFORE", "ASSERTION", "ASSIGNMENT",
"CONTINUE", "CONVERSION", "COPY", "COST", "CSV", "CALLED", "CATALOG",
"CHAIN", "CHECKPOINT", "CLASS", "CONFIGURATION", "COMMENT", "DETACH",
"DICTIONARY", "DIRECTORY", "EXPRESSION", "INSENSITIVE", "DISCARD", "OFF",
"INSTEAD", "EXPLAIN", "INPUT", "INLINE", "PARALLEL", "LEAKPROOF", "COMMITTED",
"ENCODING", "IMPLICIT", "DELIMITER", "CURSOR", "EACH", "EVENT", "DEALLOCATE",
"CONNECTION", "DECLARE", "FAMILY", "FORWARD", "EXCLUSIVE", "FUNCTIONS",
"LOCATION", "LABEL", "DELIMITERS", "HANDLER", "HEADER", "IMMUTABLE",
"GRANTED", "HOLD", "MAPPING", "OLD", "METHOD", "LOAD", "LISTEN", "MODE",
"MOVE", "PROCEDURAL", "PARSER", "PROCEDURES", "ENCRYPTED", "PUBLICATION",
"PROGRAM", "REFERENCING", "PLANS", "REINDEX", "PRIOR", "PASSWORD", "RELATIVE",
"QUOTE", "ROUTINES", "REPLACE", "SNAPSHOT", "REFRESH", "PREPARE", "OPTIONS",
"IMPORT", "INVOKER", "NEW", "PREPARED", "SCROLL", "SEQUENCES", "SYSID",
"REASSIGN", "SERVER", "SUBSCRIPTION", "SEARCH", "SCHEMAS", "RECHECK",
"POLICY", "NOTIFY", "LOCK", "RELEASE", "SERIALIZABLE", "RETURNS", "STATEMENT",
"STDIN", "STDOUT", "TABLES", "SUPPORT", "STABLE", "TEMPLATE", "UNENCRYPTED",
"VIEWS", "UNCOMMITTED", "TRANSFORM", "UNLISTEN", "TRUSTED", "VALIDATOR",
"UNTIL", "VACUUM", "VOLATILE", "STORED", "WRITE", "STRICT", "TYPES",
"WRAPPER", "WORK", "FREEZE", "AUTHORIZATION", "VERBOSE", "PERFORMANCE",
"PARAM", "OUT", "INOUT", "DUPLICATE", "IDENTIFIER_", "STRING_", "NUMBER_",
"HEX_DIGIT_", "BIT_NUM_", "FILESIZE_LITERAL"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "OpenGaussStatement.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public OpenGaussStatementParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ExecuteContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(OpenGaussStatementParser.EOF, 0); }
public SelectContext select() {
return getRuleContext(SelectContext.class,0);
}
public InsertContext insert() {
return getRuleContext(InsertContext.class,0);
}
public UpdateContext update() {
return getRuleContext(UpdateContext.class,0);
}
public DeleteContext delete() {
return getRuleContext(DeleteContext.class,0);
}
public CreateIndexContext createIndex() {
return getRuleContext(CreateIndexContext.class,0);
}
public AlterIndexContext alterIndex() {
return getRuleContext(AlterIndexContext.class,0);
}
public DropIndexContext dropIndex() {
return getRuleContext(DropIndexContext.class,0);
}
public CreateTableContext createTable() {
return getRuleContext(CreateTableContext.class,0);
}
public AlterTableContext alterTable() {
return getRuleContext(AlterTableContext.class,0);
}
public DropTableContext dropTable() {
return getRuleContext(DropTableContext.class,0);
}
public TruncateTableContext truncateTable() {
return getRuleContext(TruncateTableContext.class,0);
}
public SetTransactionContext setTransaction() {
return getRuleContext(SetTransactionContext.class,0);
}
public BeginTransactionContext beginTransaction() {
return getRuleContext(BeginTransactionContext.class,0);
}
public StartTransactionContext startTransaction() {
return getRuleContext(StartTransactionContext.class,0);
}
public EndContext end() {
return getRuleContext(EndContext.class,0);
}
public CommitContext commit() {
return getRuleContext(CommitContext.class,0);
}
public CommitPreparedContext commitPrepared() {
return getRuleContext(CommitPreparedContext.class,0);
}
public RollbackContext rollback() {
return getRuleContext(RollbackContext.class,0);
}
public RollbackPreparedContext rollbackPrepared() {
return getRuleContext(RollbackPreparedContext.class,0);
}
public AbortContext abort() {
return getRuleContext(AbortContext.class,0);
}
public SavepointContext savepoint() {
return getRuleContext(SavepointContext.class,0);
}
public ReleaseSavepointContext releaseSavepoint() {
return getRuleContext(ReleaseSavepointContext.class,0);
}
public RollbackToSavepointContext rollbackToSavepoint() {
return getRuleContext(RollbackToSavepointContext.class,0);
}
public GrantContext grant() {
return getRuleContext(GrantContext.class,0);
}
public RevokeContext revoke() {
return getRuleContext(RevokeContext.class,0);
}
public CreateUserContext createUser() {
return getRuleContext(CreateUserContext.class,0);
}
public DropUserContext dropUser() {
return getRuleContext(DropUserContext.class,0);
}
public AlterUserContext alterUser() {
return getRuleContext(AlterUserContext.class,0);
}
public CreateRoleContext createRole() {
return getRuleContext(CreateRoleContext.class,0);
}
public DropRoleContext dropRole() {
return getRuleContext(DropRoleContext.class,0);
}
public AlterRoleContext alterRole() {
return getRuleContext(AlterRoleContext.class,0);
}
public ShowContext show() {
return getRuleContext(ShowContext.class,0);
}
public SetContext set() {
return getRuleContext(SetContext.class,0);
}
public ResetParameterContext resetParameter() {
return getRuleContext(ResetParameterContext.class,0);
}
public CallContext call() {
return getRuleContext(CallContext.class,0);
}
public AlterAggregateContext alterAggregate() {
return getRuleContext(AlterAggregateContext.class,0);
}
public AlterFunctionContext alterFunction() {
return getRuleContext(AlterFunctionContext.class,0);
}
public AlterDatabaseContext alterDatabase() {
return getRuleContext(AlterDatabaseContext.class,0);
}
public AlterDomainContext alterDomain() {
return getRuleContext(AlterDomainContext.class,0);
}
public AlterDefaultPrivilegesContext alterDefaultPrivileges() {
return getRuleContext(AlterDefaultPrivilegesContext.class,0);
}
public AlterForeignTableContext alterForeignTable() {
return getRuleContext(AlterForeignTableContext.class,0);
}
public AlterGroupContext alterGroup() {
return getRuleContext(AlterGroupContext.class,0);
}
public AlterMaterializedViewContext alterMaterializedView() {
return getRuleContext(AlterMaterializedViewContext.class,0);
}
public AlterProcedureContext alterProcedure() {
return getRuleContext(AlterProcedureContext.class,0);
}
public AlterServerContext alterServer() {
return getRuleContext(AlterServerContext.class,0);
}
public AlterSequenceContext alterSequence() {
return getRuleContext(AlterSequenceContext.class,0);
}
public AlterViewContext alterView() {
return getRuleContext(AlterViewContext.class,0);
}
public CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public CreateDatabaseContext createDatabase() {
return getRuleContext(CreateDatabaseContext.class,0);
}
public CreateFunctionContext createFunction() {
return getRuleContext(CreateFunctionContext.class,0);
}
public CreateProcedureContext createProcedure() {
return getRuleContext(CreateProcedureContext.class,0);
}
public CreateServerContext createServer() {
return getRuleContext(CreateServerContext.class,0);
}
public CreateTriggerContext createTrigger() {
return getRuleContext(CreateTriggerContext.class,0);
}
public CreateViewContext createView() {
return getRuleContext(CreateViewContext.class,0);
}
public CreateSequenceContext createSequence() {
return getRuleContext(CreateSequenceContext.class,0);
}
public CreateDomainContext createDomain() {
return getRuleContext(CreateDomainContext.class,0);
}
public CreateRuleContext createRule() {
return getRuleContext(CreateRuleContext.class,0);
}
public CreateSchemaContext createSchema() {
return getRuleContext(CreateSchemaContext.class,0);
}
public AlterSchemaContext alterSchema() {
return getRuleContext(AlterSchemaContext.class,0);
}
public DropSchemaContext dropSchema() {
return getRuleContext(DropSchemaContext.class,0);
}
public CreateTypeContext createType() {
return getRuleContext(CreateTypeContext.class,0);
}
public DropTypeContext dropType() {
return getRuleContext(DropTypeContext.class,0);
}
public CreateTextSearchContext createTextSearch() {
return getRuleContext(CreateTextSearchContext.class,0);
}
public DropDatabaseContext dropDatabase() {
return getRuleContext(DropDatabaseContext.class,0);
}
public DropFunctionContext dropFunction() {
return getRuleContext(DropFunctionContext.class,0);
}
public DropProcedureContext dropProcedure() {
return getRuleContext(DropProcedureContext.class,0);
}
public DropRuleContext dropRule() {
return getRuleContext(DropRuleContext.class,0);
}
public DropServerContext dropServer() {
return getRuleContext(DropServerContext.class,0);
}
public DropTriggerContext dropTrigger() {
return getRuleContext(DropTriggerContext.class,0);
}
public DropViewContext dropView() {
return getRuleContext(DropViewContext.class,0);
}
public DropSequenceContext dropSequence() {
return getRuleContext(DropSequenceContext.class,0);
}
public DropDomainContext dropDomain() {
return getRuleContext(DropDomainContext.class,0);
}
public VacuumContext vacuum() {
return getRuleContext(VacuumContext.class,0);
}
public PrepareContext prepare() {
return getRuleContext(PrepareContext.class,0);
}
public ExecuteStmtContext executeStmt() {
return getRuleContext(ExecuteStmtContext.class,0);
}
public DeallocateContext deallocate() {
return getRuleContext(DeallocateContext.class,0);
}
public ExplainContext explain() {
return getRuleContext(ExplainContext.class,0);
}
public AnalyzeTableContext analyzeTable() {
return getRuleContext(AnalyzeTableContext.class,0);
}
public LoadContext load() {
return getRuleContext(LoadContext.class,0);
}
public CreateTablespaceContext createTablespace() {
return getRuleContext(CreateTablespaceContext.class,0);
}
public AlterTablespaceContext alterTablespace() {
return getRuleContext(AlterTablespaceContext.class,0);
}
public DropTablespaceContext dropTablespace() {
return getRuleContext(DropTablespaceContext.class,0);
}
public SetConstraintsContext setConstraints() {
return getRuleContext(SetConstraintsContext.class,0);
}
public CopyContext copy() {
return getRuleContext(CopyContext.class,0);
}
public CreateLanguageContext createLanguage() {
return getRuleContext(CreateLanguageContext.class,0);
}
public AlterLanguageContext alterLanguage() {
return getRuleContext(AlterLanguageContext.class,0);
}
public DropLanguageContext dropLanguage() {
return getRuleContext(DropLanguageContext.class,0);
}
public CreateConversionContext createConversion() {
return getRuleContext(CreateConversionContext.class,0);
}
public AlterConversionContext alterConversion() {
return getRuleContext(AlterConversionContext.class,0);
}
public DropConversionContext dropConversion() {
return getRuleContext(DropConversionContext.class,0);
}
public AlterTextSearchDictionaryContext alterTextSearchDictionary() {
return getRuleContext(AlterTextSearchDictionaryContext.class,0);
}
public AlterTextSearchTemplateContext alterTextSearchTemplate() {
return getRuleContext(AlterTextSearchTemplateContext.class,0);
}
public AlterTextSearchParserContext alterTextSearchParser() {
return getRuleContext(AlterTextSearchParserContext.class,0);
}
public CreateExtensionContext createExtension() {
return getRuleContext(CreateExtensionContext.class,0);
}
public AlterExtensionContext alterExtension() {
return getRuleContext(AlterExtensionContext.class,0);
}
public DropExtensionContext dropExtension() {
return getRuleContext(DropExtensionContext.class,0);
}
public DropTextSearchContext dropTextSearch() {
return getRuleContext(DropTextSearchContext.class,0);
}
public CreateSynonymContext createSynonym() {
return getRuleContext(CreateSynonymContext.class,0);
}
public AlterSynonymContext alterSynonym() {
return getRuleContext(AlterSynonymContext.class,0);
}
public DropSynonymContext dropSynonym() {
return getRuleContext(DropSynonymContext.class,0);
}
public DeclareContext declare() {
return getRuleContext(DeclareContext.class,0);
}
public CursorContext cursor() {
return getRuleContext(CursorContext.class,0);
}
public CloseContext close() {
return getRuleContext(CloseContext.class,0);
}
public MoveContext move() {
return getRuleContext(MoveContext.class,0);
}
public FetchContext fetch() {
return getRuleContext(FetchContext.class,0);
}
public CreateDirectoryContext createDirectory() {
return getRuleContext(CreateDirectoryContext.class,0);
}
public AlterDirectoryContext alterDirectory() {
return getRuleContext(AlterDirectoryContext.class,0);
}
public DropDirectoryContext dropDirectory() {
return getRuleContext(DropDirectoryContext.class,0);
}
public CreateCastContext createCast() {
return getRuleContext(CreateCastContext.class,0);
}
public DropCastContext dropCast() {
return getRuleContext(DropCastContext.class,0);
}
public AlterRuleContext alterRule() {
return getRuleContext(AlterRuleContext.class,0);
}
public CheckpointContext checkpoint() {
return getRuleContext(CheckpointContext.class,0);
}
public AlterTypeContext alterType() {
return getRuleContext(AlterTypeContext.class,0);
}
public CreatePublicationContext createPublication() {
return getRuleContext(CreatePublicationContext.class,0);
}
public DropPublicationContext dropPublication() {
return getRuleContext(DropPublicationContext.class,0);
}
public CreateAggregateContext createAggregate() {
return getRuleContext(CreateAggregateContext.class,0);
}
public AlterPackageContext alterPackage() {
return getRuleContext(AlterPackageContext.class,0);
}
public EmptyStatementContext emptyStatement() {
return getRuleContext(EmptyStatementContext.class,0);
}
public TerminalNode SEMI_() { return getToken(OpenGaussStatementParser.SEMI_, 0); }
public ExecuteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_execute; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitExecute(this);
else return visitor.visitChildren(this);
}
}
public final ExecuteContext execute() throws RecognitionException {
ExecuteContext _localctx = new ExecuteContext(_ctx, getState());
enterRule(_localctx, 0, RULE_execute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1642);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(1524);
select();
}
break;
case 2:
{
setState(1525);
insert();
}
break;
case 3:
{
setState(1526);
update();
}
break;
case 4:
{
setState(1527);
delete();
}
break;
case 5:
{
setState(1528);
createIndex();
}
break;
case 6:
{
setState(1529);
alterIndex();
}
break;
case 7:
{
setState(1530);
dropIndex();
}
break;
case 8:
{
setState(1531);
createTable();
}
break;
case 9:
{
setState(1532);
alterTable();
}
break;
case 10:
{
setState(1533);
dropTable();
}
break;
case 11:
{
setState(1534);
truncateTable();
}
break;
case 12:
{
setState(1535);
setTransaction();
}
break;
case 13:
{
setState(1536);
beginTransaction();
}
break;
case 14:
{
setState(1537);
startTransaction();
}
break;
case 15:
{
setState(1538);
end();
}
break;
case 16:
{
setState(1539);
commit();
}
break;
case 17:
{
setState(1540);
commitPrepared();
}
break;
case 18:
{
setState(1541);
rollback();
}
break;
case 19:
{
setState(1542);
rollbackPrepared();
}
break;
case 20:
{
setState(1543);
abort();
}
break;
case 21:
{
setState(1544);
savepoint();
}
break;
case 22:
{
setState(1545);
releaseSavepoint();
}
break;
case 23:
{
setState(1546);
rollbackToSavepoint();
}
break;
case 24:
{
setState(1547);
grant();
}
break;
case 25:
{
setState(1548);
revoke();
}
break;
case 26:
{
setState(1549);
createUser();
}
break;
case 27:
{
setState(1550);
dropUser();
}
break;
case 28:
{
setState(1551);
alterUser();
}
break;
case 29:
{
setState(1552);
createRole();
}
break;
case 30:
{
setState(1553);
dropRole();
}
break;
case 31:
{
setState(1554);
alterRole();
}
break;
case 32:
{
setState(1555);
show();
}
break;
case 33:
{
setState(1556);
set();
}
break;
case 34:
{
setState(1557);
resetParameter();
}
break;
case 35:
{
setState(1558);
call();
}
break;
case 36:
{
setState(1559);
alterAggregate();
}
break;
case 37:
{
setState(1560);
alterFunction();
}
break;
case 38:
{
setState(1561);
alterDatabase();
}
break;
case 39:
{
setState(1562);
alterDomain();
}
break;
case 40:
{
setState(1563);
alterDefaultPrivileges();
}
break;
case 41:
{
setState(1564);
alterForeignTable();
}
break;
case 42:
{
setState(1565);
alterGroup();
}
break;
case 43:
{
setState(1566);
alterMaterializedView();
}
break;
case 44:
{
setState(1567);
alterProcedure();
}
break;
case 45:
{
setState(1568);
alterServer();
}
break;
case 46:
{
setState(1569);
alterSequence();
}
break;
case 47:
{
setState(1570);
alterView();
}
break;
case 48:
{
setState(1571);
comment();
}
break;
case 49:
{
setState(1572);
createDatabase();
}
break;
case 50:
{
setState(1573);
createFunction();
}
break;
case 51:
{
setState(1574);
createProcedure();
}
break;
case 52:
{
setState(1575);
createServer();
}
break;
case 53:
{
setState(1576);
createTrigger();
}
break;
case 54:
{
setState(1577);
createView();
}
break;
case 55:
{
setState(1578);
createSequence();
}
break;
case 56:
{
setState(1579);
createDomain();
}
break;
case 57:
{
setState(1580);
createRule();
}
break;
case 58:
{
setState(1581);
createSchema();
}
break;
case 59:
{
setState(1582);
alterSchema();
}
break;
case 60:
{
setState(1583);
dropSchema();
}
break;
case 61:
{
setState(1584);
createType();
}
break;
case 62:
{
setState(1585);
dropType();
}
break;
case 63:
{
setState(1586);
createTextSearch();
}
break;
case 64:
{
setState(1587);
dropDatabase();
}
break;
case 65:
{
setState(1588);
dropFunction();
}
break;
case 66:
{
setState(1589);
dropProcedure();
}
break;
case 67:
{
setState(1590);
dropRule();
}
break;
case 68:
{
setState(1591);
dropServer();
}
break;
case 69:
{
setState(1592);
dropTrigger();
}
break;
case 70:
{
setState(1593);
dropView();
}
break;
case 71:
{
setState(1594);
dropSequence();
}
break;
case 72:
{
setState(1595);
dropDomain();
}
break;
case 73:
{
setState(1596);
vacuum();
}
break;
case 74:
{
setState(1597);
prepare();
}
break;
case 75:
{
setState(1598);
executeStmt();
}
break;
case 76:
{
setState(1599);
deallocate();
}
break;
case 77:
{
setState(1600);
explain();
}
break;
case 78:
{
setState(1601);
analyzeTable();
}
break;
case 79:
{
setState(1602);
load();
}
break;
case 80:
{
setState(1603);
createTablespace();
}
break;
case 81:
{
setState(1604);
alterTablespace();
}
break;
case 82:
{
setState(1605);
dropTablespace();
}
break;
case 83:
{
setState(1606);
setConstraints();
}
break;
case 84:
{
setState(1607);
copy();
}
break;
case 85:
{
setState(1608);
createLanguage();
}
break;
case 86:
{
setState(1609);
alterLanguage();
}
break;
case 87:
{
setState(1610);
dropLanguage();
}
break;
case 88:
{
setState(1611);
createConversion();
}
break;
case 89:
{
setState(1612);
alterConversion();
}
break;
case 90:
{
setState(1613);
dropConversion();
}
break;
case 91:
{
setState(1614);
alterTextSearchDictionary();
}
break;
case 92:
{
setState(1615);
alterTextSearchTemplate();
}
break;
case 93:
{
setState(1616);
alterTextSearchParser();
}
break;
case 94:
{
setState(1617);
createExtension();
}
break;
case 95:
{
setState(1618);
alterExtension();
}
break;
case 96:
{
setState(1619);
dropExtension();
}
break;
case 97:
{
setState(1620);
dropTextSearch();
}
break;
case 98:
{
setState(1621);
createSynonym();
}
break;
case 99:
{
setState(1622);
alterSynonym();
}
break;
case 100:
{
setState(1623);
dropSynonym();
}
break;
case 101:
{
setState(1624);
declare();
}
break;
case 102:
{
setState(1625);
cursor();
}
break;
case 103:
{
setState(1626);
close();
}
break;
case 104:
{
setState(1627);
move();
}
break;
case 105:
{
setState(1628);
fetch();
}
break;
case 106:
{
setState(1629);
createDirectory();
}
break;
case 107:
{
setState(1630);
alterDirectory();
}
break;
case 108:
{
setState(1631);
dropDirectory();
}
break;
case 109:
{
setState(1632);
createCast();
}
break;
case 110:
{
setState(1633);
dropCast();
}
break;
case 111:
{
setState(1634);
alterRule();
}
break;
case 112:
{
setState(1635);
checkpoint();
}
break;
case 113:
{
setState(1636);
alterType();
}
break;
case 114:
{
setState(1637);
createPublication();
}
break;
case 115:
{
setState(1638);
dropPublication();
}
break;
case 116:
{
setState(1639);
createAggregate();
}
break;
case 117:
{
setState(1640);
alterPackage();
}
break;
case 118:
{
setState(1641);
emptyStatement();
}
break;
}
setState(1645);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI_) {
{
setState(1644);
match(SEMI_);
}
}
setState(1647);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetTransactionContext extends ParserRuleContext {
public TerminalNode SET() { return getToken(OpenGaussStatementParser.SET, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TransactionModeListContext transactionModeList() {
return getRuleContext(TransactionModeListContext.class,0);
}
public TerminalNode SESSION() { return getToken(OpenGaussStatementParser.SESSION, 0); }
public TerminalNode CHARACTERISTICS() { return getToken(OpenGaussStatementParser.CHARACTERISTICS, 0); }
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public TerminalNode SNAPSHOT() { return getToken(OpenGaussStatementParser.SNAPSHOT, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public SetTransactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setTransaction; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSetTransaction(this);
else return visitor.visitChildren(this);
}
}
public final SetTransactionContext setTransaction() throws RecognitionException {
SetTransactionContext _localctx = new SetTransactionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_setTransaction);
int _la;
try {
setState(1661);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1649);
match(SET);
setState(1653);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SESSION) {
{
setState(1650);
match(SESSION);
setState(1651);
match(CHARACTERISTICS);
setState(1652);
match(AS);
}
}
setState(1655);
match(TRANSACTION);
setState(1656);
transactionModeList();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1657);
match(SET);
setState(1658);
match(TRANSACTION);
setState(1659);
match(SNAPSHOT);
setState(1660);
match(STRING_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BeginTransactionContext extends ParserRuleContext {
public TerminalNode BEGIN() { return getToken(OpenGaussStatementParser.BEGIN, 0); }
public TransactionModeListContext transactionModeList() {
return getRuleContext(TransactionModeListContext.class,0);
}
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public BeginTransactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_beginTransaction; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitBeginTransaction(this);
else return visitor.visitChildren(this);
}
}
public final BeginTransactionContext beginTransaction() throws RecognitionException {
BeginTransactionContext _localctx = new BeginTransactionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_beginTransaction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1663);
match(BEGIN);
setState(1665);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1664);
_la = _input.LA(1);
if ( !(_la==TRANSACTION || _la==WORK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1668);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT || ((((_la - 249)) & ~0x3f) == 0 && ((1L << (_la - 249)) & ((1L << (ISOLATION - 249)) | (1L << (READ - 249)) | (1L << (DEFERRABLE - 249)))) != 0)) {
{
setState(1667);
transactionModeList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommitContext extends ParserRuleContext {
public TerminalNode COMMIT() { return getToken(OpenGaussStatementParser.COMMIT, 0); }
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode CHAIN() { return getToken(OpenGaussStatementParser.CHAIN, 0); }
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public CommitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commit; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCommit(this);
else return visitor.visitChildren(this);
}
}
public final CommitContext commit() throws RecognitionException {
CommitContext _localctx = new CommitContext(_ctx, getState());
enterRule(_localctx, 6, RULE_commit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1670);
match(COMMIT);
setState(1672);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1671);
_la = _input.LA(1);
if ( !(_la==TRANSACTION || _la==WORK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1679);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1674);
match(AND);
setState(1676);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1675);
match(NO);
}
}
setState(1678);
match(CHAIN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SavepointContext extends ParserRuleContext {
public TerminalNode SAVEPOINT() { return getToken(OpenGaussStatementParser.SAVEPOINT, 0); }
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public SavepointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_savepoint; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSavepoint(this);
else return visitor.visitChildren(this);
}
}
public final SavepointContext savepoint() throws RecognitionException {
SavepointContext _localctx = new SavepointContext(_ctx, getState());
enterRule(_localctx, 8, RULE_savepoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1681);
match(SAVEPOINT);
setState(1682);
colId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AbortContext extends ParserRuleContext {
public TerminalNode ABORT() { return getToken(OpenGaussStatementParser.ABORT, 0); }
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode CHAIN() { return getToken(OpenGaussStatementParser.CHAIN, 0); }
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public AbortContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abort; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitAbort(this);
else return visitor.visitChildren(this);
}
}
public final AbortContext abort() throws RecognitionException {
AbortContext _localctx = new AbortContext(_ctx, getState());
enterRule(_localctx, 10, RULE_abort);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1684);
match(ABORT);
setState(1686);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1685);
_la = _input.LA(1);
if ( !(_la==TRANSACTION || _la==WORK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1693);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1688);
match(AND);
setState(1690);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1689);
match(NO);
}
}
setState(1692);
match(CHAIN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StartTransactionContext extends ParserRuleContext {
public TerminalNode START() { return getToken(OpenGaussStatementParser.START, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TransactionModeListContext transactionModeList() {
return getRuleContext(TransactionModeListContext.class,0);
}
public StartTransactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startTransaction; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitStartTransaction(this);
else return visitor.visitChildren(this);
}
}
public final StartTransactionContext startTransaction() throws RecognitionException {
StartTransactionContext _localctx = new StartTransactionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_startTransaction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1695);
match(START);
setState(1696);
match(TRANSACTION);
setState(1698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT || ((((_la - 249)) & ~0x3f) == 0 && ((1L << (_la - 249)) & ((1L << (ISOLATION - 249)) | (1L << (READ - 249)) | (1L << (DEFERRABLE - 249)))) != 0)) {
{
setState(1697);
transactionModeList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EndContext extends ParserRuleContext {
public TerminalNode END() { return getToken(OpenGaussStatementParser.END, 0); }
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode CHAIN() { return getToken(OpenGaussStatementParser.CHAIN, 0); }
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public EndContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_end; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitEnd(this);
else return visitor.visitChildren(this);
}
}
public final EndContext end() throws RecognitionException {
EndContext _localctx = new EndContext(_ctx, getState());
enterRule(_localctx, 14, RULE_end);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1700);
match(END);
setState(1702);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1701);
_la = _input.LA(1);
if ( !(_la==TRANSACTION || _la==WORK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1709);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1704);
match(AND);
setState(1706);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1705);
match(NO);
}
}
setState(1708);
match(CHAIN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RollbackContext extends ParserRuleContext {
public TerminalNode ROLLBACK() { return getToken(OpenGaussStatementParser.ROLLBACK, 0); }
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode CHAIN() { return getToken(OpenGaussStatementParser.CHAIN, 0); }
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public RollbackContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollback; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRollback(this);
else return visitor.visitChildren(this);
}
}
public final RollbackContext rollback() throws RecognitionException {
RollbackContext _localctx = new RollbackContext(_ctx, getState());
enterRule(_localctx, 16, RULE_rollback);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1711);
match(ROLLBACK);
setState(1713);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1712);
_la = _input.LA(1);
if ( !(_la==TRANSACTION || _la==WORK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1720);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1715);
match(AND);
setState(1717);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NO) {
{
setState(1716);
match(NO);
}
}
setState(1719);
match(CHAIN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReleaseSavepointContext extends ParserRuleContext {
public TerminalNode RELEASE() { return getToken(OpenGaussStatementParser.RELEASE, 0); }
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public TerminalNode SAVEPOINT() { return getToken(OpenGaussStatementParser.SAVEPOINT, 0); }
public ReleaseSavepointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_releaseSavepoint; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitReleaseSavepoint(this);
else return visitor.visitChildren(this);
}
}
public final ReleaseSavepointContext releaseSavepoint() throws RecognitionException {
ReleaseSavepointContext _localctx = new ReleaseSavepointContext(_ctx, getState());
enterRule(_localctx, 18, RULE_releaseSavepoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1722);
match(RELEASE);
setState(1724);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(1723);
match(SAVEPOINT);
}
break;
}
setState(1726);
colId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RollbackToSavepointContext extends ParserRuleContext {
public TerminalNode ROLLBACK() { return getToken(OpenGaussStatementParser.ROLLBACK, 0); }
public TerminalNode TO() { return getToken(OpenGaussStatementParser.TO, 0); }
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public TerminalNode SAVEPOINT() { return getToken(OpenGaussStatementParser.SAVEPOINT, 0); }
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public RollbackToSavepointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollbackToSavepoint; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRollbackToSavepoint(this);
else return visitor.visitChildren(this);
}
}
public final RollbackToSavepointContext rollbackToSavepoint() throws RecognitionException {
RollbackToSavepointContext _localctx = new RollbackToSavepointContext(_ctx, getState());
enterRule(_localctx, 20, RULE_rollbackToSavepoint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1728);
match(ROLLBACK);
setState(1730);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TRANSACTION || _la==WORK) {
{
setState(1729);
_la = _input.LA(1);
if ( !(_la==TRANSACTION || _la==WORK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1732);
match(TO);
setState(1734);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(1733);
match(SAVEPOINT);
}
break;
}
setState(1736);
colId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrepareTransactionContext extends ParserRuleContext {
public TerminalNode PREPARE() { return getToken(OpenGaussStatementParser.PREPARE, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public PrepareTransactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prepareTransaction; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitPrepareTransaction(this);
else return visitor.visitChildren(this);
}
}
public final PrepareTransactionContext prepareTransaction() throws RecognitionException {
PrepareTransactionContext _localctx = new PrepareTransactionContext(_ctx, getState());
enterRule(_localctx, 22, RULE_prepareTransaction);
try {
enterOuterAlt(_localctx, 1);
{
setState(1738);
match(PREPARE);
setState(1739);
match(TRANSACTION);
setState(1740);
match(STRING_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommitPreparedContext extends ParserRuleContext {
public TerminalNode COMMIT() { return getToken(OpenGaussStatementParser.COMMIT, 0); }
public TerminalNode PREPARED() { return getToken(OpenGaussStatementParser.PREPARED, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public CommitPreparedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commitPrepared; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCommitPrepared(this);
else return visitor.visitChildren(this);
}
}
public final CommitPreparedContext commitPrepared() throws RecognitionException {
CommitPreparedContext _localctx = new CommitPreparedContext(_ctx, getState());
enterRule(_localctx, 24, RULE_commitPrepared);
try {
enterOuterAlt(_localctx, 1);
{
setState(1742);
match(COMMIT);
setState(1743);
match(PREPARED);
setState(1744);
match(STRING_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RollbackPreparedContext extends ParserRuleContext {
public TerminalNode ROLLBACK() { return getToken(OpenGaussStatementParser.ROLLBACK, 0); }
public TerminalNode PREPARED() { return getToken(OpenGaussStatementParser.PREPARED, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public RollbackPreparedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollbackPrepared; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRollbackPrepared(this);
else return visitor.visitChildren(this);
}
}
public final RollbackPreparedContext rollbackPrepared() throws RecognitionException {
RollbackPreparedContext _localctx = new RollbackPreparedContext(_ctx, getState());
enterRule(_localctx, 26, RULE_rollbackPrepared);
try {
enterOuterAlt(_localctx, 1);
{
setState(1746);
match(ROLLBACK);
setState(1747);
match(PREPARED);
setState(1748);
match(STRING_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetConstraintsContext extends ParserRuleContext {
public TerminalNode SET() { return getToken(OpenGaussStatementParser.SET, 0); }
public TerminalNode CONSTRAINTS() { return getToken(OpenGaussStatementParser.CONSTRAINTS, 0); }
public ConstraintsSetListContext constraintsSetList() {
return getRuleContext(ConstraintsSetListContext.class,0);
}
public ConstraintsSetModeContext constraintsSetMode() {
return getRuleContext(ConstraintsSetModeContext.class,0);
}
public SetConstraintsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setConstraints; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSetConstraints(this);
else return visitor.visitChildren(this);
}
}
public final SetConstraintsContext setConstraints() throws RecognitionException {
SetConstraintsContext _localctx = new SetConstraintsContext(_ctx, getState());
enterRule(_localctx, 28, RULE_setConstraints);
try {
enterOuterAlt(_localctx, 1);
{
setState(1750);
match(SET);
setState(1751);
match(CONSTRAINTS);
setState(1752);
constraintsSetList();
setState(1753);
constraintsSetMode();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintsSetModeContext extends ParserRuleContext {
public TerminalNode DEFERRED() { return getToken(OpenGaussStatementParser.DEFERRED, 0); }
public TerminalNode IMMEDIATE() { return getToken(OpenGaussStatementParser.IMMEDIATE, 0); }
public ConstraintsSetModeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraintsSetMode; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitConstraintsSetMode(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintsSetModeContext constraintsSetMode() throws RecognitionException {
ConstraintsSetModeContext _localctx = new ConstraintsSetModeContext(_ctx, getState());
enterRule(_localctx, 30, RULE_constraintsSetMode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1755);
_la = _input.LA(1);
if ( !(_la==DEFERRED || _la==IMMEDIATE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintsSetListContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(OpenGaussStatementParser.ALL, 0); }
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public ConstraintsSetListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraintsSetList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitConstraintsSetList(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintsSetListContext constraintsSetList() throws RecognitionException {
ConstraintsSetListContext _localctx = new ConstraintsSetListContext(_ctx, getState());
enterRule(_localctx, 32, RULE_constraintsSetList);
try {
setState(1759);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ALL:
enterOuterAlt(_localctx, 1);
{
setState(1757);
match(ALL);
}
break;
case UNICODE_ESCAPE:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case IF:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case DOUBLE:
case INTERVAL:
case TIME:
case TIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case NAMES:
case TYPE:
case TEXT:
case REPEATABLE:
case VARYING:
case NATIONAL:
case VALUE:
case TIES:
case CUBE:
case SETS:
case OTHERS:
case AT:
case MAXVALUE:
case ADMIN:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case XML:
case JSON:
case ORDINALITY:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case IDENTIFIER_:
enterOuterAlt(_localctx, 2);
{
setState(1758);
qualifiedNameList(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(OpenGaussStatementParser.INSERT, 0); }
public TerminalNode INTO() { return getToken(OpenGaussStatementParser.INTO, 0); }
public InsertTargetContext insertTarget() {
return getRuleContext(InsertTargetContext.class,0);
}
public InsertRestContext insertRest() {
return getRuleContext(InsertRestContext.class,0);
}
public WithClauseContext withClause() {
return getRuleContext(WithClauseContext.class,0);
}
public OptOnDuplicateKeyContext optOnDuplicateKey() {
return getRuleContext(OptOnDuplicateKeyContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public InsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insert; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInsert(this);
else return visitor.visitChildren(this);
}
}
public final InsertContext insert() throws RecognitionException {
InsertContext _localctx = new InsertContext(_ctx, getState());
enterRule(_localctx, 34, RULE_insert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1762);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1761);
withClause();
}
}
setState(1764);
match(INSERT);
setState(1765);
match(INTO);
setState(1766);
insertTarget();
setState(1767);
insertRest();
setState(1769);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1768);
optOnDuplicateKey();
}
}
setState(1772);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1771);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertTargetContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public InsertTargetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertTarget; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInsertTarget(this);
else return visitor.visitChildren(this);
}
}
public final InsertTargetContext insertTarget() throws RecognitionException {
InsertTargetContext _localctx = new InsertTargetContext(_ctx, getState());
enterRule(_localctx, 36, RULE_insertTarget);
try {
setState(1779);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1774);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1775);
qualifiedName();
setState(1776);
match(AS);
setState(1777);
colId();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertRestContext extends ParserRuleContext {
public SelectContext select() {
return getRuleContext(SelectContext.class,0);
}
public TerminalNode OVERRIDING() { return getToken(OpenGaussStatementParser.OVERRIDING, 0); }
public OverrideKindContext overrideKind() {
return getRuleContext(OverrideKindContext.class,0);
}
public TerminalNode VALUE() { return getToken(OpenGaussStatementParser.VALUE, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public InsertColumnListContext insertColumnList() {
return getRuleContext(InsertColumnListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TerminalNode DEFAULT() { return getToken(OpenGaussStatementParser.DEFAULT, 0); }
public TerminalNode VALUES() { return getToken(OpenGaussStatementParser.VALUES, 0); }
public InsertRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertRest; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInsertRest(this);
else return visitor.visitChildren(this);
}
}
public final InsertRestContext insertRest() throws RecognitionException {
InsertRestContext _localctx = new InsertRestContext(_ctx, getState());
enterRule(_localctx, 38, RULE_insertRest);
try {
setState(1802);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1781);
select();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1782);
match(OVERRIDING);
setState(1783);
overrideKind();
setState(1784);
match(VALUE);
setState(1785);
select();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1787);
match(LP_);
setState(1788);
insertColumnList(0);
setState(1789);
match(RP_);
setState(1790);
select();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1792);
match(LP_);
setState(1793);
insertColumnList(0);
setState(1794);
match(RP_);
setState(1795);
match(OVERRIDING);
setState(1796);
overrideKind();
setState(1797);
match(VALUE);
setState(1798);
select();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1800);
match(DEFAULT);
setState(1801);
match(VALUES);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OverrideKindContext extends ParserRuleContext {
public TerminalNode USER() { return getToken(OpenGaussStatementParser.USER, 0); }
public TerminalNode SYSTEM() { return getToken(OpenGaussStatementParser.SYSTEM, 0); }
public OverrideKindContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_overrideKind; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOverrideKind(this);
else return visitor.visitChildren(this);
}
}
public final OverrideKindContext overrideKind() throws RecognitionException {
OverrideKindContext _localctx = new OverrideKindContext(_ctx, getState());
enterRule(_localctx, 40, RULE_overrideKind);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1804);
_la = _input.LA(1);
if ( !(_la==USER || _la==SYSTEM) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertColumnListContext extends ParserRuleContext {
public InsertColumnItemContext insertColumnItem() {
return getRuleContext(InsertColumnItemContext.class,0);
}
public InsertColumnListContext insertColumnList() {
return getRuleContext(InsertColumnListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public InsertColumnListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertColumnList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInsertColumnList(this);
else return visitor.visitChildren(this);
}
}
public final InsertColumnListContext insertColumnList() throws RecognitionException {
return insertColumnList(0);
}
private InsertColumnListContext insertColumnList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
InsertColumnListContext _localctx = new InsertColumnListContext(_ctx, _parentState);
InsertColumnListContext _prevctx = _localctx;
int _startState = 42;
enterRecursionRule(_localctx, 42, RULE_insertColumnList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1807);
insertColumnItem();
}
_ctx.stop = _input.LT(-1);
setState(1814);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new InsertColumnListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_insertColumnList);
setState(1809);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1810);
match(COMMA_);
setState(1811);
insertColumnItem();
}
}
}
setState(1816);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class InsertColumnItemContext extends ParserRuleContext {
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public OptIndirectionContext optIndirection() {
return getRuleContext(OptIndirectionContext.class,0);
}
public InsertColumnItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertColumnItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInsertColumnItem(this);
else return visitor.visitChildren(this);
}
}
public final InsertColumnItemContext insertColumnItem() throws RecognitionException {
InsertColumnItemContext _localctx = new InsertColumnItemContext(_ctx, getState());
enterRule(_localctx, 44, RULE_insertColumnItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1817);
colId();
setState(1818);
optIndirection(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptOnDuplicateKeyContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(OpenGaussStatementParser.ON, 0); }
public TerminalNode DUPLICATE() { return getToken(OpenGaussStatementParser.DUPLICATE, 0); }
public TerminalNode KEY() { return getToken(OpenGaussStatementParser.KEY, 0); }
public TerminalNode UPDATE() { return getToken(OpenGaussStatementParser.UPDATE, 0); }
public List assignment() {
return getRuleContexts(AssignmentContext.class);
}
public AssignmentContext assignment(int i) {
return getRuleContext(AssignmentContext.class,i);
}
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public TerminalNode NOTHING() { return getToken(OpenGaussStatementParser.NOTHING, 0); }
public OptOnDuplicateKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optOnDuplicateKey; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOptOnDuplicateKey(this);
else return visitor.visitChildren(this);
}
}
public final OptOnDuplicateKeyContext optOnDuplicateKey() throws RecognitionException {
OptOnDuplicateKeyContext _localctx = new OptOnDuplicateKeyContext(_ctx, getState());
enterRule(_localctx, 46, RULE_optOnDuplicateKey);
int _la;
try {
setState(1837);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1820);
match(ON);
setState(1821);
match(DUPLICATE);
setState(1822);
match(KEY);
setState(1823);
match(UPDATE);
setState(1824);
assignment();
setState(1829);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(1825);
match(COMMA_);
setState(1826);
assignment();
}
}
setState(1831);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1832);
match(ON);
setState(1833);
match(DUPLICATE);
setState(1834);
match(KEY);
setState(1835);
match(UPDATE);
setState(1836);
match(NOTHING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentContext extends ParserRuleContext {
public SetTargetContext setTarget() {
return getRuleContext(SetTargetContext.class,0);
}
public TerminalNode EQ_() { return getToken(OpenGaussStatementParser.EQ_, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public TerminalNode VALUES() { return getToken(OpenGaussStatementParser.VALUES, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public AssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitAssignment(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentContext assignment() throws RecognitionException {
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
enterRule(_localctx, 48, RULE_assignment);
try {
setState(1850);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1839);
setTarget();
setState(1840);
match(EQ_);
setState(1841);
aExpr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1843);
setTarget();
setState(1844);
match(EQ_);
setState(1845);
match(VALUES);
setState(1846);
match(LP_);
setState(1847);
name();
setState(1848);
match(RP_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateContext extends ParserRuleContext {
public TerminalNode UPDATE() { return getToken(OpenGaussStatementParser.UPDATE, 0); }
public RelationExprOptAliasContext relationExprOptAlias() {
return getRuleContext(RelationExprOptAliasContext.class,0);
}
public TerminalNode SET() { return getToken(OpenGaussStatementParser.SET, 0); }
public SetClauseListContext setClauseList() {
return getRuleContext(SetClauseListContext.class,0);
}
public WithClauseContext withClause() {
return getRuleContext(WithClauseContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public WhereOrCurrentClauseContext whereOrCurrentClause() {
return getRuleContext(WhereOrCurrentClauseContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public UpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitUpdate(this);
else return visitor.visitChildren(this);
}
}
public final UpdateContext update() throws RecognitionException {
UpdateContext _localctx = new UpdateContext(_ctx, getState());
enterRule(_localctx, 50, RULE_update);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1853);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1852);
withClause();
}
}
setState(1855);
match(UPDATE);
setState(1856);
relationExprOptAlias();
setState(1857);
match(SET);
setState(1858);
setClauseList(0);
setState(1860);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(1859);
fromClause();
}
}
setState(1863);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1862);
whereOrCurrentClause();
}
}
setState(1866);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1865);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetClauseListContext extends ParserRuleContext {
public SetClauseContext setClause() {
return getRuleContext(SetClauseContext.class,0);
}
public SetClauseListContext setClauseList() {
return getRuleContext(SetClauseListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public SetClauseListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setClauseList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSetClauseList(this);
else return visitor.visitChildren(this);
}
}
public final SetClauseListContext setClauseList() throws RecognitionException {
return setClauseList(0);
}
private SetClauseListContext setClauseList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
SetClauseListContext _localctx = new SetClauseListContext(_ctx, _parentState);
SetClauseListContext _prevctx = _localctx;
int _startState = 52;
enterRecursionRule(_localctx, 52, RULE_setClauseList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1869);
setClause();
}
_ctx.stop = _input.LT(-1);
setState(1876);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new SetClauseListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_setClauseList);
setState(1871);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1872);
match(COMMA_);
setState(1873);
setClause();
}
}
}
setState(1878);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class SetClauseContext extends ParserRuleContext {
public SetTargetContext setTarget() {
return getRuleContext(SetTargetContext.class,0);
}
public TerminalNode EQ_() { return getToken(OpenGaussStatementParser.EQ_, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public SetTargetListContext setTargetList() {
return getRuleContext(SetTargetListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public SetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSetClause(this);
else return visitor.visitChildren(this);
}
}
public final SetClauseContext setClause() throws RecognitionException {
SetClauseContext _localctx = new SetClauseContext(_ctx, getState());
enterRule(_localctx, 54, RULE_setClause);
try {
setState(1889);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNICODE_ESCAPE:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case IF:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case DOUBLE:
case INTERVAL:
case TIME:
case TIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case NAMES:
case TYPE:
case TEXT:
case REPEATABLE:
case VARYING:
case NATIONAL:
case VALUE:
case TIES:
case CUBE:
case SETS:
case OTHERS:
case AT:
case MAXVALUE:
case ADMIN:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case XML:
case JSON:
case ORDINALITY:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case IDENTIFIER_:
enterOuterAlt(_localctx, 1);
{
setState(1879);
setTarget();
setState(1880);
match(EQ_);
setState(1881);
aExpr(0);
}
break;
case LP_:
enterOuterAlt(_localctx, 2);
{
setState(1883);
match(LP_);
setState(1884);
setTargetList(0);
setState(1885);
match(RP_);
setState(1886);
match(EQ_);
setState(1887);
aExpr(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetTargetContext extends ParserRuleContext {
public List colId() {
return getRuleContexts(ColIdContext.class);
}
public ColIdContext colId(int i) {
return getRuleContext(ColIdContext.class,i);
}
public TerminalNode DOT_() { return getToken(OpenGaussStatementParser.DOT_, 0); }
public SetTargetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setTarget; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSetTarget(this);
else return visitor.visitChildren(this);
}
}
public final SetTargetContext setTarget() throws RecognitionException {
SetTargetContext _localctx = new SetTargetContext(_ctx, getState());
enterRule(_localctx, 56, RULE_setTarget);
try {
enterOuterAlt(_localctx, 1);
{
setState(1891);
colId();
setState(1894);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(1892);
match(DOT_);
setState(1893);
colId();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetTargetListContext extends ParserRuleContext {
public SetTargetContext setTarget() {
return getRuleContext(SetTargetContext.class,0);
}
public SetTargetListContext setTargetList() {
return getRuleContext(SetTargetListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public SetTargetListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setTargetList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSetTargetList(this);
else return visitor.visitChildren(this);
}
}
public final SetTargetListContext setTargetList() throws RecognitionException {
return setTargetList(0);
}
private SetTargetListContext setTargetList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
SetTargetListContext _localctx = new SetTargetListContext(_ctx, _parentState);
SetTargetListContext _prevctx = _localctx;
int _startState = 58;
enterRecursionRule(_localctx, 58, RULE_setTargetList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1897);
setTarget();
}
_ctx.stop = _input.LT(-1);
setState(1904);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new SetTargetListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_setTargetList);
setState(1899);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1900);
match(COMMA_);
setState(1901);
setTarget();
}
}
}
setState(1906);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ReturningClauseContext extends ParserRuleContext {
public TerminalNode RETURNING() { return getToken(OpenGaussStatementParser.RETURNING, 0); }
public TargetListContext targetList() {
return getRuleContext(TargetListContext.class,0);
}
public ReturningClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returningClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitReturningClause(this);
else return visitor.visitChildren(this);
}
}
public final ReturningClauseContext returningClause() throws RecognitionException {
ReturningClauseContext _localctx = new ReturningClauseContext(_ctx, getState());
enterRule(_localctx, 60, RULE_returningClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1907);
match(RETURNING);
setState(1908);
targetList(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeleteContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(OpenGaussStatementParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(OpenGaussStatementParser.FROM, 0); }
public RelationExprOptAliasContext relationExprOptAlias() {
return getRuleContext(RelationExprOptAliasContext.class,0);
}
public WithClauseContext withClause() {
return getRuleContext(WithClauseContext.class,0);
}
public UsingClauseContext usingClause() {
return getRuleContext(UsingClauseContext.class,0);
}
public WhereOrCurrentClauseContext whereOrCurrentClause() {
return getRuleContext(WhereOrCurrentClauseContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public DeleteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delete; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitDelete(this);
else return visitor.visitChildren(this);
}
}
public final DeleteContext delete() throws RecognitionException {
DeleteContext _localctx = new DeleteContext(_ctx, getState());
enterRule(_localctx, 62, RULE_delete);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1911);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1910);
withClause();
}
}
setState(1913);
match(DELETE);
setState(1914);
match(FROM);
setState(1915);
relationExprOptAlias();
setState(1917);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(1916);
usingClause();
}
}
setState(1920);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1919);
whereOrCurrentClause();
}
}
setState(1923);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1922);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationExprOptAliasContext extends ParserRuleContext {
public RelationExprContext relationExpr() {
return getRuleContext(RelationExprContext.class,0);
}
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public RelationExprOptAliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationExprOptAlias; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRelationExprOptAlias(this);
else return visitor.visitChildren(this);
}
}
public final RelationExprOptAliasContext relationExprOptAlias() throws RecognitionException {
RelationExprOptAliasContext _localctx = new RelationExprOptAliasContext(_ctx, getState());
enterRule(_localctx, 64, RULE_relationExprOptAlias);
try {
setState(1933);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1925);
relationExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1926);
relationExpr();
setState(1927);
colId();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1929);
relationExpr();
setState(1930);
match(AS);
setState(1931);
colId();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UsingClauseContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(OpenGaussStatementParser.USING, 0); }
public FromListContext fromList() {
return getRuleContext(FromListContext.class,0);
}
public UsingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_usingClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitUsingClause(this);
else return visitor.visitChildren(this);
}
}
public final UsingClauseContext usingClause() throws RecognitionException {
UsingClauseContext _localctx = new UsingClauseContext(_ctx, getState());
enterRule(_localctx, 66, RULE_usingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1935);
match(USING);
setState(1936);
fromList(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectContext extends ParserRuleContext {
public SelectNoParensContext selectNoParens() {
return getRuleContext(SelectNoParensContext.class,0);
}
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public SelectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelect(this);
else return visitor.visitChildren(this);
}
}
public final SelectContext select() throws RecognitionException {
SelectContext _localctx = new SelectContext(_ctx, getState());
enterRule(_localctx, 68, RULE_select);
try {
setState(1940);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1938);
selectNoParens();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1939);
selectWithParens();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectWithParensContext extends ParserRuleContext {
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public SelectNoParensContext selectNoParens() {
return getRuleContext(SelectNoParensContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public SelectWithParensContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectWithParens; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectWithParens(this);
else return visitor.visitChildren(this);
}
}
public final SelectWithParensContext selectWithParens() throws RecognitionException {
SelectWithParensContext _localctx = new SelectWithParensContext(_ctx, getState());
enterRule(_localctx, 70, RULE_selectWithParens);
try {
setState(1950);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1942);
match(LP_);
setState(1943);
selectNoParens();
setState(1944);
match(RP_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1946);
match(LP_);
setState(1947);
selectWithParens();
setState(1948);
match(RP_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectNoParensContext extends ParserRuleContext {
public SelectClauseNContext selectClauseN() {
return getRuleContext(SelectClauseNContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public ForLockingClauseContext forLockingClause() {
return getRuleContext(ForLockingClauseContext.class,0);
}
public SelectLimitContext selectLimit() {
return getRuleContext(SelectLimitContext.class,0);
}
public WithClauseContext withClause() {
return getRuleContext(WithClauseContext.class,0);
}
public SelectNoParensContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectNoParens; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectNoParens(this);
else return visitor.visitChildren(this);
}
}
public final SelectNoParensContext selectNoParens() throws RecognitionException {
SelectNoParensContext _localctx = new SelectNoParensContext(_ctx, getState());
enterRule(_localctx, 72, RULE_selectNoParens);
int _la;
try {
setState(1997);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1952);
selectClauseN(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1953);
selectClauseN(0);
setState(1954);
sortClause();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1956);
selectClauseN(0);
setState(1958);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1957);
sortClause();
}
}
setState(1960);
forLockingClause();
setState(1962);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==OFFSET || _la==FETCH) {
{
setState(1961);
selectLimit();
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1964);
selectClauseN(0);
setState(1966);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1965);
sortClause();
}
}
setState(1968);
selectLimit();
setState(1970);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(1969);
forLockingClause();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1972);
withClause();
setState(1973);
selectClauseN(0);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1975);
withClause();
setState(1976);
selectClauseN(0);
setState(1977);
sortClause();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1979);
withClause();
setState(1980);
selectClauseN(0);
setState(1982);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1981);
sortClause();
}
}
setState(1984);
forLockingClause();
setState(1986);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==OFFSET || _la==FETCH) {
{
setState(1985);
selectLimit();
}
}
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1988);
withClause();
setState(1989);
selectClauseN(0);
setState(1991);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1990);
sortClause();
}
}
setState(1993);
selectLimit();
setState(1995);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(1994);
forLockingClause();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectClauseNContext extends ParserRuleContext {
public SimpleSelectContext simpleSelect() {
return getRuleContext(SimpleSelectContext.class,0);
}
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public List selectClauseN() {
return getRuleContexts(SelectClauseNContext.class);
}
public SelectClauseNContext selectClauseN(int i) {
return getRuleContext(SelectClauseNContext.class,i);
}
public TerminalNode INTERSECT() { return getToken(OpenGaussStatementParser.INTERSECT, 0); }
public AllOrDistinctContext allOrDistinct() {
return getRuleContext(AllOrDistinctContext.class,0);
}
public TerminalNode UNION() { return getToken(OpenGaussStatementParser.UNION, 0); }
public TerminalNode EXCEPT() { return getToken(OpenGaussStatementParser.EXCEPT, 0); }
public TerminalNode MINUS() { return getToken(OpenGaussStatementParser.MINUS, 0); }
public SelectClauseNContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClauseN; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectClauseN(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseNContext selectClauseN() throws RecognitionException {
return selectClauseN(0);
}
private SelectClauseNContext selectClauseN(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
SelectClauseNContext _localctx = new SelectClauseNContext(_ctx, _parentState);
SelectClauseNContext _prevctx = _localctx;
int _startState = 74;
enterRecursionRule(_localctx, 74, RULE_selectClauseN, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2002);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
case TABLE:
case VALUES:
{
setState(2000);
simpleSelect();
}
break;
case LP_:
{
setState(2001);
selectWithParens();
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(2018);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2016);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
{
_localctx = new SelectClauseNContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_selectClauseN);
setState(2004);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2005);
match(INTERSECT);
setState(2007);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2006);
allOrDistinct();
}
}
setState(2009);
selectClauseN(3);
}
break;
case 2:
{
_localctx = new SelectClauseNContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_selectClauseN);
setState(2010);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2011);
_la = _input.LA(1);
if ( !(_la==UNION || _la==EXCEPT || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2013);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DISTINCT || _la==ALL) {
{
setState(2012);
allOrDistinct();
}
}
setState(2015);
selectClauseN(2);
}
break;
}
}
}
setState(2020);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class SimpleSelectContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(OpenGaussStatementParser.SELECT, 0); }
public TerminalNode ALL() { return getToken(OpenGaussStatementParser.ALL, 0); }
public TargetListContext targetList() {
return getRuleContext(TargetListContext.class,0);
}
public IntoClauseContext intoClause() {
return getRuleContext(IntoClauseContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public GroupClauseContext groupClause() {
return getRuleContext(GroupClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public DistinctClauseContext distinctClause() {
return getRuleContext(DistinctClauseContext.class,0);
}
public ValuesClauseContext valuesClause() {
return getRuleContext(ValuesClauseContext.class,0);
}
public TerminalNode TABLE() { return getToken(OpenGaussStatementParser.TABLE, 0); }
public RelationExprContext relationExpr() {
return getRuleContext(RelationExprContext.class,0);
}
public SimpleSelectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleSelect; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSimpleSelect(this);
else return visitor.visitChildren(this);
}
}
public final SimpleSelectContext simpleSelect() throws RecognitionException {
SimpleSelectContext _localctx = new SimpleSelectContext(_ctx, getState());
enterRule(_localctx, 76, RULE_simpleSelect);
try {
setState(2070);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2021);
match(SELECT);
setState(2023);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
setState(2022);
match(ALL);
}
break;
}
setState(2026);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(2025);
targetList(0);
}
break;
}
setState(2029);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
setState(2028);
intoClause();
}
break;
}
setState(2032);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(2031);
fromClause();
}
break;
}
setState(2035);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(2034);
whereClause();
}
break;
}
setState(2038);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
{
setState(2037);
groupClause();
}
break;
}
setState(2041);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
{
setState(2040);
havingClause();
}
break;
}
setState(2044);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(2043);
windowClause();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2046);
match(SELECT);
setState(2047);
distinctClause();
setState(2048);
targetList(0);
setState(2050);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(2049);
intoClause();
}
break;
}
setState(2053);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(2052);
fromClause();
}
break;
}
setState(2056);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(2055);
whereClause();
}
break;
}
setState(2059);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(2058);
groupClause();
}
break;
}
setState(2062);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
case 1:
{
setState(2061);
havingClause();
}
break;
}
setState(2065);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(2064);
windowClause();
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2067);
valuesClause(0);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2068);
match(TABLE);
setState(2069);
relationExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithClauseContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(OpenGaussStatementParser.WITH, 0); }
public CteListContext cteList() {
return getRuleContext(CteListContext.class,0);
}
public TerminalNode RECURSIVE() { return getToken(OpenGaussStatementParser.RECURSIVE, 0); }
public WithClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWithClause(this);
else return visitor.visitChildren(this);
}
}
public final WithClauseContext withClause() throws RecognitionException {
WithClauseContext _localctx = new WithClauseContext(_ctx, getState());
enterRule(_localctx, 78, RULE_withClause);
try {
setState(2077);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2072);
match(WITH);
setState(2073);
cteList(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2074);
match(WITH);
setState(2075);
match(RECURSIVE);
setState(2076);
cteList(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntoClauseContext extends ParserRuleContext {
public TerminalNode INTO() { return getToken(OpenGaussStatementParser.INTO, 0); }
public OptTempTableNameContext optTempTableName() {
return getRuleContext(OptTempTableNameContext.class,0);
}
public IntoClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intoClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitIntoClause(this);
else return visitor.visitChildren(this);
}
}
public final IntoClauseContext intoClause() throws RecognitionException {
IntoClauseContext _localctx = new IntoClauseContext(_ctx, getState());
enterRule(_localctx, 80, RULE_intoClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2079);
match(INTO);
setState(2080);
optTempTableName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptTempTableNameContext extends ParserRuleContext {
public TerminalNode TEMPORARY() { return getToken(OpenGaussStatementParser.TEMPORARY, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode TABLE() { return getToken(OpenGaussStatementParser.TABLE, 0); }
public TerminalNode TEMP() { return getToken(OpenGaussStatementParser.TEMP, 0); }
public TerminalNode LOCAL() { return getToken(OpenGaussStatementParser.LOCAL, 0); }
public TerminalNode GLOBAL() { return getToken(OpenGaussStatementParser.GLOBAL, 0); }
public TerminalNode UNLOGGED() { return getToken(OpenGaussStatementParser.UNLOGGED, 0); }
public OptTempTableNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optTempTableName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOptTempTableName(this);
else return visitor.visitChildren(this);
}
}
public final OptTempTableNameContext optTempTableName() throws RecognitionException {
OptTempTableNameContext _localctx = new OptTempTableNameContext(_ctx, getState());
enterRule(_localctx, 82, RULE_optTempTableName);
int _la;
try {
setState(2126);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2082);
match(TEMPORARY);
setState(2084);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2083);
match(TABLE);
}
}
setState(2086);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2087);
match(TEMP);
setState(2089);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2088);
match(TABLE);
}
}
setState(2091);
qualifiedName();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2092);
match(LOCAL);
setState(2093);
match(TEMPORARY);
setState(2095);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2094);
match(TABLE);
}
}
setState(2097);
qualifiedName();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2098);
match(LOCAL);
setState(2099);
match(TEMP);
setState(2101);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2100);
match(TABLE);
}
}
setState(2103);
qualifiedName();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2104);
match(GLOBAL);
setState(2105);
match(TEMPORARY);
setState(2107);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2106);
match(TABLE);
}
}
setState(2109);
qualifiedName();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2110);
match(GLOBAL);
setState(2111);
match(TEMP);
setState(2113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2112);
match(TABLE);
}
}
setState(2115);
qualifiedName();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2116);
match(UNLOGGED);
setState(2118);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2117);
match(TABLE);
}
}
setState(2120);
qualifiedName();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2122);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2121);
match(TABLE);
}
}
setState(2124);
qualifiedName();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2125);
qualifiedName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CteListContext extends ParserRuleContext {
public CommonTableExprContext commonTableExpr() {
return getRuleContext(CommonTableExprContext.class,0);
}
public CteListContext cteList() {
return getRuleContext(CteListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public CteListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cteList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCteList(this);
else return visitor.visitChildren(this);
}
}
public final CteListContext cteList() throws RecognitionException {
return cteList(0);
}
private CteListContext cteList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
CteListContext _localctx = new CteListContext(_ctx, _parentState);
CteListContext _prevctx = _localctx;
int _startState = 84;
enterRecursionRule(_localctx, 84, RULE_cteList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2129);
commonTableExpr();
}
_ctx.stop = _input.LT(-1);
setState(2136);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new CteListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_cteList);
setState(2131);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2132);
match(COMMA_);
setState(2133);
commonTableExpr();
}
}
}
setState(2138);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class CommonTableExprContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public OptNameListContext optNameList() {
return getRuleContext(OptNameListContext.class,0);
}
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public OptMaterializedContext optMaterialized() {
return getRuleContext(OptMaterializedContext.class,0);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public PreparableStmtContext preparableStmt() {
return getRuleContext(PreparableStmtContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public CommonTableExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commonTableExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCommonTableExpr(this);
else return visitor.visitChildren(this);
}
}
public final CommonTableExprContext commonTableExpr() throws RecognitionException {
CommonTableExprContext _localctx = new CommonTableExprContext(_ctx, getState());
enterRule(_localctx, 86, RULE_commonTableExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(2139);
name();
setState(2140);
optNameList();
setState(2141);
match(AS);
setState(2142);
optMaterialized();
setState(2143);
match(LP_);
setState(2144);
preparableStmt();
setState(2145);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptMaterializedContext extends ParserRuleContext {
public TerminalNode MATERIALIZED() { return getToken(OpenGaussStatementParser.MATERIALIZED, 0); }
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public OptMaterializedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optMaterialized; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOptMaterialized(this);
else return visitor.visitChildren(this);
}
}
public final OptMaterializedContext optMaterialized() throws RecognitionException {
OptMaterializedContext _localctx = new OptMaterializedContext(_ctx, getState());
enterRule(_localctx, 88, RULE_optMaterialized);
try {
setState(2151);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MATERIALIZED:
enterOuterAlt(_localctx, 1);
{
setState(2147);
match(MATERIALIZED);
}
break;
case NOT:
enterOuterAlt(_localctx, 2);
{
setState(2148);
match(NOT);
setState(2149);
match(MATERIALIZED);
}
break;
case LP_:
enterOuterAlt(_localctx, 3);
{
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptNameListContext extends ParserRuleContext {
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public NameListContext nameList() {
return getRuleContext(NameListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public OptNameListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optNameList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOptNameList(this);
else return visitor.visitChildren(this);
}
}
public final OptNameListContext optNameList() throws RecognitionException {
OptNameListContext _localctx = new OptNameListContext(_ctx, getState());
enterRule(_localctx, 90, RULE_optNameList);
try {
setState(2158);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LP_:
enterOuterAlt(_localctx, 1);
{
setState(2153);
match(LP_);
setState(2154);
nameList(0);
setState(2155);
match(RP_);
}
break;
case EOF:
case COMMA_:
case SEMI_:
case AS:
case ON:
enterOuterAlt(_localctx, 2);
{
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PreparableStmtContext extends ParserRuleContext {
public SelectContext select() {
return getRuleContext(SelectContext.class,0);
}
public InsertContext insert() {
return getRuleContext(InsertContext.class,0);
}
public UpdateContext update() {
return getRuleContext(UpdateContext.class,0);
}
public DeleteContext delete() {
return getRuleContext(DeleteContext.class,0);
}
public PreparableStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_preparableStmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitPreparableStmt(this);
else return visitor.visitChildren(this);
}
}
public final PreparableStmtContext preparableStmt() throws RecognitionException {
PreparableStmtContext _localctx = new PreparableStmtContext(_ctx, getState());
enterRule(_localctx, 92, RULE_preparableStmt);
try {
setState(2164);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2160);
select();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2161);
insert();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2162);
update();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2163);
delete();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForLockingClauseContext extends ParserRuleContext {
public ForLockingItemsContext forLockingItems() {
return getRuleContext(ForLockingItemsContext.class,0);
}
public TerminalNode FOR() { return getToken(OpenGaussStatementParser.FOR, 0); }
public TerminalNode READ() { return getToken(OpenGaussStatementParser.READ, 0); }
public TerminalNode ONLY() { return getToken(OpenGaussStatementParser.ONLY, 0); }
public ForLockingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forLockingClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitForLockingClause(this);
else return visitor.visitChildren(this);
}
}
public final ForLockingClauseContext forLockingClause() throws RecognitionException {
ForLockingClauseContext _localctx = new ForLockingClauseContext(_ctx, getState());
enterRule(_localctx, 94, RULE_forLockingClause);
try {
setState(2170);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2166);
forLockingItems(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2167);
match(FOR);
setState(2168);
match(READ);
setState(2169);
match(ONLY);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForLockingItemsContext extends ParserRuleContext {
public ForLockingItemContext forLockingItem() {
return getRuleContext(ForLockingItemContext.class,0);
}
public ForLockingItemsContext forLockingItems() {
return getRuleContext(ForLockingItemsContext.class,0);
}
public ForLockingItemsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forLockingItems; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitForLockingItems(this);
else return visitor.visitChildren(this);
}
}
public final ForLockingItemsContext forLockingItems() throws RecognitionException {
return forLockingItems(0);
}
private ForLockingItemsContext forLockingItems(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ForLockingItemsContext _localctx = new ForLockingItemsContext(_ctx, _parentState);
ForLockingItemsContext _prevctx = _localctx;
int _startState = 96;
enterRecursionRule(_localctx, 96, RULE_forLockingItems, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2173);
forLockingItem();
}
_ctx.stop = _input.LT(-1);
setState(2179);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,91,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ForLockingItemsContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_forLockingItems);
setState(2175);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2176);
forLockingItem();
}
}
}
setState(2181);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,91,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ForLockingItemContext extends ParserRuleContext {
public ForLockingStrengthContext forLockingStrength() {
return getRuleContext(ForLockingStrengthContext.class,0);
}
public LockedRelsListContext lockedRelsList() {
return getRuleContext(LockedRelsListContext.class,0);
}
public NowaitOrSkipContext nowaitOrSkip() {
return getRuleContext(NowaitOrSkipContext.class,0);
}
public ForLockingItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forLockingItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitForLockingItem(this);
else return visitor.visitChildren(this);
}
}
public final ForLockingItemContext forLockingItem() throws RecognitionException {
ForLockingItemContext _localctx = new ForLockingItemContext(_ctx, getState());
enterRule(_localctx, 98, RULE_forLockingItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2182);
forLockingStrength();
setState(2184);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
{
setState(2183);
lockedRelsList();
}
break;
}
setState(2187);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) {
case 1:
{
setState(2186);
nowaitOrSkip();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NowaitOrSkipContext extends ParserRuleContext {
public TerminalNode NOWAIT() { return getToken(OpenGaussStatementParser.NOWAIT, 0); }
public TerminalNode LOCKED() { return getToken(OpenGaussStatementParser.LOCKED, 0); }
public NowaitOrSkipContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nowaitOrSkip; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitNowaitOrSkip(this);
else return visitor.visitChildren(this);
}
}
public final NowaitOrSkipContext nowaitOrSkip() throws RecognitionException {
NowaitOrSkipContext _localctx = new NowaitOrSkipContext(_ctx, getState());
enterRule(_localctx, 100, RULE_nowaitOrSkip);
try {
setState(2192);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOWAIT:
enterOuterAlt(_localctx, 1);
{
setState(2189);
match(NOWAIT);
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(2190);
match(T__0);
setState(2191);
match(LOCKED);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForLockingStrengthContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(OpenGaussStatementParser.FOR, 0); }
public TerminalNode UPDATE() { return getToken(OpenGaussStatementParser.UPDATE, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public TerminalNode KEY() { return getToken(OpenGaussStatementParser.KEY, 0); }
public TerminalNode SHARE() { return getToken(OpenGaussStatementParser.SHARE, 0); }
public ForLockingStrengthContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forLockingStrength; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitForLockingStrength(this);
else return visitor.visitChildren(this);
}
}
public final ForLockingStrengthContext forLockingStrength() throws RecognitionException {
ForLockingStrengthContext _localctx = new ForLockingStrengthContext(_ctx, getState());
enterRule(_localctx, 102, RULE_forLockingStrength);
try {
setState(2205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2194);
match(FOR);
setState(2195);
match(UPDATE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2196);
match(FOR);
setState(2197);
match(NO);
setState(2198);
match(KEY);
setState(2199);
match(UPDATE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2200);
match(FOR);
setState(2201);
match(SHARE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2202);
match(FOR);
setState(2203);
match(KEY);
setState(2204);
match(SHARE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LockedRelsListContext extends ParserRuleContext {
public TerminalNode OF() { return getToken(OpenGaussStatementParser.OF, 0); }
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public LockedRelsListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lockedRelsList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitLockedRelsList(this);
else return visitor.visitChildren(this);
}
}
public final LockedRelsListContext lockedRelsList() throws RecognitionException {
LockedRelsListContext _localctx = new LockedRelsListContext(_ctx, getState());
enterRule(_localctx, 104, RULE_lockedRelsList);
try {
enterOuterAlt(_localctx, 1);
{
setState(2207);
match(OF);
setState(2208);
qualifiedNameList(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedNameListContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public QualifiedNameListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedNameList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitQualifiedNameList(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameListContext qualifiedNameList() throws RecognitionException {
return qualifiedNameList(0);
}
private QualifiedNameListContext qualifiedNameList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, _parentState);
QualifiedNameListContext _prevctx = _localctx;
int _startState = 106;
enterRecursionRule(_localctx, 106, RULE_qualifiedNameList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2211);
qualifiedName();
}
_ctx.stop = _input.LT(-1);
setState(2218);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new QualifiedNameListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_qualifiedNameList);
setState(2213);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2214);
match(COMMA_);
setState(2215);
qualifiedName();
}
}
}
setState(2220);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class SelectLimitContext extends ParserRuleContext {
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public OffsetClauseContext offsetClause() {
return getRuleContext(OffsetClauseContext.class,0);
}
public SelectLimitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectLimit; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectLimit(this);
else return visitor.visitChildren(this);
}
}
public final SelectLimitContext selectLimit() throws RecognitionException {
SelectLimitContext _localctx = new SelectLimitContext(_ctx, getState());
enterRule(_localctx, 108, RULE_selectLimit);
int _la;
try {
setState(2229);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
case FETCH:
enterOuterAlt(_localctx, 1);
{
setState(2221);
limitClause();
setState(2223);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFSET) {
{
setState(2222);
offsetClause();
}
}
}
break;
case OFFSET:
enterOuterAlt(_localctx, 2);
{
setState(2225);
offsetClause();
setState(2227);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIMIT || _la==FETCH) {
{
setState(2226);
limitClause();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValuesClauseContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(OpenGaussStatementParser.VALUES, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public ValuesClauseContext valuesClause() {
return getRuleContext(ValuesClauseContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public ValuesClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valuesClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitValuesClause(this);
else return visitor.visitChildren(this);
}
}
public final ValuesClauseContext valuesClause() throws RecognitionException {
return valuesClause(0);
}
private ValuesClauseContext valuesClause(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ValuesClauseContext _localctx = new ValuesClauseContext(_ctx, _parentState);
ValuesClauseContext _prevctx = _localctx;
int _startState = 110;
enterRecursionRule(_localctx, 110, RULE_valuesClause, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2232);
match(VALUES);
setState(2233);
match(LP_);
setState(2234);
exprList(0);
setState(2235);
match(RP_);
}
_ctx.stop = _input.LT(-1);
setState(2245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ValuesClauseContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_valuesClause);
setState(2237);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2238);
match(COMMA_);
setState(2239);
match(LP_);
setState(2240);
exprList(0);
setState(2241);
match(RP_);
}
}
}
setState(2247);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class LimitClauseContext extends ParserRuleContext {
public TerminalNode LIMIT() { return getToken(OpenGaussStatementParser.LIMIT, 0); }
public SelectLimitValueContext selectLimitValue() {
return getRuleContext(SelectLimitValueContext.class,0);
}
public SelectOffsetValueContext selectOffsetValue() {
return getRuleContext(SelectOffsetValueContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public TerminalNode FETCH() { return getToken(OpenGaussStatementParser.FETCH, 0); }
public FirstOrNextContext firstOrNext() {
return getRuleContext(FirstOrNextContext.class,0);
}
public RowOrRowsContext rowOrRows() {
return getRuleContext(RowOrRowsContext.class,0);
}
public OnlyOrWithTiesContext onlyOrWithTies() {
return getRuleContext(OnlyOrWithTiesContext.class,0);
}
public SelectFetchValueContext selectFetchValue() {
return getRuleContext(SelectFetchValueContext.class,0);
}
public LimitClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitLimitClause(this);
else return visitor.visitChildren(this);
}
}
public final LimitClauseContext limitClause() throws RecognitionException {
LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
enterRule(_localctx, 112, RULE_limitClause);
try {
setState(2263);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2248);
match(LIMIT);
setState(2249);
selectLimitValue();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2250);
match(LIMIT);
setState(2251);
selectOffsetValue();
setState(2252);
match(COMMA_);
setState(2253);
selectLimitValue();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2255);
match(FETCH);
setState(2256);
firstOrNext();
setState(2258);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(2257);
selectFetchValue();
}
break;
}
setState(2260);
rowOrRows();
setState(2261);
onlyOrWithTies();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OffsetClauseContext extends ParserRuleContext {
public TerminalNode OFFSET() { return getToken(OpenGaussStatementParser.OFFSET, 0); }
public SelectOffsetValueContext selectOffsetValue() {
return getRuleContext(SelectOffsetValueContext.class,0);
}
public RowOrRowsContext rowOrRows() {
return getRuleContext(RowOrRowsContext.class,0);
}
public OffsetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offsetClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOffsetClause(this);
else return visitor.visitChildren(this);
}
}
public final OffsetClauseContext offsetClause() throws RecognitionException {
OffsetClauseContext _localctx = new OffsetClauseContext(_ctx, getState());
enterRule(_localctx, 114, RULE_offsetClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2265);
match(OFFSET);
setState(2266);
selectOffsetValue();
setState(2268);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW || _la==ROWS) {
{
setState(2267);
rowOrRows();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectLimitValueContext extends ParserRuleContext {
public CExprContext cExpr() {
return getRuleContext(CExprContext.class,0);
}
public TerminalNode ALL() { return getToken(OpenGaussStatementParser.ALL, 0); }
public SelectLimitValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectLimitValue; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectLimitValue(this);
else return visitor.visitChildren(this);
}
}
public final SelectLimitValueContext selectLimitValue() throws RecognitionException {
SelectLimitValueContext _localctx = new SelectLimitValueContext(_ctx, getState());
enterRule(_localctx, 116, RULE_selectLimitValue);
try {
setState(2272);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS_:
case MINUS_:
case LP_:
case QUESTION_:
case DOLLAR_:
case UNICODE_ESCAPE:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case POSITION:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case CASE:
case CAST:
case TRIM:
case SUBSTRING:
case NATURAL:
case JOIN:
case FULL:
case INNER:
case OUTER:
case LEFT:
case RIGHT:
case CROSS:
case IF:
case IS:
case NULL:
case TRUE:
case FALSE:
case EXISTS:
case LIKE:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case BOOLEAN:
case DOUBLE:
case CHAR:
case CHARACTER:
case ARRAY:
case INTERVAL:
case DATE:
case TIME:
case TIMESTAMP:
case LOCALTIME:
case LOCALTIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case CURRENT_USER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case COLLATION:
case NAMES:
case INTEGER:
case REAL:
case DECIMAL:
case TYPE:
case SMALLINT:
case BIGINT:
case NUMERIC:
case TEXT:
case REPEATABLE:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case NULLIF:
case VARYING:
case NATIONAL:
case NCHAR:
case VALUE:
case COALESCE:
case TIES:
case CUBE:
case GROUPING:
case SETS:
case OTHERS:
case OVERLAPS:
case AT:
case DEC:
case MAXVALUE:
case ADMIN:
case BINARY:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case ROW:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case USER:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONCURRENTLY:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case EXTRACT:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SESSION_USER:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case INT:
case INT2:
case INT4:
case INT8:
case FLOAT:
case FLOAT4:
case FLOAT8:
case VARCHAR:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case BIT:
case XML:
case JSON:
case TABLESAMPLE:
case ORDINALITY:
case CURRENT_ROLE:
case CURRENT_CATALOG:
case CURRENT_SCHEMA:
case NORMALIZE:
case OVERLAY:
case XMLCONCAT:
case XMLELEMENT:
case XMLEXISTS:
case XMLFOREST:
case XMLPARSE:
case XMLPI:
case XMLROOT:
case XMLSERIALIZE:
case TREAT:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case GREATEST:
case LEAST:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case ILIKE:
case SIMILAR:
case ISNULL:
case NOTNULL:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case FREEZE:
case AUTHORIZATION:
case VERBOSE:
case PARAM:
case IDENTIFIER_:
case STRING_:
case NUMBER_:
enterOuterAlt(_localctx, 1);
{
setState(2270);
cExpr();
}
break;
case ALL:
enterOuterAlt(_localctx, 2);
{
setState(2271);
match(ALL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectOffsetValueContext extends ParserRuleContext {
public CExprContext cExpr() {
return getRuleContext(CExprContext.class,0);
}
public SelectOffsetValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectOffsetValue; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectOffsetValue(this);
else return visitor.visitChildren(this);
}
}
public final SelectOffsetValueContext selectOffsetValue() throws RecognitionException {
SelectOffsetValueContext _localctx = new SelectOffsetValueContext(_ctx, getState());
enterRule(_localctx, 118, RULE_selectOffsetValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(2274);
cExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectFetchValueContext extends ParserRuleContext {
public CExprContext cExpr() {
return getRuleContext(CExprContext.class,0);
}
public SelectFetchValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectFetchValue; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSelectFetchValue(this);
else return visitor.visitChildren(this);
}
}
public final SelectFetchValueContext selectFetchValue() throws RecognitionException {
SelectFetchValueContext _localctx = new SelectFetchValueContext(_ctx, getState());
enterRule(_localctx, 120, RULE_selectFetchValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(2276);
cExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RowOrRowsContext extends ParserRuleContext {
public TerminalNode ROW() { return getToken(OpenGaussStatementParser.ROW, 0); }
public TerminalNode ROWS() { return getToken(OpenGaussStatementParser.ROWS, 0); }
public RowOrRowsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowOrRows; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRowOrRows(this);
else return visitor.visitChildren(this);
}
}
public final RowOrRowsContext rowOrRows() throws RecognitionException {
RowOrRowsContext _localctx = new RowOrRowsContext(_ctx, getState());
enterRule(_localctx, 122, RULE_rowOrRows);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2278);
_la = _input.LA(1);
if ( !(_la==ROW || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FirstOrNextContext extends ParserRuleContext {
public TerminalNode FIRST() { return getToken(OpenGaussStatementParser.FIRST, 0); }
public TerminalNode NEXT() { return getToken(OpenGaussStatementParser.NEXT, 0); }
public FirstOrNextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_firstOrNext; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitFirstOrNext(this);
else return visitor.visitChildren(this);
}
}
public final FirstOrNextContext firstOrNext() throws RecognitionException {
FirstOrNextContext _localctx = new FirstOrNextContext(_ctx, getState());
enterRule(_localctx, 124, RULE_firstOrNext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2280);
_la = _input.LA(1);
if ( !(_la==NEXT || _la==FIRST) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OnlyOrWithTiesContext extends ParserRuleContext {
public TerminalNode ONLY() { return getToken(OpenGaussStatementParser.ONLY, 0); }
public TerminalNode WITH() { return getToken(OpenGaussStatementParser.WITH, 0); }
public TerminalNode TIES() { return getToken(OpenGaussStatementParser.TIES, 0); }
public OnlyOrWithTiesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onlyOrWithTies; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOnlyOrWithTies(this);
else return visitor.visitChildren(this);
}
}
public final OnlyOrWithTiesContext onlyOrWithTies() throws RecognitionException {
OnlyOrWithTiesContext _localctx = new OnlyOrWithTiesContext(_ctx, getState());
enterRule(_localctx, 126, RULE_onlyOrWithTies);
try {
setState(2285);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ONLY:
enterOuterAlt(_localctx, 1);
{
setState(2282);
match(ONLY);
}
break;
case WITH:
enterOuterAlt(_localctx, 2);
{
setState(2283);
match(WITH);
setState(2284);
match(TIES);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TargetListContext extends ParserRuleContext {
public TargetElContext targetEl() {
return getRuleContext(TargetElContext.class,0);
}
public TargetListContext targetList() {
return getRuleContext(TargetListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public TargetListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_targetList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitTargetList(this);
else return visitor.visitChildren(this);
}
}
public final TargetListContext targetList() throws RecognitionException {
return targetList(0);
}
private TargetListContext targetList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TargetListContext _localctx = new TargetListContext(_ctx, _parentState);
TargetListContext _prevctx = _localctx;
int _startState = 128;
enterRecursionRule(_localctx, 128, RULE_targetList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2288);
targetEl();
}
_ctx.stop = _input.LT(-1);
setState(2295);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new TargetListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_targetList);
setState(2290);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2291);
match(COMMA_);
setState(2292);
targetEl();
}
}
}
setState(2297);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TargetElContext extends ParserRuleContext {
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public TerminalNode DOT_ASTERISK_() { return getToken(OpenGaussStatementParser.DOT_ASTERISK_, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public TargetElContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_targetEl; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitTargetEl(this);
else return visitor.visitChildren(this);
}
}
public final TargetElContext targetEl() throws RecognitionException {
TargetElContext _localctx = new TargetElContext(_ctx, getState());
enterRule(_localctx, 130, RULE_targetEl);
try {
setState(2310);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2298);
colId();
setState(2299);
match(DOT_ASTERISK_);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2301);
aExpr(0);
setState(2302);
match(AS);
setState(2303);
identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2305);
aExpr(0);
setState(2306);
identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2308);
aExpr(0);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2309);
match(ASTERISK_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupClauseContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(OpenGaussStatementParser.GROUP, 0); }
public TerminalNode BY() { return getToken(OpenGaussStatementParser.BY, 0); }
public GroupByListContext groupByList() {
return getRuleContext(GroupByListContext.class,0);
}
public GroupClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitGroupClause(this);
else return visitor.visitChildren(this);
}
}
public final GroupClauseContext groupClause() throws RecognitionException {
GroupClauseContext _localctx = new GroupClauseContext(_ctx, getState());
enterRule(_localctx, 132, RULE_groupClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2312);
match(GROUP);
setState(2313);
match(BY);
setState(2314);
groupByList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByListContext extends ParserRuleContext {
public List groupByItem() {
return getRuleContexts(GroupByItemContext.class);
}
public GroupByItemContext groupByItem(int i) {
return getRuleContext(GroupByItemContext.class,i);
}
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public GroupByListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitGroupByList(this);
else return visitor.visitChildren(this);
}
}
public final GroupByListContext groupByList() throws RecognitionException {
GroupByListContext _localctx = new GroupByListContext(_ctx, getState());
enterRule(_localctx, 134, RULE_groupByList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2316);
groupByItem();
setState(2321);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2317);
match(COMMA_);
setState(2318);
groupByItem();
}
}
}
setState(2323);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByItemContext extends ParserRuleContext {
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public EmptyGroupingSetContext emptyGroupingSet() {
return getRuleContext(EmptyGroupingSetContext.class,0);
}
public CubeClauseContext cubeClause() {
return getRuleContext(CubeClauseContext.class,0);
}
public RollupClauseContext rollupClause() {
return getRuleContext(RollupClauseContext.class,0);
}
public GroupingSetsClauseContext groupingSetsClause() {
return getRuleContext(GroupingSetsClauseContext.class,0);
}
public GroupByItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitGroupByItem(this);
else return visitor.visitChildren(this);
}
}
public final GroupByItemContext groupByItem() throws RecognitionException {
GroupByItemContext _localctx = new GroupByItemContext(_ctx, getState());
enterRule(_localctx, 136, RULE_groupByItem);
try {
setState(2329);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2324);
aExpr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2325);
emptyGroupingSet();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2326);
cubeClause();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2327);
rollupClause();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2328);
groupingSetsClause();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EmptyGroupingSetContext extends ParserRuleContext {
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public EmptyGroupingSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptyGroupingSet; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitEmptyGroupingSet(this);
else return visitor.visitChildren(this);
}
}
public final EmptyGroupingSetContext emptyGroupingSet() throws RecognitionException {
EmptyGroupingSetContext _localctx = new EmptyGroupingSetContext(_ctx, getState());
enterRule(_localctx, 138, RULE_emptyGroupingSet);
try {
enterOuterAlt(_localctx, 1);
{
setState(2331);
match(LP_);
setState(2332);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RollupClauseContext extends ParserRuleContext {
public TerminalNode ROLLUP() { return getToken(OpenGaussStatementParser.ROLLUP, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public RollupClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rollupClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRollupClause(this);
else return visitor.visitChildren(this);
}
}
public final RollupClauseContext rollupClause() throws RecognitionException {
RollupClauseContext _localctx = new RollupClauseContext(_ctx, getState());
enterRule(_localctx, 140, RULE_rollupClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2334);
match(ROLLUP);
setState(2335);
match(LP_);
setState(2336);
exprList(0);
setState(2337);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CubeClauseContext extends ParserRuleContext {
public TerminalNode CUBE() { return getToken(OpenGaussStatementParser.CUBE, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public CubeClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cubeClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCubeClause(this);
else return visitor.visitChildren(this);
}
}
public final CubeClauseContext cubeClause() throws RecognitionException {
CubeClauseContext _localctx = new CubeClauseContext(_ctx, getState());
enterRule(_localctx, 142, RULE_cubeClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2339);
match(CUBE);
setState(2340);
match(LP_);
setState(2341);
exprList(0);
setState(2342);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupingSetsClauseContext extends ParserRuleContext {
public TerminalNode GROUPING() { return getToken(OpenGaussStatementParser.GROUPING, 0); }
public TerminalNode SETS() { return getToken(OpenGaussStatementParser.SETS, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public GroupByListContext groupByList() {
return getRuleContext(GroupByListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public GroupingSetsClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingSetsClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitGroupingSetsClause(this);
else return visitor.visitChildren(this);
}
}
public final GroupingSetsClauseContext groupingSetsClause() throws RecognitionException {
GroupingSetsClauseContext _localctx = new GroupingSetsClauseContext(_ctx, getState());
enterRule(_localctx, 144, RULE_groupingSetsClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2344);
match(GROUPING);
setState(2345);
match(SETS);
setState(2346);
match(LP_);
setState(2347);
groupByList();
setState(2348);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WindowClauseContext extends ParserRuleContext {
public TerminalNode WINDOW() { return getToken(OpenGaussStatementParser.WINDOW, 0); }
public WindowDefinitionListContext windowDefinitionList() {
return getRuleContext(WindowDefinitionListContext.class,0);
}
public WindowClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWindowClause(this);
else return visitor.visitChildren(this);
}
}
public final WindowClauseContext windowClause() throws RecognitionException {
WindowClauseContext _localctx = new WindowClauseContext(_ctx, getState());
enterRule(_localctx, 146, RULE_windowClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2350);
match(WINDOW);
setState(2351);
windowDefinitionList(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WindowDefinitionListContext extends ParserRuleContext {
public WindowDefinitionContext windowDefinition() {
return getRuleContext(WindowDefinitionContext.class,0);
}
public WindowDefinitionListContext windowDefinitionList() {
return getRuleContext(WindowDefinitionListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public WindowDefinitionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowDefinitionList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWindowDefinitionList(this);
else return visitor.visitChildren(this);
}
}
public final WindowDefinitionListContext windowDefinitionList() throws RecognitionException {
return windowDefinitionList(0);
}
private WindowDefinitionListContext windowDefinitionList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
WindowDefinitionListContext _localctx = new WindowDefinitionListContext(_ctx, _parentState);
WindowDefinitionListContext _prevctx = _localctx;
int _startState = 148;
enterRecursionRule(_localctx, 148, RULE_windowDefinitionList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2354);
windowDefinition();
}
_ctx.stop = _input.LT(-1);
setState(2361);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new WindowDefinitionListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_windowDefinitionList);
setState(2356);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2357);
match(COMMA_);
setState(2358);
windowDefinition();
}
}
}
setState(2363);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class WindowDefinitionContext extends ParserRuleContext {
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public WindowSpecificationContext windowSpecification() {
return getRuleContext(WindowSpecificationContext.class,0);
}
public WindowDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowDefinition; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWindowDefinition(this);
else return visitor.visitChildren(this);
}
}
public final WindowDefinitionContext windowDefinition() throws RecognitionException {
WindowDefinitionContext _localctx = new WindowDefinitionContext(_ctx, getState());
enterRule(_localctx, 150, RULE_windowDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(2364);
colId();
setState(2365);
match(AS);
setState(2366);
windowSpecification();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WindowSpecificationContext extends ParserRuleContext {
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public ExistingWindowNameContext existingWindowName() {
return getRuleContext(ExistingWindowNameContext.class,0);
}
public PartitionClauseContext partitionClause() {
return getRuleContext(PartitionClauseContext.class,0);
}
public SortClauseContext sortClause() {
return getRuleContext(SortClauseContext.class,0);
}
public FrameClauseContext frameClause() {
return getRuleContext(FrameClauseContext.class,0);
}
public WindowSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowSpecification; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWindowSpecification(this);
else return visitor.visitChildren(this);
}
}
public final WindowSpecificationContext windowSpecification() throws RecognitionException {
WindowSpecificationContext _localctx = new WindowSpecificationContext(_ctx, getState());
enterRule(_localctx, 152, RULE_windowSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2368);
match(LP_);
setState(2370);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
{
setState(2369);
existingWindowName();
}
break;
}
setState(2373);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(2372);
partitionClause();
}
}
setState(2376);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(2375);
sortClause();
}
}
setState(2379);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROWS || _la==RANGE || _la==GROUPS) {
{
setState(2378);
frameClause();
}
}
setState(2381);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExistingWindowNameContext extends ParserRuleContext {
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public ExistingWindowNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_existingWindowName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitExistingWindowName(this);
else return visitor.visitChildren(this);
}
}
public final ExistingWindowNameContext existingWindowName() throws RecognitionException {
ExistingWindowNameContext _localctx = new ExistingWindowNameContext(_ctx, getState());
enterRule(_localctx, 154, RULE_existingWindowName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2383);
colId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionClauseContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(OpenGaussStatementParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(OpenGaussStatementParser.BY, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public PartitionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitPartitionClause(this);
else return visitor.visitChildren(this);
}
}
public final PartitionClauseContext partitionClause() throws RecognitionException {
PartitionClauseContext _localctx = new PartitionClauseContext(_ctx, getState());
enterRule(_localctx, 156, RULE_partitionClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2385);
match(PARTITION);
setState(2386);
match(BY);
setState(2387);
exprList(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameClauseContext extends ParserRuleContext {
public TerminalNode RANGE() { return getToken(OpenGaussStatementParser.RANGE, 0); }
public FrameExtentContext frameExtent() {
return getRuleContext(FrameExtentContext.class,0);
}
public OptWindowExclusionClauseContext optWindowExclusionClause() {
return getRuleContext(OptWindowExclusionClauseContext.class,0);
}
public TerminalNode ROWS() { return getToken(OpenGaussStatementParser.ROWS, 0); }
public TerminalNode GROUPS() { return getToken(OpenGaussStatementParser.GROUPS, 0); }
public FrameClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitFrameClause(this);
else return visitor.visitChildren(this);
}
}
public final FrameClauseContext frameClause() throws RecognitionException {
FrameClauseContext _localctx = new FrameClauseContext(_ctx, getState());
enterRule(_localctx, 158, RULE_frameClause);
try {
setState(2401);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RANGE:
enterOuterAlt(_localctx, 1);
{
setState(2389);
match(RANGE);
setState(2390);
frameExtent();
setState(2391);
optWindowExclusionClause();
}
break;
case ROWS:
enterOuterAlt(_localctx, 2);
{
setState(2393);
match(ROWS);
setState(2394);
frameExtent();
setState(2395);
optWindowExclusionClause();
}
break;
case GROUPS:
enterOuterAlt(_localctx, 3);
{
setState(2397);
match(GROUPS);
setState(2398);
frameExtent();
setState(2399);
optWindowExclusionClause();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameExtentContext extends ParserRuleContext {
public List frameBound() {
return getRuleContexts(FrameBoundContext.class);
}
public FrameBoundContext frameBound(int i) {
return getRuleContext(FrameBoundContext.class,i);
}
public TerminalNode BETWEEN() { return getToken(OpenGaussStatementParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public FrameExtentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameExtent; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitFrameExtent(this);
else return visitor.visitChildren(this);
}
}
public final FrameExtentContext frameExtent() throws RecognitionException {
FrameExtentContext _localctx = new FrameExtentContext(_ctx, getState());
enterRule(_localctx, 160, RULE_frameExtent);
try {
setState(2409);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OR_:
case SIGNED_LEFT_SHIFT_:
case SIGNED_RIGHT_SHIFT_:
case PLUS_:
case MINUS_:
case POUND_:
case LP_:
case QUESTION_:
case DOLLAR_:
case UNICODE_ESCAPE:
case JSON_EXTRACT_:
case JSON_EXTRACT_TEXT_:
case JSON_PATH_EXTRACT_:
case JSON_PATH_EXTRACT_TEXT_:
case JSONB_CONTAIN_RIGHT_:
case JSONB_CONTAIN_LEFT_:
case JSONB_CONTAIN_ALL_TOP_KEY_:
case JSONB_PATH_DELETE_:
case JSONB_PATH_CONTAIN_ANY_VALUE_:
case JSONB_PATH_PREDICATE_CHECK_:
case GEOMETRIC_LENGTH_:
case GEOMETRIC_DISTANCE_:
case GEOMETRIC_EXTEND_RIGHT_:
case GEOMETRIC_EXTEND_LEFT_:
case GEOMETRIC_STRICT_BELOW_:
case GEOMETRIC_STRICT_ABOVE_:
case GEOMETRIC_EXTEND_ABOVE_:
case GEOMETRIC_EXTEND_BELOW_:
case GEOMETRIC_BELOW_:
case GEOMETRIC_ABOVE_:
case GEOMETRIC_INTERSECT_:
case GEOMETRIC_PERPENDICULAR_:
case GEOMETRIC_SAME_AS_:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case UNIQUE:
case KEY:
case POSITION:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case CASE:
case CAST:
case TRIM:
case SUBSTRING:
case NATURAL:
case JOIN:
case FULL:
case INNER:
case OUTER:
case LEFT:
case RIGHT:
case CROSS:
case IF:
case IS:
case NOT:
case NULL:
case TRUE:
case FALSE:
case EXISTS:
case LIKE:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case BOOLEAN:
case DOUBLE:
case CHAR:
case CHARACTER:
case ARRAY:
case INTERVAL:
case DATE:
case TIME:
case TIMESTAMP:
case LOCALTIME:
case LOCALTIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case DEFAULT:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case CURRENT_USER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case COLLATION:
case NAMES:
case INTEGER:
case REAL:
case DECIMAL:
case TYPE:
case SMALLINT:
case BIGINT:
case NUMERIC:
case TEXT:
case REPEATABLE:
case CURRENT_DATE:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case NULLIF:
case VARYING:
case NATIONAL:
case NCHAR:
case VALUE:
case COALESCE:
case TIES:
case CUBE:
case GROUPING:
case SETS:
case OTHERS:
case OVERLAPS:
case AT:
case DEC:
case MAXVALUE:
case ADMIN:
case BINARY:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case ROW:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case USER:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONCURRENTLY:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case EXTRACT:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SESSION_USER:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case INT:
case INT2:
case INT4:
case INT8:
case FLOAT:
case FLOAT4:
case FLOAT8:
case VARCHAR:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case BIT:
case XML:
case JSON:
case TABLESAMPLE:
case ORDINALITY:
case CURRENT_ROLE:
case CURRENT_CATALOG:
case CURRENT_SCHEMA:
case NORMALIZE:
case OVERLAY:
case XMLCONCAT:
case XMLELEMENT:
case XMLEXISTS:
case XMLFOREST:
case XMLPARSE:
case XMLPI:
case XMLROOT:
case XMLSERIALIZE:
case TREAT:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case GREATEST:
case LEAST:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case ILIKE:
case SIMILAR:
case ISNULL:
case NOTNULL:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case FREEZE:
case AUTHORIZATION:
case VERBOSE:
case PARAM:
case IDENTIFIER_:
case STRING_:
case NUMBER_:
enterOuterAlt(_localctx, 1);
{
setState(2403);
frameBound();
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 2);
{
setState(2404);
match(BETWEEN);
setState(2405);
frameBound();
setState(2406);
match(AND);
setState(2407);
frameBound();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameBoundContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(OpenGaussStatementParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(OpenGaussStatementParser.PRECEDING, 0); }
public TerminalNode FOLLOWING() { return getToken(OpenGaussStatementParser.FOLLOWING, 0); }
public TerminalNode CURRENT() { return getToken(OpenGaussStatementParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(OpenGaussStatementParser.ROW, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public FrameBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameBound; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitFrameBound(this);
else return visitor.visitChildren(this);
}
}
public final FrameBoundContext frameBound() throws RecognitionException {
FrameBoundContext _localctx = new FrameBoundContext(_ctx, getState());
enterRule(_localctx, 162, RULE_frameBound);
try {
setState(2423);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2411);
match(UNBOUNDED);
setState(2412);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2413);
match(UNBOUNDED);
setState(2414);
match(FOLLOWING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2415);
match(CURRENT);
setState(2416);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2417);
aExpr(0);
setState(2418);
match(PRECEDING);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2420);
aExpr(0);
setState(2421);
match(FOLLOWING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptWindowExclusionClauseContext extends ParserRuleContext {
public TerminalNode EXCLUDE() { return getToken(OpenGaussStatementParser.EXCLUDE, 0); }
public TerminalNode CURRENT() { return getToken(OpenGaussStatementParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(OpenGaussStatementParser.ROW, 0); }
public TerminalNode GROUP() { return getToken(OpenGaussStatementParser.GROUP, 0); }
public TerminalNode TIES() { return getToken(OpenGaussStatementParser.TIES, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public TerminalNode OTHERS() { return getToken(OpenGaussStatementParser.OTHERS, 0); }
public OptWindowExclusionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optWindowExclusionClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOptWindowExclusionClause(this);
else return visitor.visitChildren(this);
}
}
public final OptWindowExclusionClauseContext optWindowExclusionClause() throws RecognitionException {
OptWindowExclusionClauseContext _localctx = new OptWindowExclusionClauseContext(_ctx, getState());
enterRule(_localctx, 164, RULE_optWindowExclusionClause);
try {
setState(2436);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2425);
match(EXCLUDE);
setState(2426);
match(CURRENT);
setState(2427);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2428);
match(EXCLUDE);
setState(2429);
match(GROUP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2430);
match(EXCLUDE);
setState(2431);
match(TIES);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2432);
match(EXCLUDE);
setState(2433);
match(NO);
setState(2434);
match(OTHERS);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AliasContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public AliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alias; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitAlias(this);
else return visitor.visitChildren(this);
}
}
public final AliasContext alias() throws RecognitionException {
AliasContext _localctx = new AliasContext(_ctx, getState());
enterRule(_localctx, 166, RULE_alias);
try {
setState(2440);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNICODE_ESCAPE:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case IF:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case DOUBLE:
case INTERVAL:
case TIME:
case TIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case NAMES:
case TYPE:
case TEXT:
case REPEATABLE:
case VARYING:
case NATIONAL:
case VALUE:
case TIES:
case CUBE:
case SETS:
case OTHERS:
case AT:
case MAXVALUE:
case ADMIN:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case XML:
case JSON:
case ORDINALITY:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case IDENTIFIER_:
enterOuterAlt(_localctx, 1);
{
setState(2438);
identifier();
}
break;
case STRING_:
enterOuterAlt(_localctx, 2);
{
setState(2439);
match(STRING_);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(OpenGaussStatementParser.FROM, 0); }
public FromListContext fromList() {
return getRuleContext(FromListContext.class,0);
}
public FromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitFromClause(this);
else return visitor.visitChildren(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 168, RULE_fromClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2442);
match(FROM);
setState(2443);
fromList(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromListContext extends ParserRuleContext {
public TableReferenceContext tableReference() {
return getRuleContext(TableReferenceContext.class,0);
}
public FromListContext fromList() {
return getRuleContext(FromListContext.class,0);
}
public TerminalNode COMMA_() { return getToken(OpenGaussStatementParser.COMMA_, 0); }
public FromListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitFromList(this);
else return visitor.visitChildren(this);
}
}
public final FromListContext fromList() throws RecognitionException {
return fromList(0);
}
private FromListContext fromList(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
FromListContext _localctx = new FromListContext(_ctx, _parentState);
FromListContext _prevctx = _localctx;
int _startState = 170;
enterRecursionRule(_localctx, 170, RULE_fromList, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2446);
tableReference(0);
}
_ctx.stop = _input.LT(-1);
setState(2453);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new FromListContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_fromList);
setState(2448);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2449);
match(COMMA_);
setState(2450);
tableReference(0);
}
}
}
setState(2455);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TableReferenceContext extends ParserRuleContext {
public RelationExprContext relationExpr() {
return getRuleContext(RelationExprContext.class,0);
}
public AliasClauseContext aliasClause() {
return getRuleContext(AliasClauseContext.class,0);
}
public TablesampleClauseContext tablesampleClause() {
return getRuleContext(TablesampleClauseContext.class,0);
}
public FunctionTableContext functionTable() {
return getRuleContext(FunctionTableContext.class,0);
}
public FuncAliasClauseContext funcAliasClause() {
return getRuleContext(FuncAliasClauseContext.class,0);
}
public TerminalNode LATERAL() { return getToken(OpenGaussStatementParser.LATERAL, 0); }
public XmlTableContext xmlTable() {
return getRuleContext(XmlTableContext.class,0);
}
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public TableReferenceContext tableReference() {
return getRuleContext(TableReferenceContext.class,0);
}
public JoinedTableContext joinedTable() {
return getRuleContext(JoinedTableContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TableReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableReference; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitTableReference(this);
else return visitor.visitChildren(this);
}
}
public final TableReferenceContext tableReference() throws RecognitionException {
return tableReference(0);
}
private TableReferenceContext tableReference(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TableReferenceContext _localctx = new TableReferenceContext(_ctx, _parentState);
TableReferenceContext _prevctx = _localctx;
int _startState = 172;
enterRecursionRule(_localctx, 172, RULE_tableReference, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2501);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(2457);
relationExpr();
setState(2459);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
{
setState(2458);
aliasClause();
}
break;
}
}
break;
case 2:
{
setState(2461);
relationExpr();
setState(2463);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNICODE_ESCAPE || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (INSERT - 77)) | (1L << (UPDATE - 77)) | (1L << (DELETE - 77)) | (1L << (ALTER - 77)) | (1L << (DROP - 77)) | (1L << (TRUNCATE - 77)) | (1L << (SCHEMA - 77)) | (1L << (REVOKE - 77)) | (1L << (ADD - 77)) | (1L << (SET - 77)) | (1L << (INDEX - 77)) | (1L << (KEY - 77)) | (1L << (FUNCTION - 77)) | (1L << (TRIGGER - 77)) | (1L << (PROCEDURE - 77)) | (1L << (VIEW - 77)) | (1L << (AS - 77)) | (1L << (IF - 77)))) != 0) || ((((_la - 147)) & ~0x3f) == 0 && ((1L << (_la - 147)) & ((1L << (BY - 147)) | (1L << (BEGIN - 147)) | (1L << (COMMIT - 147)) | (1L << (ROLLBACK - 147)) | (1L << (SAVEPOINT - 147)) | (1L << (DOUBLE - 147)) | (1L << (INTERVAL - 147)) | (1L << (TIME - 147)) | (1L << (TIMESTAMP - 147)) | (1L << (YEAR - 147)) | (1L << (MONTH - 147)) | (1L << (DAY - 147)) | (1L << (HOUR - 147)) | (1L << (MINUTE - 147)) | (1L << (SECOND - 147)) | (1L << (CURRENT - 147)) | (1L << (ENABLE - 147)) | (1L << (DISABLE - 147)) | (1L << (CALL - 147)) | (1L << (PRESERVE - 147)) | (1L << (DEFINER - 147)) | (1L << (SQL - 147)) | (1L << (CASCADED - 147)) | (1L << (LOCAL - 147)) | (1L << (CLOSE - 147)) | (1L << (NEXT - 147)) | (1L << (NAME - 147)) | (1L << (NAMES - 147)) | (1L << (TYPE - 147)) | (1L << (TEXT - 147)) | (1L << (REPEATABLE - 147)) | (1L << (VARYING - 147)) | (1L << (NATIONAL - 147)))) != 0) || ((((_la - 212)) & ~0x3f) == 0 && ((1L << (_la - 212)) & ((1L << (VALUE - 212)) | (1L << (TIES - 212)) | (1L << (CUBE - 212)) | (1L << (SETS - 212)) | (1L << (OTHERS - 212)) | (1L << (AT - 212)) | (1L << (MAXVALUE - 212)) | (1L << (ADMIN - 212)) | (1L << (ESCAPE - 212)) | (1L << (EXCLUDE - 212)) | (1L << (MOD - 212)) | (1L << (PARTITION - 212)) | (1L << (UNKNOWN - 212)) | (1L << (ALWAYS - 212)) | (1L << (CASCADE - 212)) | (1L << (GENERATED - 212)) | (1L << (ISOLATION - 212)) | (1L << (LEVEL - 212)) | (1L << (NO - 212)) | (1L << (OPTION - 212)) | (1L << (PRIVILEGES - 212)) | (1L << (READ - 212)) | (1L << (ROLE - 212)) | (1L << (ROWS - 212)) | (1L << (START - 212)) | (1L << (TRANSACTION - 212)) | (1L << (ACTION - 212)) | (1L << (CACHE - 212)) | (1L << (CHARACTERISTICS - 212)) | (1L << (CLUSTER - 212)) | (1L << (COMMENTS - 212)) | (1L << (CONSTRAINTS - 212)) | (1L << (CYCLE - 212)) | (1L << (DATA - 212)) | (1L << (DATABASE - 212)) | (1L << (DEFAULTS - 212)) | (1L << (DEFERRED - 212)))) != 0) || ((((_la - 276)) & ~0x3f) == 0 && ((1L << (_la - 276)) & ((1L << (DEPENDS - 276)) | (1L << (DOMAIN - 276)) | (1L << (EXCLUDING - 276)) | (1L << (EXECUTE - 276)) | (1L << (EXTENDED - 276)) | (1L << (EXTENSION - 276)) | (1L << (EXTERNAL - 276)) | (1L << (FILTER - 276)) | (1L << (FIRST - 276)) | (1L << (FOLLOWING - 276)) | (1L << (FORCE - 276)) | (1L << (GLOBAL - 276)) | (1L << (IDENTITY - 276)) | (1L << (IMMEDIATE - 276)) | (1L << (INCLUDING - 276)) | (1L << (INCREMENT - 276)) | (1L << (INDEXES - 276)) | (1L << (INHERIT - 276)) | (1L << (INHERITS - 276)) | (1L << (INCLUDE - 276)) | (1L << (LANGUAGE - 276)) | (1L << (LARGE - 276)) | (1L << (LAST - 276)) | (1L << (LOGGED - 276)) | (1L << (MAIN - 276)) | (1L << (MATCH - 276)) | (1L << (MINVALUE - 276)) | (1L << (NOTHING - 276)) | (1L << (NULLS - 276)) | (1L << (OBJECT - 276)) | (1L << (OIDS - 276)) | (1L << (OVER - 276)) | (1L << (OWNED - 276)) | (1L << (OWNER - 276)) | (1L << (PARTIAL - 276)) | (1L << (PLAIN - 276)) | (1L << (PRECEDING - 276)) | (1L << (RANGE - 276)) | (1L << (RENAME - 276)) | (1L << (REPLICA - 276)) | (1L << (RESET - 276)) | (1L << (RESTART - 276)) | (1L << (RESTRICT - 276)) | (1L << (ROUTINE - 276)) | (1L << (RULE - 276)) | (1L << (SECURITY - 276)) | (1L << (SEQUENCE - 276)) | (1L << (SESSION - 276)) | (1L << (SHOW - 276)) | (1L << (SIMPLE - 276)) | (1L << (STATISTICS - 276)) | (1L << (STORAGE - 276)) | (1L << (TABLESPACE - 276)) | (1L << (TEMP - 276)) | (1L << (TEMPORARY - 276)) | (1L << (UNBOUNDED - 276)) | (1L << (UNLOGGED - 276)) | (1L << (VALID - 276)))) != 0) || ((((_la - 340)) & ~0x3f) == 0 && ((1L << (_la - 340)) & ((1L << (VALIDATE - 340)) | (1L << (WITHIN - 340)) | (1L << (WITHOUT - 340)) | (1L << (ZONE - 340)) | (1L << (OF - 340)) | (1L << (UESCAPE - 340)) | (1L << (GROUPS - 340)) | (1L << (RECURSIVE - 340)) | (1L << (ENUM - 340)) | (1L << (POINT - 340)) | (1L << (LSEG - 340)) | (1L << (BOX - 340)) | (1L << (PATH - 340)) | (1L << (POLYGON - 340)) | (1L << (CIRCLE - 340)) | (1L << (XML - 340)) | (1L << (JSON - 340)) | (1L << (ORDINALITY - 340)) | (1L << (NFC - 340)) | (1L << (NFD - 340)) | (1L << (NFKC - 340)))) != 0) || ((((_la - 404)) & ~0x3f) == 0 && ((1L << (_la - 404)) & ((1L << (NFKD - 404)) | (1L << (REF - 404)) | (1L << (PASSING - 404)) | (1L << (VERSION - 404)) | (1L << (YES - 404)) | (1L << (STANDALONE - 404)) | (1L << (MATERIALIZED - 404)) | (1L << (OPERATOR - 404)) | (1L << (SHARE - 404)) | (1L << (ROLLUP - 404)) | (1L << (DOCUMENT - 404)) | (1L << (NORMALIZED - 404)) | (1L << (NOWAIT - 404)) | (1L << (LOCKED - 404)) | (1L << (COLUMNS - 404)) | (1L << (CONTENT - 404)) | (1L << (STRIP - 404)) | (1L << (WHITESPACE - 404)) | (1L << (CONFLICT - 404)) | (1L << (OVERRIDING - 404)) | (1L << (SYSTEM - 404)) | (1L << (ABORT - 404)) | (1L << (ABSOLUTE - 404)) | (1L << (ACCESS - 404)) | (1L << (AFTER - 404)) | (1L << (AGGREGATE - 404)) | (1L << (ALSO - 404)) | (1L << (ATTACH - 404)) | (1L << (ATTRIBUTE - 404)) | (1L << (BACKWARD - 404)) | (1L << (BEFORE - 404)) | (1L << (ASSERTION - 404)) | (1L << (ASSIGNMENT - 404)) | (1L << (CONTINUE - 404)) | (1L << (CONVERSION - 404)) | (1L << (COPY - 404)) | (1L << (COST - 404)) | (1L << (CSV - 404)) | (1L << (CALLED - 404)) | (1L << (CATALOG - 404)) | (1L << (CHAIN - 404)) | (1L << (CHECKPOINT - 404)) | (1L << (CLASS - 404)) | (1L << (CONFIGURATION - 404)) | (1L << (COMMENT - 404)) | (1L << (DETACH - 404)))) != 0) || ((((_la - 468)) & ~0x3f) == 0 && ((1L << (_la - 468)) & ((1L << (DICTIONARY - 468)) | (1L << (EXPRESSION - 468)) | (1L << (INSENSITIVE - 468)) | (1L << (DISCARD - 468)) | (1L << (OFF - 468)) | (1L << (INSTEAD - 468)) | (1L << (EXPLAIN - 468)) | (1L << (INPUT - 468)) | (1L << (INLINE - 468)) | (1L << (PARALLEL - 468)) | (1L << (LEAKPROOF - 468)) | (1L << (COMMITTED - 468)) | (1L << (ENCODING - 468)) | (1L << (IMPLICIT - 468)) | (1L << (DELIMITER - 468)) | (1L << (CURSOR - 468)) | (1L << (EACH - 468)) | (1L << (EVENT - 468)) | (1L << (DEALLOCATE - 468)) | (1L << (CONNECTION - 468)) | (1L << (DECLARE - 468)) | (1L << (FAMILY - 468)) | (1L << (FORWARD - 468)) | (1L << (EXCLUSIVE - 468)) | (1L << (FUNCTIONS - 468)) | (1L << (LOCATION - 468)) | (1L << (LABEL - 468)) | (1L << (DELIMITERS - 468)) | (1L << (HANDLER - 468)) | (1L << (HEADER - 468)) | (1L << (IMMUTABLE - 468)) | (1L << (GRANTED - 468)) | (1L << (HOLD - 468)) | (1L << (MAPPING - 468)) | (1L << (OLD - 468)) | (1L << (METHOD - 468)) | (1L << (LOAD - 468)) | (1L << (LISTEN - 468)) | (1L << (MODE - 468)) | (1L << (MOVE - 468)) | (1L << (PROCEDURAL - 468)) | (1L << (PARSER - 468)) | (1L << (PROCEDURES - 468)) | (1L << (ENCRYPTED - 468)) | (1L << (PUBLICATION - 468)) | (1L << (PROGRAM - 468)) | (1L << (REFERENCING - 468)) | (1L << (PLANS - 468)) | (1L << (REINDEX - 468)) | (1L << (PRIOR - 468)) | (1L << (PASSWORD - 468)) | (1L << (RELATIVE - 468)) | (1L << (QUOTE - 468)) | (1L << (ROUTINES - 468)) | (1L << (REPLACE - 468)) | (1L << (SNAPSHOT - 468)) | (1L << (REFRESH - 468)) | (1L << (PREPARE - 468)) | (1L << (OPTIONS - 468)) | (1L << (IMPORT - 468)) | (1L << (INVOKER - 468)) | (1L << (NEW - 468)) | (1L << (PREPARED - 468)))) != 0) || ((((_la - 532)) & ~0x3f) == 0 && ((1L << (_la - 532)) & ((1L << (SCROLL - 532)) | (1L << (SEQUENCES - 532)) | (1L << (SYSID - 532)) | (1L << (REASSIGN - 532)) | (1L << (SERVER - 532)) | (1L << (SUBSCRIPTION - 532)) | (1L << (SEARCH - 532)) | (1L << (SCHEMAS - 532)) | (1L << (RECHECK - 532)) | (1L << (POLICY - 532)) | (1L << (NOTIFY - 532)) | (1L << (LOCK - 532)) | (1L << (RELEASE - 532)) | (1L << (SERIALIZABLE - 532)) | (1L << (RETURNS - 532)) | (1L << (STATEMENT - 532)) | (1L << (STDIN - 532)) | (1L << (STDOUT - 532)) | (1L << (TABLES - 532)) | (1L << (SUPPORT - 532)) | (1L << (STABLE - 532)) | (1L << (TEMPLATE - 532)) | (1L << (UNENCRYPTED - 532)) | (1L << (VIEWS - 532)) | (1L << (UNCOMMITTED - 532)) | (1L << (TRANSFORM - 532)) | (1L << (UNLISTEN - 532)) | (1L << (TRUSTED - 532)) | (1L << (VALIDATOR - 532)) | (1L << (UNTIL - 532)) | (1L << (VACUUM - 532)) | (1L << (VOLATILE - 532)) | (1L << (STORED - 532)) | (1L << (WRITE - 532)) | (1L << (STRICT - 532)) | (1L << (TYPES - 532)) | (1L << (WRAPPER - 532)) | (1L << (WORK - 532)) | (1L << (IDENTIFIER_ - 532)))) != 0)) {
{
setState(2462);
aliasClause();
}
}
setState(2465);
tablesampleClause();
}
break;
case 3:
{
setState(2467);
functionTable();
setState(2469);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(2468);
funcAliasClause();
}
break;
}
}
break;
case 4:
{
setState(2471);
match(LATERAL);
setState(2472);
functionTable();
setState(2474);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(2473);
funcAliasClause();
}
break;
}
}
break;
case 5:
{
setState(2476);
xmlTable();
setState(2478);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(2477);
aliasClause();
}
break;
}
}
break;
case 6:
{
setState(2480);
match(LATERAL);
setState(2481);
xmlTable();
setState(2483);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
setState(2482);
aliasClause();
}
break;
}
}
break;
case 7:
{
setState(2485);
selectWithParens();
setState(2487);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(2486);
aliasClause();
}
break;
}
}
break;
case 8:
{
setState(2489);
match(LATERAL);
setState(2490);
selectWithParens();
setState(2492);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
case 1:
{
setState(2491);
aliasClause();
}
break;
}
}
break;
case 9:
{
setState(2494);
match(LP_);
setState(2495);
tableReference(0);
setState(2496);
joinedTable();
setState(2497);
match(RP_);
setState(2499);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(2498);
aliasClause();
}
break;
}
}
break;
}
_ctx.stop = _input.LT(-1);
setState(2507);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,131,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new TableReferenceContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_tableReference);
setState(2503);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2504);
joinedTable();
}
}
}
setState(2509);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,131,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class JoinedTableContext extends ParserRuleContext {
public CrossJoinTypeContext crossJoinType() {
return getRuleContext(CrossJoinTypeContext.class,0);
}
public TableReferenceContext tableReference() {
return getRuleContext(TableReferenceContext.class,0);
}
public InnerJoinTypeContext innerJoinType() {
return getRuleContext(InnerJoinTypeContext.class,0);
}
public JoinQualContext joinQual() {
return getRuleContext(JoinQualContext.class,0);
}
public OuterJoinTypeContext outerJoinType() {
return getRuleContext(OuterJoinTypeContext.class,0);
}
public NaturalJoinTypeContext naturalJoinType() {
return getRuleContext(NaturalJoinTypeContext.class,0);
}
public JoinedTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinedTable; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitJoinedTable(this);
else return visitor.visitChildren(this);
}
}
public final JoinedTableContext joinedTable() throws RecognitionException {
JoinedTableContext _localctx = new JoinedTableContext(_ctx, getState());
enterRule(_localctx, 174, RULE_joinedTable);
try {
setState(2524);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
enterOuterAlt(_localctx, 1);
{
setState(2510);
crossJoinType();
setState(2511);
tableReference(0);
}
break;
case JOIN:
case INNER:
enterOuterAlt(_localctx, 2);
{
setState(2513);
innerJoinType();
setState(2514);
tableReference(0);
setState(2515);
joinQual();
}
break;
case FULL:
case LEFT:
case RIGHT:
enterOuterAlt(_localctx, 3);
{
setState(2517);
outerJoinType();
setState(2518);
tableReference(0);
setState(2519);
joinQual();
}
break;
case NATURAL:
enterOuterAlt(_localctx, 4);
{
setState(2521);
naturalJoinType();
setState(2522);
tableReference(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CrossJoinTypeContext extends ParserRuleContext {
public TerminalNode CROSS() { return getToken(OpenGaussStatementParser.CROSS, 0); }
public TerminalNode JOIN() { return getToken(OpenGaussStatementParser.JOIN, 0); }
public CrossJoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crossJoinType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCrossJoinType(this);
else return visitor.visitChildren(this);
}
}
public final CrossJoinTypeContext crossJoinType() throws RecognitionException {
CrossJoinTypeContext _localctx = new CrossJoinTypeContext(_ctx, getState());
enterRule(_localctx, 176, RULE_crossJoinType);
try {
enterOuterAlt(_localctx, 1);
{
setState(2526);
match(CROSS);
setState(2527);
match(JOIN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InnerJoinTypeContext extends ParserRuleContext {
public TerminalNode JOIN() { return getToken(OpenGaussStatementParser.JOIN, 0); }
public TerminalNode INNER() { return getToken(OpenGaussStatementParser.INNER, 0); }
public InnerJoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_innerJoinType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInnerJoinType(this);
else return visitor.visitChildren(this);
}
}
public final InnerJoinTypeContext innerJoinType() throws RecognitionException {
InnerJoinTypeContext _localctx = new InnerJoinTypeContext(_ctx, getState());
enterRule(_localctx, 178, RULE_innerJoinType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2530);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(2529);
match(INNER);
}
}
setState(2532);
match(JOIN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterJoinTypeContext extends ParserRuleContext {
public TerminalNode JOIN() { return getToken(OpenGaussStatementParser.JOIN, 0); }
public TerminalNode FULL() { return getToken(OpenGaussStatementParser.FULL, 0); }
public TerminalNode LEFT() { return getToken(OpenGaussStatementParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(OpenGaussStatementParser.RIGHT, 0); }
public TerminalNode OUTER() { return getToken(OpenGaussStatementParser.OUTER, 0); }
public OuterJoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerJoinType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOuterJoinType(this);
else return visitor.visitChildren(this);
}
}
public final OuterJoinTypeContext outerJoinType() throws RecognitionException {
OuterJoinTypeContext _localctx = new OuterJoinTypeContext(_ctx, getState());
enterRule(_localctx, 180, RULE_outerJoinType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2534);
_la = _input.LA(1);
if ( !(((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (FULL - 117)) | (1L << (LEFT - 117)) | (1L << (RIGHT - 117)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2536);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(2535);
match(OUTER);
}
}
setState(2538);
match(JOIN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NaturalJoinTypeContext extends ParserRuleContext {
public TerminalNode NATURAL() { return getToken(OpenGaussStatementParser.NATURAL, 0); }
public TerminalNode JOIN() { return getToken(OpenGaussStatementParser.JOIN, 0); }
public TerminalNode INNER() { return getToken(OpenGaussStatementParser.INNER, 0); }
public TerminalNode FULL() { return getToken(OpenGaussStatementParser.FULL, 0); }
public TerminalNode LEFT() { return getToken(OpenGaussStatementParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(OpenGaussStatementParser.RIGHT, 0); }
public TerminalNode OUTER() { return getToken(OpenGaussStatementParser.OUTER, 0); }
public NaturalJoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_naturalJoinType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitNaturalJoinType(this);
else return visitor.visitChildren(this);
}
}
public final NaturalJoinTypeContext naturalJoinType() throws RecognitionException {
NaturalJoinTypeContext _localctx = new NaturalJoinTypeContext(_ctx, getState());
enterRule(_localctx, 182, RULE_naturalJoinType);
int _la;
try {
setState(2551);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2540);
match(NATURAL);
setState(2542);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(2541);
match(INNER);
}
}
setState(2544);
match(JOIN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2545);
match(NATURAL);
setState(2546);
_la = _input.LA(1);
if ( !(((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (FULL - 117)) | (1L << (LEFT - 117)) | (1L << (RIGHT - 117)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2548);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(2547);
match(OUTER);
}
}
setState(2550);
match(JOIN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinQualContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(OpenGaussStatementParser.USING, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public NameListContext nameList() {
return getRuleContext(NameListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TerminalNode ON() { return getToken(OpenGaussStatementParser.ON, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public JoinQualContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinQual; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitJoinQual(this);
else return visitor.visitChildren(this);
}
}
public final JoinQualContext joinQual() throws RecognitionException {
JoinQualContext _localctx = new JoinQualContext(_ctx, getState());
enterRule(_localctx, 184, RULE_joinQual);
try {
setState(2560);
_errHandler.sync(this);
switch (_input.LA(1)) {
case USING:
enterOuterAlt(_localctx, 1);
{
setState(2553);
match(USING);
setState(2554);
match(LP_);
setState(2555);
nameList(0);
setState(2556);
match(RP_);
}
break;
case ON:
enterOuterAlt(_localctx, 2);
{
setState(2558);
match(ON);
setState(2559);
aExpr(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationExprContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public TerminalNode ONLY() { return getToken(OpenGaussStatementParser.ONLY, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public RelationExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitRelationExpr(this);
else return visitor.visitChildren(this);
}
}
public final RelationExprContext relationExpr() throws RecognitionException {
RelationExprContext _localctx = new RelationExprContext(_ctx, getState());
enterRule(_localctx, 186, RULE_relationExpr);
try {
setState(2573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2562);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2563);
qualifiedName();
setState(2564);
match(ASTERISK_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2566);
match(ONLY);
setState(2567);
qualifiedName();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2568);
match(ONLY);
setState(2569);
match(LP_);
setState(2570);
qualifiedName();
setState(2571);
match(RP_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhereClauseContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(OpenGaussStatementParser.WHERE, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 188, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2575);
match(WHERE);
setState(2576);
aExpr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhereOrCurrentClauseContext extends ParserRuleContext {
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode WHERE() { return getToken(OpenGaussStatementParser.WHERE, 0); }
public TerminalNode CURRENT() { return getToken(OpenGaussStatementParser.CURRENT, 0); }
public TerminalNode OF() { return getToken(OpenGaussStatementParser.OF, 0); }
public CursorNameContext cursorName() {
return getRuleContext(CursorNameContext.class,0);
}
public WhereOrCurrentClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereOrCurrentClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWhereOrCurrentClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereOrCurrentClauseContext whereOrCurrentClause() throws RecognitionException {
WhereOrCurrentClauseContext _localctx = new WhereOrCurrentClauseContext(_ctx, getState());
enterRule(_localctx, 190, RULE_whereOrCurrentClause);
try {
setState(2583);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2578);
whereClause();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2579);
match(WHERE);
setState(2580);
match(CURRENT);
setState(2581);
match(OF);
setState(2582);
cursorName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(OpenGaussStatementParser.HAVING, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitHavingClause(this);
else return visitor.visitChildren(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 192, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2585);
match(HAVING);
setState(2586);
aExpr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DoStatementContext extends ParserRuleContext {
public TerminalNode DO() { return getToken(OpenGaussStatementParser.DO, 0); }
public DostmtOptListContext dostmtOptList() {
return getRuleContext(DostmtOptListContext.class,0);
}
public DoStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doStatement; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitDoStatement(this);
else return visitor.visitChildren(this);
}
}
public final DoStatementContext doStatement() throws RecognitionException {
DoStatementContext _localctx = new DoStatementContext(_ctx, getState());
enterRule(_localctx, 194, RULE_doStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(2588);
match(DO);
setState(2589);
dostmtOptList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DostmtOptListContext extends ParserRuleContext {
public List dostmtOptItem() {
return getRuleContexts(DostmtOptItemContext.class);
}
public DostmtOptItemContext dostmtOptItem(int i) {
return getRuleContext(DostmtOptItemContext.class,i);
}
public DostmtOptListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dostmtOptList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitDostmtOptList(this);
else return visitor.visitChildren(this);
}
}
public final DostmtOptListContext dostmtOptList() throws RecognitionException {
DostmtOptListContext _localctx = new DostmtOptListContext(_ctx, getState());
enterRule(_localctx, 196, RULE_dostmtOptList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2592);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(2591);
dostmtOptItem();
}
}
setState(2594);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LANGUAGE || _la==STRING_ );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DostmtOptItemContext extends ParserRuleContext {
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public TerminalNode LANGUAGE() { return getToken(OpenGaussStatementParser.LANGUAGE, 0); }
public NonReservedWordOrSconstContext nonReservedWordOrSconst() {
return getRuleContext(NonReservedWordOrSconstContext.class,0);
}
public DostmtOptItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dostmtOptItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitDostmtOptItem(this);
else return visitor.visitChildren(this);
}
}
public final DostmtOptItemContext dostmtOptItem() throws RecognitionException {
DostmtOptItemContext _localctx = new DostmtOptItemContext(_ctx, getState());
enterRule(_localctx, 198, RULE_dostmtOptItem);
try {
setState(2599);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_:
enterOuterAlt(_localctx, 1);
{
setState(2596);
match(STRING_);
}
break;
case LANGUAGE:
enterOuterAlt(_localctx, 2);
{
setState(2597);
match(LANGUAGE);
setState(2598);
nonReservedWordOrSconst();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LockContext extends ParserRuleContext {
public TerminalNode LOCK() { return getToken(OpenGaussStatementParser.LOCK, 0); }
public RelationExprListContext relationExprList() {
return getRuleContext(RelationExprListContext.class,0);
}
public TerminalNode TABLE() { return getToken(OpenGaussStatementParser.TABLE, 0); }
public TerminalNode IN() { return getToken(OpenGaussStatementParser.IN, 0); }
public LockTypeContext lockType() {
return getRuleContext(LockTypeContext.class,0);
}
public TerminalNode MODE() { return getToken(OpenGaussStatementParser.MODE, 0); }
public TerminalNode NOWAIT() { return getToken(OpenGaussStatementParser.NOWAIT, 0); }
public LockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lock; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitLock(this);
else return visitor.visitChildren(this);
}
}
public final LockContext lock() throws RecognitionException {
LockContext _localctx = new LockContext(_ctx, getState());
enterRule(_localctx, 200, RULE_lock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2601);
match(LOCK);
setState(2603);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TABLE) {
{
setState(2602);
match(TABLE);
}
}
setState(2605);
relationExprList();
setState(2610);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IN) {
{
setState(2606);
match(IN);
setState(2607);
lockType();
setState(2608);
match(MODE);
}
}
setState(2613);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOWAIT) {
{
setState(2612);
match(NOWAIT);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LockTypeContext extends ParserRuleContext {
public TerminalNode ACCESS() { return getToken(OpenGaussStatementParser.ACCESS, 0); }
public TerminalNode SHARE() { return getToken(OpenGaussStatementParser.SHARE, 0); }
public TerminalNode ROW() { return getToken(OpenGaussStatementParser.ROW, 0); }
public TerminalNode EXCLUSIVE() { return getToken(OpenGaussStatementParser.EXCLUSIVE, 0); }
public TerminalNode UPDATE() { return getToken(OpenGaussStatementParser.UPDATE, 0); }
public LockTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lockType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitLockType(this);
else return visitor.visitChildren(this);
}
}
public final LockTypeContext lockType() throws RecognitionException {
LockTypeContext _localctx = new LockTypeContext(_ctx, getState());
enterRule(_localctx, 202, RULE_lockType);
try {
setState(2631);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2615);
match(ACCESS);
setState(2616);
match(SHARE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2617);
match(ROW);
setState(2618);
match(SHARE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2619);
match(ROW);
setState(2620);
match(EXCLUSIVE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2621);
match(SHARE);
setState(2622);
match(UPDATE);
setState(2623);
match(EXCLUSIVE);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2624);
match(SHARE);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2625);
match(SHARE);
setState(2626);
match(ROW);
setState(2627);
match(EXCLUSIVE);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2628);
match(EXCLUSIVE);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2629);
match(ACCESS);
setState(2630);
match(EXCLUSIVE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CheckpointContext extends ParserRuleContext {
public TerminalNode CHECKPOINT() { return getToken(OpenGaussStatementParser.CHECKPOINT, 0); }
public CheckpointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_checkpoint; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCheckpoint(this);
else return visitor.visitChildren(this);
}
}
public final CheckpointContext checkpoint() throws RecognitionException {
CheckpointContext _localctx = new CheckpointContext(_ctx, getState());
enterRule(_localctx, 204, RULE_checkpoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(2633);
match(CHECKPOINT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyContext extends ParserRuleContext {
public TerminalNode COPY() { return getToken(OpenGaussStatementParser.COPY, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public CopyOptionsContext copyOptions() {
return getRuleContext(CopyOptionsContext.class,0);
}
public TerminalNode FROM() { return getToken(OpenGaussStatementParser.FROM, 0); }
public TerminalNode TO() { return getToken(OpenGaussStatementParser.TO, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public TerminalNode STDIN() { return getToken(OpenGaussStatementParser.STDIN, 0); }
public TerminalNode STDOUT() { return getToken(OpenGaussStatementParser.STDOUT, 0); }
public TerminalNode BINARY() { return getToken(OpenGaussStatementParser.BINARY, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TerminalNode PROGRAM() { return getToken(OpenGaussStatementParser.PROGRAM, 0); }
public CopyDelimiterContext copyDelimiter() {
return getRuleContext(CopyDelimiterContext.class,0);
}
public TerminalNode WITH() { return getToken(OpenGaussStatementParser.WITH, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public PreparableStmtContext preparableStmt() {
return getRuleContext(PreparableStmtContext.class,0);
}
public CopyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copy; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopy(this);
else return visitor.visitChildren(this);
}
}
public final CopyContext copy() throws RecognitionException {
CopyContext _localctx = new CopyContext(_ctx, getState());
enterRule(_localctx, 206, RULE_copy);
int _la;
try {
setState(2675);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2635);
match(COPY);
setState(2637);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BINARY) {
{
setState(2636);
match(BINARY);
}
}
setState(2639);
qualifiedName();
setState(2644);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP_) {
{
setState(2640);
match(LP_);
setState(2641);
columnList();
setState(2642);
match(RP_);
}
}
setState(2646);
_la = _input.LA(1);
if ( !(_la==FROM || _la==TO) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2648);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROGRAM) {
{
setState(2647);
match(PROGRAM);
}
}
setState(2650);
_la = _input.LA(1);
if ( !(((((_la - 548)) & ~0x3f) == 0 && ((1L << (_la - 548)) & ((1L << (STDIN - 548)) | (1L << (STDOUT - 548)) | (1L << (STRING_ - 548)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2652);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING || _la==DELIMITERS) {
{
setState(2651);
copyDelimiter();
}
}
setState(2655);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2654);
match(WITH);
}
}
setState(2657);
copyOptions();
setState(2659);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(2658);
whereClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2661);
match(COPY);
setState(2662);
match(LP_);
setState(2663);
preparableStmt();
setState(2664);
match(RP_);
setState(2665);
match(TO);
setState(2667);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PROGRAM) {
{
setState(2666);
match(PROGRAM);
}
}
setState(2669);
_la = _input.LA(1);
if ( !(((((_la - 548)) & ~0x3f) == 0 && ((1L << (_la - 548)) & ((1L << (STDIN - 548)) | (1L << (STDOUT - 548)) | (1L << (STRING_ - 548)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(2671);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(2670);
match(WITH);
}
}
setState(2673);
copyOptions();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyOptionsContext extends ParserRuleContext {
public CopyOptListContext copyOptList() {
return getRuleContext(CopyOptListContext.class,0);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public CopyGenericOptListContext copyGenericOptList() {
return getRuleContext(CopyGenericOptListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public CopyOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyOptions; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyOptions(this);
else return visitor.visitChildren(this);
}
}
public final CopyOptionsContext copyOptions() throws RecognitionException {
CopyOptionsContext _localctx = new CopyOptionsContext(_ctx, getState());
enterRule(_localctx, 208, RULE_copyOptions);
try {
setState(2682);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EOF:
case SEMI_:
case WHERE:
case NULL:
case BINARY:
case ESCAPE:
case FORCE:
case CSV:
case ENCODING:
case DELIMITER:
case HEADER:
case QUOTE:
case FREEZE:
enterOuterAlt(_localctx, 1);
{
setState(2677);
copyOptList();
}
break;
case LP_:
enterOuterAlt(_localctx, 2);
{
setState(2678);
match(LP_);
setState(2679);
copyGenericOptList();
setState(2680);
match(RP_);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyGenericOptListContext extends ParserRuleContext {
public List copyGenericOptElem() {
return getRuleContexts(CopyGenericOptElemContext.class);
}
public CopyGenericOptElemContext copyGenericOptElem(int i) {
return getRuleContext(CopyGenericOptElemContext.class,i);
}
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public CopyGenericOptListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyGenericOptList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyGenericOptList(this);
else return visitor.visitChildren(this);
}
}
public final CopyGenericOptListContext copyGenericOptList() throws RecognitionException {
CopyGenericOptListContext _localctx = new CopyGenericOptListContext(_ctx, getState());
enterRule(_localctx, 210, RULE_copyGenericOptList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2684);
copyGenericOptElem();
setState(2689);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2685);
match(COMMA_);
setState(2686);
copyGenericOptElem();
}
}
setState(2691);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyGenericOptElemContext extends ParserRuleContext {
public ColLabelContext colLabel() {
return getRuleContext(ColLabelContext.class,0);
}
public CopyGenericOptArgContext copyGenericOptArg() {
return getRuleContext(CopyGenericOptArgContext.class,0);
}
public CopyGenericOptElemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyGenericOptElem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyGenericOptElem(this);
else return visitor.visitChildren(this);
}
}
public final CopyGenericOptElemContext copyGenericOptElem() throws RecognitionException {
CopyGenericOptElemContext _localctx = new CopyGenericOptElemContext(_ctx, getState());
enterRule(_localctx, 212, RULE_copyGenericOptElem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2692);
colLabel();
setState(2693);
copyGenericOptArg();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyGenericOptArgContext extends ParserRuleContext {
public BooleanOrStringContext booleanOrString() {
return getRuleContext(BooleanOrStringContext.class,0);
}
public NumericOnlyContext numericOnly() {
return getRuleContext(NumericOnlyContext.class,0);
}
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public CopyGenericOptArgListContext copyGenericOptArgList() {
return getRuleContext(CopyGenericOptArgListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public CopyGenericOptArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyGenericOptArg; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyGenericOptArg(this);
else return visitor.visitChildren(this);
}
}
public final CopyGenericOptArgContext copyGenericOptArg() throws RecognitionException {
CopyGenericOptArgContext _localctx = new CopyGenericOptArgContext(_ctx, getState());
enterRule(_localctx, 214, RULE_copyGenericOptArg);
try {
setState(2702);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNICODE_ESCAPE:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case POSITION:
case PRECISION:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case VALUES:
case TRIM:
case SUBSTRING:
case NATURAL:
case JOIN:
case FULL:
case INNER:
case OUTER:
case LEFT:
case RIGHT:
case CROSS:
case ON:
case IF:
case IS:
case TRUE:
case FALSE:
case EXISTS:
case BETWEEN:
case LIKE:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case BOOLEAN:
case DOUBLE:
case CHAR:
case CHARACTER:
case INTERVAL:
case TIME:
case TIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case COLLATION:
case NAMES:
case INTEGER:
case REAL:
case DECIMAL:
case TYPE:
case SMALLINT:
case BIGINT:
case NUMERIC:
case TEXT:
case REPEATABLE:
case NULLIF:
case VARYING:
case NATIONAL:
case NCHAR:
case VALUE:
case COALESCE:
case TIES:
case CUBE:
case GROUPING:
case SETS:
case OTHERS:
case OVERLAPS:
case AT:
case DEC:
case MAXVALUE:
case ADMIN:
case BINARY:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case ROW:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONCURRENTLY:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case EXTRACT:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case INT:
case FLOAT:
case VARCHAR:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case BIT:
case XML:
case JSON:
case TABLESAMPLE:
case ORDINALITY:
case CURRENT_SCHEMA:
case OVERLAY:
case XMLCONCAT:
case XMLELEMENT:
case XMLEXISTS:
case XMLFOREST:
case XMLPARSE:
case XMLPI:
case XMLROOT:
case XMLSERIALIZE:
case TREAT:
case SETOF:
case NFC:
case NFD:
case NFKC:
case NFKD:
case XMLATTRIBUTES:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case GREATEST:
case LEAST:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case ILIKE:
case SIMILAR:
case ISNULL:
case NOTNULL:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case XMLTABLE:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case XMLNAMESPACES:
case NONE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case FREEZE:
case AUTHORIZATION:
case VERBOSE:
case OUT:
case INOUT:
case IDENTIFIER_:
case STRING_:
enterOuterAlt(_localctx, 1);
{
setState(2695);
booleanOrString();
}
break;
case PLUS_:
case MINUS_:
case NUMBER_:
enterOuterAlt(_localctx, 2);
{
setState(2696);
numericOnly();
}
break;
case ASTERISK_:
enterOuterAlt(_localctx, 3);
{
setState(2697);
match(ASTERISK_);
}
break;
case LP_:
enterOuterAlt(_localctx, 4);
{
setState(2698);
match(LP_);
setState(2699);
copyGenericOptArgList();
setState(2700);
match(RP_);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyGenericOptArgListContext extends ParserRuleContext {
public List copyGenericOptArgListItem() {
return getRuleContexts(CopyGenericOptArgListItemContext.class);
}
public CopyGenericOptArgListItemContext copyGenericOptArgListItem(int i) {
return getRuleContext(CopyGenericOptArgListItemContext.class,i);
}
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public CopyGenericOptArgListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyGenericOptArgList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyGenericOptArgList(this);
else return visitor.visitChildren(this);
}
}
public final CopyGenericOptArgListContext copyGenericOptArgList() throws RecognitionException {
CopyGenericOptArgListContext _localctx = new CopyGenericOptArgListContext(_ctx, getState());
enterRule(_localctx, 216, RULE_copyGenericOptArgList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2704);
copyGenericOptArgListItem();
setState(2709);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2705);
match(COMMA_);
setState(2706);
copyGenericOptArgListItem();
}
}
setState(2711);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyGenericOptArgListItemContext extends ParserRuleContext {
public BooleanOrStringContext booleanOrString() {
return getRuleContext(BooleanOrStringContext.class,0);
}
public CopyGenericOptArgListItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyGenericOptArgListItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyGenericOptArgListItem(this);
else return visitor.visitChildren(this);
}
}
public final CopyGenericOptArgListItemContext copyGenericOptArgListItem() throws RecognitionException {
CopyGenericOptArgListItemContext _localctx = new CopyGenericOptArgListItemContext(_ctx, getState());
enterRule(_localctx, 218, RULE_copyGenericOptArgListItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(2712);
booleanOrString();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyOptListContext extends ParserRuleContext {
public List copyOptItem() {
return getRuleContexts(CopyOptItemContext.class);
}
public CopyOptItemContext copyOptItem(int i) {
return getRuleContext(CopyOptItemContext.class,i);
}
public CopyOptListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyOptList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyOptList(this);
else return visitor.visitChildren(this);
}
}
public final CopyOptListContext copyOptList() throws RecognitionException {
CopyOptListContext _localctx = new CopyOptListContext(_ctx, getState());
enterRule(_localctx, 220, RULE_copyOptList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2717);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NULL || ((((_la - 238)) & ~0x3f) == 0 && ((1L << (_la - 238)) & ((1L << (BINARY - 238)) | (1L << (ESCAPE - 238)) | (1L << (FORCE - 238)))) != 0) || ((((_la - 459)) & ~0x3f) == 0 && ((1L << (_la - 459)) & ((1L << (CSV - 459)) | (1L << (ENCODING - 459)) | (1L << (DELIMITER - 459)) | (1L << (HEADER - 459)) | (1L << (QUOTE - 459)))) != 0) || _la==FREEZE) {
{
{
setState(2714);
copyOptItem();
}
}
setState(2719);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyOptItemContext extends ParserRuleContext {
public TerminalNode BINARY() { return getToken(OpenGaussStatementParser.BINARY, 0); }
public TerminalNode FREEZE() { return getToken(OpenGaussStatementParser.FREEZE, 0); }
public TerminalNode DELIMITER() { return getToken(OpenGaussStatementParser.DELIMITER, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public TerminalNode NULL() { return getToken(OpenGaussStatementParser.NULL, 0); }
public TerminalNode CSV() { return getToken(OpenGaussStatementParser.CSV, 0); }
public TerminalNode HEADER() { return getToken(OpenGaussStatementParser.HEADER, 0); }
public TerminalNode QUOTE() { return getToken(OpenGaussStatementParser.QUOTE, 0); }
public TerminalNode ESCAPE() { return getToken(OpenGaussStatementParser.ESCAPE, 0); }
public TerminalNode FORCE() { return getToken(OpenGaussStatementParser.FORCE, 0); }
public ColumnListContext columnList() {
return getRuleContext(ColumnListContext.class,0);
}
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public TerminalNode ENCODING() { return getToken(OpenGaussStatementParser.ENCODING, 0); }
public CopyOptItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyOptItem; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyOptItem(this);
else return visitor.visitChildren(this);
}
}
public final CopyOptItemContext copyOptItem() throws RecognitionException {
CopyOptItemContext _localctx = new CopyOptItemContext(_ctx, getState());
enterRule(_localctx, 222, RULE_copyOptItem);
int _la;
try {
setState(2759);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2720);
match(BINARY);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2721);
match(FREEZE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2722);
match(DELIMITER);
setState(2724);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2723);
match(AS);
}
}
setState(2726);
match(STRING_);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2727);
match(NULL);
setState(2729);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2728);
match(AS);
}
}
setState(2731);
match(STRING_);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2732);
match(CSV);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2733);
match(HEADER);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2734);
match(QUOTE);
setState(2736);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2735);
match(AS);
}
}
setState(2738);
match(STRING_);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2739);
match(ESCAPE);
setState(2741);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(2740);
match(AS);
}
}
setState(2743);
match(STRING_);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2744);
match(FORCE);
setState(2745);
match(QUOTE);
setState(2746);
columnList();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2747);
match(FORCE);
setState(2748);
match(QUOTE);
setState(2749);
match(ASTERISK_);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2750);
match(FORCE);
setState(2751);
match(NOT);
setState(2752);
match(NULL);
setState(2753);
columnList();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2754);
match(FORCE);
setState(2755);
match(NULL);
setState(2756);
columnList();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2757);
match(ENCODING);
setState(2758);
match(STRING_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CopyDelimiterContext extends ParserRuleContext {
public TerminalNode DELIMITERS() { return getToken(OpenGaussStatementParser.DELIMITERS, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public TerminalNode USING() { return getToken(OpenGaussStatementParser.USING, 0); }
public CopyDelimiterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copyDelimiter; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCopyDelimiter(this);
else return visitor.visitChildren(this);
}
}
public final CopyDelimiterContext copyDelimiter() throws RecognitionException {
CopyDelimiterContext _localctx = new CopyDelimiterContext(_ctx, getState());
enterRule(_localctx, 224, RULE_copyDelimiter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2762);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(2761);
match(USING);
}
}
setState(2764);
match(DELIMITERS);
setState(2765);
match(STRING_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterMarkerContext extends ParserRuleContext {
public TerminalNode QUESTION_() { return getToken(OpenGaussStatementParser.QUESTION_, 0); }
public LiteralsTypeContext literalsType() {
return getRuleContext(LiteralsTypeContext.class,0);
}
public TerminalNode DOLLAR_() { return getToken(OpenGaussStatementParser.DOLLAR_, 0); }
public TerminalNode NUMBER_() { return getToken(OpenGaussStatementParser.NUMBER_, 0); }
public ParameterMarkerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterMarker; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitParameterMarker(this);
else return visitor.visitChildren(this);
}
}
public final ParameterMarkerContext parameterMarker() throws RecognitionException {
ParameterMarkerContext _localctx = new ParameterMarkerContext(_ctx, getState());
enterRule(_localctx, 226, RULE_parameterMarker);
try {
setState(2773);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUESTION_:
enterOuterAlt(_localctx, 1);
{
setState(2767);
match(QUESTION_);
setState(2769);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
{
setState(2768);
literalsType();
}
break;
}
}
break;
case DOLLAR_:
enterOuterAlt(_localctx, 2);
{
setState(2771);
match(DOLLAR_);
setState(2772);
match(NUMBER_);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReservedKeywordContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(OpenGaussStatementParser.ALL, 0); }
public TerminalNode ANALYSE() { return getToken(OpenGaussStatementParser.ANALYSE, 0); }
public TerminalNode ANALYZE() { return getToken(OpenGaussStatementParser.ANALYZE, 0); }
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode ANY() { return getToken(OpenGaussStatementParser.ANY, 0); }
public TerminalNode ARRAY() { return getToken(OpenGaussStatementParser.ARRAY, 0); }
public TerminalNode AS() { return getToken(OpenGaussStatementParser.AS, 0); }
public TerminalNode ASC() { return getToken(OpenGaussStatementParser.ASC, 0); }
public TerminalNode ASYMMETRIC() { return getToken(OpenGaussStatementParser.ASYMMETRIC, 0); }
public TerminalNode BOTH() { return getToken(OpenGaussStatementParser.BOTH, 0); }
public TerminalNode CASE() { return getToken(OpenGaussStatementParser.CASE, 0); }
public TerminalNode CAST() { return getToken(OpenGaussStatementParser.CAST, 0); }
public TerminalNode CHECK() { return getToken(OpenGaussStatementParser.CHECK, 0); }
public TerminalNode COLLATE() { return getToken(OpenGaussStatementParser.COLLATE, 0); }
public TerminalNode COLUMN() { return getToken(OpenGaussStatementParser.COLUMN, 0); }
public TerminalNode CONSTRAINT() { return getToken(OpenGaussStatementParser.CONSTRAINT, 0); }
public TerminalNode CREATE() { return getToken(OpenGaussStatementParser.CREATE, 0); }
public TerminalNode CURRENT_CATALOG() { return getToken(OpenGaussStatementParser.CURRENT_CATALOG, 0); }
public TerminalNode CURRENT_DATE() { return getToken(OpenGaussStatementParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_ROLE() { return getToken(OpenGaussStatementParser.CURRENT_ROLE, 0); }
public TerminalNode CURRENT_TIME() { return getToken(OpenGaussStatementParser.CURRENT_TIME, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(OpenGaussStatementParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_USER() { return getToken(OpenGaussStatementParser.CURRENT_USER, 0); }
public TerminalNode DEFAULT() { return getToken(OpenGaussStatementParser.DEFAULT, 0); }
public TerminalNode DEFERRABLE() { return getToken(OpenGaussStatementParser.DEFERRABLE, 0); }
public TerminalNode DESC() { return getToken(OpenGaussStatementParser.DESC, 0); }
public TerminalNode DISTINCT() { return getToken(OpenGaussStatementParser.DISTINCT, 0); }
public TerminalNode DO() { return getToken(OpenGaussStatementParser.DO, 0); }
public TerminalNode ELSE() { return getToken(OpenGaussStatementParser.ELSE, 0); }
public TerminalNode END() { return getToken(OpenGaussStatementParser.END, 0); }
public TerminalNode EXCEPT() { return getToken(OpenGaussStatementParser.EXCEPT, 0); }
public TerminalNode FALSE() { return getToken(OpenGaussStatementParser.FALSE, 0); }
public TerminalNode FETCH() { return getToken(OpenGaussStatementParser.FETCH, 0); }
public TerminalNode FOR() { return getToken(OpenGaussStatementParser.FOR, 0); }
public TerminalNode FOREIGN() { return getToken(OpenGaussStatementParser.FOREIGN, 0); }
public TerminalNode FROM() { return getToken(OpenGaussStatementParser.FROM, 0); }
public TerminalNode GRANT() { return getToken(OpenGaussStatementParser.GRANT, 0); }
public TerminalNode GROUP() { return getToken(OpenGaussStatementParser.GROUP, 0); }
public TerminalNode HAVING() { return getToken(OpenGaussStatementParser.HAVING, 0); }
public TerminalNode IN() { return getToken(OpenGaussStatementParser.IN, 0); }
public TerminalNode INITIALLY() { return getToken(OpenGaussStatementParser.INITIALLY, 0); }
public TerminalNode INTERSECT() { return getToken(OpenGaussStatementParser.INTERSECT, 0); }
public TerminalNode INTO() { return getToken(OpenGaussStatementParser.INTO, 0); }
public TerminalNode LATERAL() { return getToken(OpenGaussStatementParser.LATERAL, 0); }
public TerminalNode LEADING() { return getToken(OpenGaussStatementParser.LEADING, 0); }
public TerminalNode LIMIT() { return getToken(OpenGaussStatementParser.LIMIT, 0); }
public TerminalNode LOCALTIME() { return getToken(OpenGaussStatementParser.LOCALTIME, 0); }
public TerminalNode LOCALTIMESTAMP() { return getToken(OpenGaussStatementParser.LOCALTIMESTAMP, 0); }
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public TerminalNode NULL() { return getToken(OpenGaussStatementParser.NULL, 0); }
public TerminalNode OFFSET() { return getToken(OpenGaussStatementParser.OFFSET, 0); }
public TerminalNode ON() { return getToken(OpenGaussStatementParser.ON, 0); }
public TerminalNode ONLY() { return getToken(OpenGaussStatementParser.ONLY, 0); }
public TerminalNode OR() { return getToken(OpenGaussStatementParser.OR, 0); }
public TerminalNode ORDER() { return getToken(OpenGaussStatementParser.ORDER, 0); }
public TerminalNode PLACING() { return getToken(OpenGaussStatementParser.PLACING, 0); }
public TerminalNode PRIMARY() { return getToken(OpenGaussStatementParser.PRIMARY, 0); }
public TerminalNode REFERENCES() { return getToken(OpenGaussStatementParser.REFERENCES, 0); }
public TerminalNode RETURNING() { return getToken(OpenGaussStatementParser.RETURNING, 0); }
public TerminalNode ROW() { return getToken(OpenGaussStatementParser.ROW, 0); }
public TerminalNode SELECT() { return getToken(OpenGaussStatementParser.SELECT, 0); }
public TerminalNode SESSION_USER() { return getToken(OpenGaussStatementParser.SESSION_USER, 0); }
public TerminalNode SOME() { return getToken(OpenGaussStatementParser.SOME, 0); }
public TerminalNode SYMMETRIC() { return getToken(OpenGaussStatementParser.SYMMETRIC, 0); }
public TerminalNode TABLE() { return getToken(OpenGaussStatementParser.TABLE, 0); }
public TerminalNode THEN() { return getToken(OpenGaussStatementParser.THEN, 0); }
public TerminalNode TO() { return getToken(OpenGaussStatementParser.TO, 0); }
public TerminalNode TRAILING() { return getToken(OpenGaussStatementParser.TRAILING, 0); }
public TerminalNode TRUE() { return getToken(OpenGaussStatementParser.TRUE, 0); }
public TerminalNode UNION() { return getToken(OpenGaussStatementParser.UNION, 0); }
public TerminalNode UNIQUE() { return getToken(OpenGaussStatementParser.UNIQUE, 0); }
public TerminalNode USER() { return getToken(OpenGaussStatementParser.USER, 0); }
public TerminalNode USING() { return getToken(OpenGaussStatementParser.USING, 0); }
public TerminalNode VARIADIC() { return getToken(OpenGaussStatementParser.VARIADIC, 0); }
public TerminalNode WHEN() { return getToken(OpenGaussStatementParser.WHEN, 0); }
public TerminalNode WHERE() { return getToken(OpenGaussStatementParser.WHERE, 0); }
public TerminalNode WINDOW() { return getToken(OpenGaussStatementParser.WINDOW, 0); }
public TerminalNode WITH() { return getToken(OpenGaussStatementParser.WITH, 0); }
public ReservedKeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reservedKeyword; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitReservedKeyword(this);
else return visitor.visitChildren(this);
}
}
public final ReservedKeywordContext reservedKeyword() throws RecognitionException {
ReservedKeywordContext _localctx = new ReservedKeywordContext(_ctx, getState());
enterRule(_localctx, 228, RULE_reservedKeyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2775);
_la = _input.LA(1);
if ( !(((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SELECT - 76)) | (1L << (CREATE - 76)) | (1L << (GRANT - 76)) | (1L << (TABLE - 76)) | (1L << (COLUMN - 76)) | (1L << (CONSTRAINT - 76)) | (1L << (PRIMARY - 76)) | (1L << (UNIQUE - 76)) | (1L << (FOREIGN - 76)) | (1L << (INTO - 76)) | (1L << (WITH - 76)) | (1L << (UNION - 76)) | (1L << (DISTINCT - 76)) | (1L << (CASE - 76)) | (1L << (WHEN - 76)) | (1L << (CAST - 76)) | (1L << (FROM - 76)) | (1L << (USING - 76)) | (1L << (WHERE - 76)) | (1L << (AS - 76)) | (1L << (ON - 76)) | (1L << (ELSE - 76)) | (1L << (THEN - 76)) | (1L << (FOR - 76)) | (1L << (TO - 76)) | (1L << (AND - 76)) | (1L << (OR - 76)) | (1L << (NOT - 76)) | (1L << (NULL - 76)) | (1L << (TRUE - 76)) | (1L << (FALSE - 76)))) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & ((1L << (IN - 141)) | (1L << (ALL - 141)) | (1L << (ANY - 141)) | (1L << (ORDER - 141)) | (1L << (GROUP - 141)) | (1L << (ASC - 141)) | (1L << (DESC - 141)) | (1L << (HAVING - 141)) | (1L << (LIMIT - 141)) | (1L << (OFFSET - 141)) | (1L << (ARRAY - 141)) | (1L << (LOCALTIME - 141)) | (1L << (LOCALTIMESTAMP - 141)) | (1L << (DEFAULT - 141)) | (1L << (DO - 141)) | (1L << (CURRENT_USER - 141)))) != 0) || ((((_la - 205)) & ~0x3f) == 0 && ((1L << (_la - 205)) & ((1L << (CURRENT_DATE - 205)) | (1L << (CURRENT_TIME - 205)) | (1L << (CURRENT_TIMESTAMP - 205)) | (1L << (BOTH - 205)) | (1L << (LEADING - 205)) | (1L << (TRAILING - 205)) | (1L << (INTERSECT - 205)) | (1L << (EXCEPT - 205)) | (1L << (FETCH - 205)) | (1L << (WINDOW - 205)) | (1L << (SOME - 205)) | (1L << (END - 205)) | (1L << (ROW - 205)) | (1L << (CHECK - 205)) | (1L << (REFERENCES - 205)) | (1L << (USER - 205)) | (1L << (COLLATE - 205)))) != 0) || ((((_la - 274)) & ~0x3f) == 0 && ((1L << (_la - 274)) & ((1L << (DEFERRABLE - 274)) | (1L << (INITIALLY - 274)) | (1L << (ONLY - 274)) | (1L << (SESSION_USER - 274)))) != 0) || ((((_la - 386)) & ~0x3f) == 0 && ((1L << (_la - 386)) & ((1L << (CURRENT_ROLE - 386)) | (1L << (CURRENT_CATALOG - 386)) | (1L << (SYMMETRIC - 386)) | (1L << (ASYMMETRIC - 386)) | (1L << (VARIADIC - 386)) | (1L << (PLACING - 386)) | (1L << (RETURNING - 386)) | (1L << (LATERAL - 386)) | (1L << (ANALYSE - 386)) | (1L << (ANALYZE - 386)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberLiteralsContext extends ParserRuleContext {
public TerminalNode NUMBER_() { return getToken(OpenGaussStatementParser.NUMBER_, 0); }
public TerminalNode MINUS_() { return getToken(OpenGaussStatementParser.MINUS_, 0); }
public LiteralsTypeContext literalsType() {
return getRuleContext(LiteralsTypeContext.class,0);
}
public NumberLiteralsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numberLiterals; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitNumberLiterals(this);
else return visitor.visitChildren(this);
}
}
public final NumberLiteralsContext numberLiterals() throws RecognitionException {
NumberLiteralsContext _localctx = new NumberLiteralsContext(_ctx, getState());
enterRule(_localctx, 230, RULE_numberLiterals);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2778);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS_) {
{
setState(2777);
match(MINUS_);
}
}
setState(2780);
match(NUMBER_);
setState(2782);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TYPE_CAST_) {
{
setState(2781);
literalsType();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralsTypeContext extends ParserRuleContext {
public TerminalNode TYPE_CAST_() { return getToken(OpenGaussStatementParser.TYPE_CAST_, 0); }
public TerminalNode IDENTIFIER_() { return getToken(OpenGaussStatementParser.IDENTIFIER_, 0); }
public LiteralsTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalsType; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitLiteralsType(this);
else return visitor.visitChildren(this);
}
}
public final LiteralsTypeContext literalsType() throws RecognitionException {
LiteralsTypeContext _localctx = new LiteralsTypeContext(_ctx, getState());
enterRule(_localctx, 232, RULE_literalsType);
try {
enterOuterAlt(_localctx, 1);
{
setState(2784);
match(TYPE_CAST_);
setState(2785);
match(IDENTIFIER_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER_() { return getToken(OpenGaussStatementParser.IDENTIFIER_, 0); }
public TerminalNode UNICODE_ESCAPE() { return getToken(OpenGaussStatementParser.UNICODE_ESCAPE, 0); }
public UescapeContext uescape() {
return getRuleContext(UescapeContext.class,0);
}
public UnreservedWordContext unreservedWord() {
return getRuleContext(UnreservedWordContext.class,0);
}
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 234, RULE_identifier);
int _la;
try {
setState(2795);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNICODE_ESCAPE:
case IDENTIFIER_:
enterOuterAlt(_localctx, 1);
{
setState(2788);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==UNICODE_ESCAPE) {
{
setState(2787);
match(UNICODE_ESCAPE);
}
}
setState(2790);
match(IDENTIFIER_);
setState(2792);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
case 1:
{
setState(2791);
uescape();
}
break;
}
}
break;
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case IF:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case DOUBLE:
case INTERVAL:
case TIME:
case TIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case NAMES:
case TYPE:
case TEXT:
case REPEATABLE:
case VARYING:
case NATIONAL:
case VALUE:
case TIES:
case CUBE:
case SETS:
case OTHERS:
case AT:
case MAXVALUE:
case ADMIN:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case XML:
case JSON:
case ORDINALITY:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
enterOuterAlt(_localctx, 2);
{
setState(2794);
unreservedWord();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UescapeContext extends ParserRuleContext {
public TerminalNode UESCAPE() { return getToken(OpenGaussStatementParser.UESCAPE, 0); }
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public UescapeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_uescape; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitUescape(this);
else return visitor.visitChildren(this);
}
}
public final UescapeContext uescape() throws RecognitionException {
UescapeContext _localctx = new UescapeContext(_ctx, getState());
enterRule(_localctx, 236, RULE_uescape);
try {
enterOuterAlt(_localctx, 1);
{
setState(2797);
match(UESCAPE);
setState(2798);
match(STRING_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnreservedWordContext extends ParserRuleContext {
public TerminalNode ABORT() { return getToken(OpenGaussStatementParser.ABORT, 0); }
public TerminalNode ABSOLUTE() { return getToken(OpenGaussStatementParser.ABSOLUTE, 0); }
public TerminalNode ACCESS() { return getToken(OpenGaussStatementParser.ACCESS, 0); }
public TerminalNode ACTION() { return getToken(OpenGaussStatementParser.ACTION, 0); }
public TerminalNode ADD() { return getToken(OpenGaussStatementParser.ADD, 0); }
public TerminalNode ADMIN() { return getToken(OpenGaussStatementParser.ADMIN, 0); }
public TerminalNode AFTER() { return getToken(OpenGaussStatementParser.AFTER, 0); }
public TerminalNode AGGREGATE() { return getToken(OpenGaussStatementParser.AGGREGATE, 0); }
public TerminalNode ALSO() { return getToken(OpenGaussStatementParser.ALSO, 0); }
public TerminalNode ALTER() { return getToken(OpenGaussStatementParser.ALTER, 0); }
public TerminalNode ALWAYS() { return getToken(OpenGaussStatementParser.ALWAYS, 0); }
public TerminalNode ASSERTION() { return getToken(OpenGaussStatementParser.ASSERTION, 0); }
public TerminalNode ASSIGNMENT() { return getToken(OpenGaussStatementParser.ASSIGNMENT, 0); }
public TerminalNode AT() { return getToken(OpenGaussStatementParser.AT, 0); }
public TerminalNode ATTACH() { return getToken(OpenGaussStatementParser.ATTACH, 0); }
public TerminalNode ATTRIBUTE() { return getToken(OpenGaussStatementParser.ATTRIBUTE, 0); }
public TerminalNode BACKWARD() { return getToken(OpenGaussStatementParser.BACKWARD, 0); }
public TerminalNode BEFORE() { return getToken(OpenGaussStatementParser.BEFORE, 0); }
public TerminalNode BEGIN() { return getToken(OpenGaussStatementParser.BEGIN, 0); }
public TerminalNode BY() { return getToken(OpenGaussStatementParser.BY, 0); }
public TerminalNode BOX() { return getToken(OpenGaussStatementParser.BOX, 0); }
public TerminalNode CACHE() { return getToken(OpenGaussStatementParser.CACHE, 0); }
public TerminalNode CALL() { return getToken(OpenGaussStatementParser.CALL, 0); }
public TerminalNode CALLED() { return getToken(OpenGaussStatementParser.CALLED, 0); }
public TerminalNode CASCADE() { return getToken(OpenGaussStatementParser.CASCADE, 0); }
public TerminalNode CASCADED() { return getToken(OpenGaussStatementParser.CASCADED, 0); }
public TerminalNode CATALOG() { return getToken(OpenGaussStatementParser.CATALOG, 0); }
public TerminalNode CHAIN() { return getToken(OpenGaussStatementParser.CHAIN, 0); }
public TerminalNode CHARACTERISTICS() { return getToken(OpenGaussStatementParser.CHARACTERISTICS, 0); }
public TerminalNode CHECKPOINT() { return getToken(OpenGaussStatementParser.CHECKPOINT, 0); }
public TerminalNode CLASS() { return getToken(OpenGaussStatementParser.CLASS, 0); }
public TerminalNode CLOSE() { return getToken(OpenGaussStatementParser.CLOSE, 0); }
public TerminalNode CLUSTER() { return getToken(OpenGaussStatementParser.CLUSTER, 0); }
public TerminalNode COLUMNS() { return getToken(OpenGaussStatementParser.COLUMNS, 0); }
public TerminalNode COMMENT() { return getToken(OpenGaussStatementParser.COMMENT, 0); }
public TerminalNode COMMENTS() { return getToken(OpenGaussStatementParser.COMMENTS, 0); }
public TerminalNode COMMIT() { return getToken(OpenGaussStatementParser.COMMIT, 0); }
public TerminalNode COMMITTED() { return getToken(OpenGaussStatementParser.COMMITTED, 0); }
public TerminalNode CONFIGURATION() { return getToken(OpenGaussStatementParser.CONFIGURATION, 0); }
public TerminalNode CONFLICT() { return getToken(OpenGaussStatementParser.CONFLICT, 0); }
public TerminalNode CONNECTION() { return getToken(OpenGaussStatementParser.CONNECTION, 0); }
public TerminalNode CONSTRAINTS() { return getToken(OpenGaussStatementParser.CONSTRAINTS, 0); }
public TerminalNode CONTENT() { return getToken(OpenGaussStatementParser.CONTENT, 0); }
public TerminalNode CONTINUE() { return getToken(OpenGaussStatementParser.CONTINUE, 0); }
public TerminalNode CONVERSION() { return getToken(OpenGaussStatementParser.CONVERSION, 0); }
public TerminalNode COPY() { return getToken(OpenGaussStatementParser.COPY, 0); }
public TerminalNode COST() { return getToken(OpenGaussStatementParser.COST, 0); }
public TerminalNode CSV() { return getToken(OpenGaussStatementParser.CSV, 0); }
public TerminalNode CUBE() { return getToken(OpenGaussStatementParser.CUBE, 0); }
public TerminalNode CURRENT() { return getToken(OpenGaussStatementParser.CURRENT, 0); }
public TerminalNode CURSOR() { return getToken(OpenGaussStatementParser.CURSOR, 0); }
public TerminalNode CYCLE() { return getToken(OpenGaussStatementParser.CYCLE, 0); }
public TerminalNode CIRCLE() { return getToken(OpenGaussStatementParser.CIRCLE, 0); }
public TerminalNode DATA() { return getToken(OpenGaussStatementParser.DATA, 0); }
public TerminalNode DATABASE() { return getToken(OpenGaussStatementParser.DATABASE, 0); }
public TerminalNode DAY() { return getToken(OpenGaussStatementParser.DAY, 0); }
public TerminalNode DEALLOCATE() { return getToken(OpenGaussStatementParser.DEALLOCATE, 0); }
public TerminalNode DECLARE() { return getToken(OpenGaussStatementParser.DECLARE, 0); }
public TerminalNode DEFAULTS() { return getToken(OpenGaussStatementParser.DEFAULTS, 0); }
public TerminalNode DEFERRED() { return getToken(OpenGaussStatementParser.DEFERRED, 0); }
public TerminalNode DEFINER() { return getToken(OpenGaussStatementParser.DEFINER, 0); }
public TerminalNode DELETE() { return getToken(OpenGaussStatementParser.DELETE, 0); }
public TerminalNode DELIMITER() { return getToken(OpenGaussStatementParser.DELIMITER, 0); }
public TerminalNode DELIMITERS() { return getToken(OpenGaussStatementParser.DELIMITERS, 0); }
public TerminalNode DEPENDS() { return getToken(OpenGaussStatementParser.DEPENDS, 0); }
public TerminalNode DETACH() { return getToken(OpenGaussStatementParser.DETACH, 0); }
public TerminalNode DICTIONARY() { return getToken(OpenGaussStatementParser.DICTIONARY, 0); }
public TerminalNode DISABLE() { return getToken(OpenGaussStatementParser.DISABLE, 0); }
public TerminalNode DISCARD() { return getToken(OpenGaussStatementParser.DISCARD, 0); }
public TerminalNode DOCUMENT() { return getToken(OpenGaussStatementParser.DOCUMENT, 0); }
public TerminalNode DOMAIN() { return getToken(OpenGaussStatementParser.DOMAIN, 0); }
public TerminalNode DOUBLE() { return getToken(OpenGaussStatementParser.DOUBLE, 0); }
public TerminalNode DROP() { return getToken(OpenGaussStatementParser.DROP, 0); }
public TerminalNode EACH() { return getToken(OpenGaussStatementParser.EACH, 0); }
public TerminalNode ENABLE() { return getToken(OpenGaussStatementParser.ENABLE, 0); }
public TerminalNode ENCODING() { return getToken(OpenGaussStatementParser.ENCODING, 0); }
public TerminalNode ENCRYPTED() { return getToken(OpenGaussStatementParser.ENCRYPTED, 0); }
public TerminalNode ENUM() { return getToken(OpenGaussStatementParser.ENUM, 0); }
public TerminalNode ESCAPE() { return getToken(OpenGaussStatementParser.ESCAPE, 0); }
public TerminalNode EVENT() { return getToken(OpenGaussStatementParser.EVENT, 0); }
public TerminalNode EXCLUDE() { return getToken(OpenGaussStatementParser.EXCLUDE, 0); }
public TerminalNode EXCLUDING() { return getToken(OpenGaussStatementParser.EXCLUDING, 0); }
public TerminalNode EXCLUSIVE() { return getToken(OpenGaussStatementParser.EXCLUSIVE, 0); }
public TerminalNode EXECUTE() { return getToken(OpenGaussStatementParser.EXECUTE, 0); }
public TerminalNode EXPLAIN() { return getToken(OpenGaussStatementParser.EXPLAIN, 0); }
public TerminalNode EXPRESSION() { return getToken(OpenGaussStatementParser.EXPRESSION, 0); }
public TerminalNode EXTENDED() { return getToken(OpenGaussStatementParser.EXTENDED, 0); }
public TerminalNode EXTENSION() { return getToken(OpenGaussStatementParser.EXTENSION, 0); }
public TerminalNode EXTERNAL() { return getToken(OpenGaussStatementParser.EXTERNAL, 0); }
public TerminalNode FAMILY() { return getToken(OpenGaussStatementParser.FAMILY, 0); }
public TerminalNode FILTER() { return getToken(OpenGaussStatementParser.FILTER, 0); }
public TerminalNode FIRST() { return getToken(OpenGaussStatementParser.FIRST, 0); }
public TerminalNode FOLLOWING() { return getToken(OpenGaussStatementParser.FOLLOWING, 0); }
public TerminalNode FORCE() { return getToken(OpenGaussStatementParser.FORCE, 0); }
public TerminalNode FORWARD() { return getToken(OpenGaussStatementParser.FORWARD, 0); }
public TerminalNode FUNCTION() { return getToken(OpenGaussStatementParser.FUNCTION, 0); }
public TerminalNode FUNCTIONS() { return getToken(OpenGaussStatementParser.FUNCTIONS, 0); }
public TerminalNode GENERATED() { return getToken(OpenGaussStatementParser.GENERATED, 0); }
public TerminalNode GLOBAL() { return getToken(OpenGaussStatementParser.GLOBAL, 0); }
public TerminalNode GRANTED() { return getToken(OpenGaussStatementParser.GRANTED, 0); }
public TerminalNode GROUPS() { return getToken(OpenGaussStatementParser.GROUPS, 0); }
public TerminalNode HANDLER() { return getToken(OpenGaussStatementParser.HANDLER, 0); }
public TerminalNode HEADER() { return getToken(OpenGaussStatementParser.HEADER, 0); }
public TerminalNode HOLD() { return getToken(OpenGaussStatementParser.HOLD, 0); }
public TerminalNode HOUR() { return getToken(OpenGaussStatementParser.HOUR, 0); }
public TerminalNode IDENTITY() { return getToken(OpenGaussStatementParser.IDENTITY, 0); }
public TerminalNode IF() { return getToken(OpenGaussStatementParser.IF, 0); }
public TerminalNode IMMEDIATE() { return getToken(OpenGaussStatementParser.IMMEDIATE, 0); }
public TerminalNode IMMUTABLE() { return getToken(OpenGaussStatementParser.IMMUTABLE, 0); }
public TerminalNode IMPLICIT() { return getToken(OpenGaussStatementParser.IMPLICIT, 0); }
public TerminalNode IMPORT() { return getToken(OpenGaussStatementParser.IMPORT, 0); }
public TerminalNode INCLUDE() { return getToken(OpenGaussStatementParser.INCLUDE, 0); }
public TerminalNode INCLUDING() { return getToken(OpenGaussStatementParser.INCLUDING, 0); }
public TerminalNode INCREMENT() { return getToken(OpenGaussStatementParser.INCREMENT, 0); }
public TerminalNode INDEX() { return getToken(OpenGaussStatementParser.INDEX, 0); }
public TerminalNode INDEXES() { return getToken(OpenGaussStatementParser.INDEXES, 0); }
public TerminalNode INHERIT() { return getToken(OpenGaussStatementParser.INHERIT, 0); }
public TerminalNode INHERITS() { return getToken(OpenGaussStatementParser.INHERITS, 0); }
public TerminalNode INLINE() { return getToken(OpenGaussStatementParser.INLINE, 0); }
public TerminalNode INPUT() { return getToken(OpenGaussStatementParser.INPUT, 0); }
public TerminalNode INSENSITIVE() { return getToken(OpenGaussStatementParser.INSENSITIVE, 0); }
public TerminalNode INSERT() { return getToken(OpenGaussStatementParser.INSERT, 0); }
public TerminalNode INSTEAD() { return getToken(OpenGaussStatementParser.INSTEAD, 0); }
public TerminalNode INVOKER() { return getToken(OpenGaussStatementParser.INVOKER, 0); }
public TerminalNode INTERVAL() { return getToken(OpenGaussStatementParser.INTERVAL, 0); }
public TerminalNode ISOLATION() { return getToken(OpenGaussStatementParser.ISOLATION, 0); }
public TerminalNode KEY() { return getToken(OpenGaussStatementParser.KEY, 0); }
public TerminalNode LABEL() { return getToken(OpenGaussStatementParser.LABEL, 0); }
public TerminalNode LANGUAGE() { return getToken(OpenGaussStatementParser.LANGUAGE, 0); }
public TerminalNode LARGE() { return getToken(OpenGaussStatementParser.LARGE, 0); }
public TerminalNode LAST() { return getToken(OpenGaussStatementParser.LAST, 0); }
public TerminalNode LEAKPROOF() { return getToken(OpenGaussStatementParser.LEAKPROOF, 0); }
public TerminalNode LEVEL() { return getToken(OpenGaussStatementParser.LEVEL, 0); }
public TerminalNode LISTEN() { return getToken(OpenGaussStatementParser.LISTEN, 0); }
public TerminalNode LOAD() { return getToken(OpenGaussStatementParser.LOAD, 0); }
public TerminalNode LOCAL() { return getToken(OpenGaussStatementParser.LOCAL, 0); }
public TerminalNode LOCATION() { return getToken(OpenGaussStatementParser.LOCATION, 0); }
public TerminalNode LOCK() { return getToken(OpenGaussStatementParser.LOCK, 0); }
public TerminalNode LOCKED() { return getToken(OpenGaussStatementParser.LOCKED, 0); }
public TerminalNode LOGGED() { return getToken(OpenGaussStatementParser.LOGGED, 0); }
public TerminalNode LSEG() { return getToken(OpenGaussStatementParser.LSEG, 0); }
public TerminalNode MAIN() { return getToken(OpenGaussStatementParser.MAIN, 0); }
public TerminalNode MAPPING() { return getToken(OpenGaussStatementParser.MAPPING, 0); }
public TerminalNode MATCH() { return getToken(OpenGaussStatementParser.MATCH, 0); }
public TerminalNode MATERIALIZED() { return getToken(OpenGaussStatementParser.MATERIALIZED, 0); }
public TerminalNode MAXVALUE() { return getToken(OpenGaussStatementParser.MAXVALUE, 0); }
public TerminalNode METHOD() { return getToken(OpenGaussStatementParser.METHOD, 0); }
public TerminalNode MINUTE() { return getToken(OpenGaussStatementParser.MINUTE, 0); }
public TerminalNode MINVALUE() { return getToken(OpenGaussStatementParser.MINVALUE, 0); }
public TerminalNode MODE() { return getToken(OpenGaussStatementParser.MODE, 0); }
public TerminalNode MONTH() { return getToken(OpenGaussStatementParser.MONTH, 0); }
public TerminalNode MOVE() { return getToken(OpenGaussStatementParser.MOVE, 0); }
public TerminalNode MOD() { return getToken(OpenGaussStatementParser.MOD, 0); }
public TerminalNode NAME() { return getToken(OpenGaussStatementParser.NAME, 0); }
public TerminalNode NAMES() { return getToken(OpenGaussStatementParser.NAMES, 0); }
public TerminalNode NATIONAL() { return getToken(OpenGaussStatementParser.NATIONAL, 0); }
public TerminalNode NEW() { return getToken(OpenGaussStatementParser.NEW, 0); }
public TerminalNode NEXT() { return getToken(OpenGaussStatementParser.NEXT, 0); }
public TerminalNode NFC() { return getToken(OpenGaussStatementParser.NFC, 0); }
public TerminalNode NFD() { return getToken(OpenGaussStatementParser.NFD, 0); }
public TerminalNode NFKC() { return getToken(OpenGaussStatementParser.NFKC, 0); }
public TerminalNode NFKD() { return getToken(OpenGaussStatementParser.NFKD, 0); }
public TerminalNode NO() { return getToken(OpenGaussStatementParser.NO, 0); }
public TerminalNode NORMALIZED() { return getToken(OpenGaussStatementParser.NORMALIZED, 0); }
public TerminalNode NOTHING() { return getToken(OpenGaussStatementParser.NOTHING, 0); }
public TerminalNode NOTIFY() { return getToken(OpenGaussStatementParser.NOTIFY, 0); }
public TerminalNode NOWAIT() { return getToken(OpenGaussStatementParser.NOWAIT, 0); }
public TerminalNode NULLS() { return getToken(OpenGaussStatementParser.NULLS, 0); }
public TerminalNode OBJECT() { return getToken(OpenGaussStatementParser.OBJECT, 0); }
public TerminalNode OF() { return getToken(OpenGaussStatementParser.OF, 0); }
public TerminalNode OFF() { return getToken(OpenGaussStatementParser.OFF, 0); }
public TerminalNode OIDS() { return getToken(OpenGaussStatementParser.OIDS, 0); }
public TerminalNode OLD() { return getToken(OpenGaussStatementParser.OLD, 0); }
public TerminalNode OPERATOR() { return getToken(OpenGaussStatementParser.OPERATOR, 0); }
public TerminalNode OPTION() { return getToken(OpenGaussStatementParser.OPTION, 0); }
public TerminalNode OPTIONS() { return getToken(OpenGaussStatementParser.OPTIONS, 0); }
public TerminalNode ORDINALITY() { return getToken(OpenGaussStatementParser.ORDINALITY, 0); }
public TerminalNode OTHERS() { return getToken(OpenGaussStatementParser.OTHERS, 0); }
public TerminalNode OVER() { return getToken(OpenGaussStatementParser.OVER, 0); }
public TerminalNode OVERRIDING() { return getToken(OpenGaussStatementParser.OVERRIDING, 0); }
public TerminalNode OWNED() { return getToken(OpenGaussStatementParser.OWNED, 0); }
public TerminalNode OWNER() { return getToken(OpenGaussStatementParser.OWNER, 0); }
public TerminalNode PARALLEL() { return getToken(OpenGaussStatementParser.PARALLEL, 0); }
public TerminalNode PARSER() { return getToken(OpenGaussStatementParser.PARSER, 0); }
public TerminalNode PARTIAL() { return getToken(OpenGaussStatementParser.PARTIAL, 0); }
public TerminalNode PARTITION() { return getToken(OpenGaussStatementParser.PARTITION, 0); }
public TerminalNode PASSING() { return getToken(OpenGaussStatementParser.PASSING, 0); }
public TerminalNode PASSWORD() { return getToken(OpenGaussStatementParser.PASSWORD, 0); }
public TerminalNode PATH() { return getToken(OpenGaussStatementParser.PATH, 0); }
public TerminalNode PLAIN() { return getToken(OpenGaussStatementParser.PLAIN, 0); }
public TerminalNode PLANS() { return getToken(OpenGaussStatementParser.PLANS, 0); }
public TerminalNode POLICY() { return getToken(OpenGaussStatementParser.POLICY, 0); }
public TerminalNode POINT() { return getToken(OpenGaussStatementParser.POINT, 0); }
public TerminalNode POLYGON() { return getToken(OpenGaussStatementParser.POLYGON, 0); }
public TerminalNode PRECEDING() { return getToken(OpenGaussStatementParser.PRECEDING, 0); }
public TerminalNode PREPARE() { return getToken(OpenGaussStatementParser.PREPARE, 0); }
public TerminalNode PREPARED() { return getToken(OpenGaussStatementParser.PREPARED, 0); }
public TerminalNode PRESERVE() { return getToken(OpenGaussStatementParser.PRESERVE, 0); }
public TerminalNode PRIOR() { return getToken(OpenGaussStatementParser.PRIOR, 0); }
public TerminalNode PRIVILEGES() { return getToken(OpenGaussStatementParser.PRIVILEGES, 0); }
public TerminalNode PROCEDURAL() { return getToken(OpenGaussStatementParser.PROCEDURAL, 0); }
public TerminalNode PROCEDURE() { return getToken(OpenGaussStatementParser.PROCEDURE, 0); }
public TerminalNode PROCEDURES() { return getToken(OpenGaussStatementParser.PROCEDURES, 0); }
public TerminalNode PROGRAM() { return getToken(OpenGaussStatementParser.PROGRAM, 0); }
public TerminalNode PUBLICATION() { return getToken(OpenGaussStatementParser.PUBLICATION, 0); }
public TerminalNode QUOTE() { return getToken(OpenGaussStatementParser.QUOTE, 0); }
public TerminalNode RANGE() { return getToken(OpenGaussStatementParser.RANGE, 0); }
public TerminalNode READ() { return getToken(OpenGaussStatementParser.READ, 0); }
public TerminalNode REASSIGN() { return getToken(OpenGaussStatementParser.REASSIGN, 0); }
public TerminalNode RECHECK() { return getToken(OpenGaussStatementParser.RECHECK, 0); }
public TerminalNode RECURSIVE() { return getToken(OpenGaussStatementParser.RECURSIVE, 0); }
public TerminalNode REF() { return getToken(OpenGaussStatementParser.REF, 0); }
public TerminalNode REFERENCING() { return getToken(OpenGaussStatementParser.REFERENCING, 0); }
public TerminalNode REFRESH() { return getToken(OpenGaussStatementParser.REFRESH, 0); }
public TerminalNode REINDEX() { return getToken(OpenGaussStatementParser.REINDEX, 0); }
public TerminalNode RELATIVE() { return getToken(OpenGaussStatementParser.RELATIVE, 0); }
public TerminalNode RELEASE() { return getToken(OpenGaussStatementParser.RELEASE, 0); }
public TerminalNode RENAME() { return getToken(OpenGaussStatementParser.RENAME, 0); }
public TerminalNode REPEATABLE() { return getToken(OpenGaussStatementParser.REPEATABLE, 0); }
public TerminalNode REPLACE() { return getToken(OpenGaussStatementParser.REPLACE, 0); }
public TerminalNode REPLICA() { return getToken(OpenGaussStatementParser.REPLICA, 0); }
public TerminalNode RESET() { return getToken(OpenGaussStatementParser.RESET, 0); }
public TerminalNode RESTART() { return getToken(OpenGaussStatementParser.RESTART, 0); }
public TerminalNode RESTRICT() { return getToken(OpenGaussStatementParser.RESTRICT, 0); }
public TerminalNode RETURNS() { return getToken(OpenGaussStatementParser.RETURNS, 0); }
public TerminalNode REVOKE() { return getToken(OpenGaussStatementParser.REVOKE, 0); }
public TerminalNode ROLE() { return getToken(OpenGaussStatementParser.ROLE, 0); }
public TerminalNode ROLLBACK() { return getToken(OpenGaussStatementParser.ROLLBACK, 0); }
public TerminalNode ROLLUP() { return getToken(OpenGaussStatementParser.ROLLUP, 0); }
public TerminalNode ROUTINE() { return getToken(OpenGaussStatementParser.ROUTINE, 0); }
public TerminalNode ROUTINES() { return getToken(OpenGaussStatementParser.ROUTINES, 0); }
public TerminalNode ROWS() { return getToken(OpenGaussStatementParser.ROWS, 0); }
public TerminalNode RULE() { return getToken(OpenGaussStatementParser.RULE, 0); }
public TerminalNode SAVEPOINT() { return getToken(OpenGaussStatementParser.SAVEPOINT, 0); }
public TerminalNode SCHEMA() { return getToken(OpenGaussStatementParser.SCHEMA, 0); }
public TerminalNode SCHEMAS() { return getToken(OpenGaussStatementParser.SCHEMAS, 0); }
public TerminalNode SCROLL() { return getToken(OpenGaussStatementParser.SCROLL, 0); }
public TerminalNode SEARCH() { return getToken(OpenGaussStatementParser.SEARCH, 0); }
public TerminalNode SECOND() { return getToken(OpenGaussStatementParser.SECOND, 0); }
public TerminalNode SECURITY() { return getToken(OpenGaussStatementParser.SECURITY, 0); }
public TerminalNode SEQUENCE() { return getToken(OpenGaussStatementParser.SEQUENCE, 0); }
public TerminalNode SEQUENCES() { return getToken(OpenGaussStatementParser.SEQUENCES, 0); }
public TerminalNode SERIALIZABLE() { return getToken(OpenGaussStatementParser.SERIALIZABLE, 0); }
public TerminalNode SERVER() { return getToken(OpenGaussStatementParser.SERVER, 0); }
public TerminalNode SESSION() { return getToken(OpenGaussStatementParser.SESSION, 0); }
public TerminalNode SET() { return getToken(OpenGaussStatementParser.SET, 0); }
public TerminalNode SETS() { return getToken(OpenGaussStatementParser.SETS, 0); }
public TerminalNode SHARE() { return getToken(OpenGaussStatementParser.SHARE, 0); }
public TerminalNode SHOW() { return getToken(OpenGaussStatementParser.SHOW, 0); }
public TerminalNode SIMPLE() { return getToken(OpenGaussStatementParser.SIMPLE, 0); }
public TerminalNode SNAPSHOT() { return getToken(OpenGaussStatementParser.SNAPSHOT, 0); }
public TerminalNode SQL() { return getToken(OpenGaussStatementParser.SQL, 0); }
public TerminalNode STABLE() { return getToken(OpenGaussStatementParser.STABLE, 0); }
public TerminalNode STANDALONE() { return getToken(OpenGaussStatementParser.STANDALONE, 0); }
public TerminalNode START() { return getToken(OpenGaussStatementParser.START, 0); }
public TerminalNode STATEMENT() { return getToken(OpenGaussStatementParser.STATEMENT, 0); }
public TerminalNode STATISTICS() { return getToken(OpenGaussStatementParser.STATISTICS, 0); }
public TerminalNode STDIN() { return getToken(OpenGaussStatementParser.STDIN, 0); }
public TerminalNode STDOUT() { return getToken(OpenGaussStatementParser.STDOUT, 0); }
public TerminalNode STORAGE() { return getToken(OpenGaussStatementParser.STORAGE, 0); }
public TerminalNode STORED() { return getToken(OpenGaussStatementParser.STORED, 0); }
public TerminalNode STRICT() { return getToken(OpenGaussStatementParser.STRICT, 0); }
public TerminalNode STRIP() { return getToken(OpenGaussStatementParser.STRIP, 0); }
public TerminalNode SUBSCRIPTION() { return getToken(OpenGaussStatementParser.SUBSCRIPTION, 0); }
public TerminalNode SUPPORT() { return getToken(OpenGaussStatementParser.SUPPORT, 0); }
public TerminalNode SYSID() { return getToken(OpenGaussStatementParser.SYSID, 0); }
public TerminalNode SYSTEM() { return getToken(OpenGaussStatementParser.SYSTEM, 0); }
public TerminalNode TABLES() { return getToken(OpenGaussStatementParser.TABLES, 0); }
public TerminalNode TABLESPACE() { return getToken(OpenGaussStatementParser.TABLESPACE, 0); }
public TerminalNode TEMP() { return getToken(OpenGaussStatementParser.TEMP, 0); }
public TerminalNode TEMPLATE() { return getToken(OpenGaussStatementParser.TEMPLATE, 0); }
public TerminalNode TEMPORARY() { return getToken(OpenGaussStatementParser.TEMPORARY, 0); }
public TerminalNode TEXT() { return getToken(OpenGaussStatementParser.TEXT, 0); }
public TerminalNode TIES() { return getToken(OpenGaussStatementParser.TIES, 0); }
public TerminalNode TRANSACTION() { return getToken(OpenGaussStatementParser.TRANSACTION, 0); }
public TerminalNode TRANSFORM() { return getToken(OpenGaussStatementParser.TRANSFORM, 0); }
public TerminalNode TRIGGER() { return getToken(OpenGaussStatementParser.TRIGGER, 0); }
public TerminalNode TRUNCATE() { return getToken(OpenGaussStatementParser.TRUNCATE, 0); }
public TerminalNode TRUSTED() { return getToken(OpenGaussStatementParser.TRUSTED, 0); }
public TerminalNode TYPE() { return getToken(OpenGaussStatementParser.TYPE, 0); }
public TerminalNode TYPES() { return getToken(OpenGaussStatementParser.TYPES, 0); }
public TerminalNode TIME() { return getToken(OpenGaussStatementParser.TIME, 0); }
public TerminalNode TIMESTAMP() { return getToken(OpenGaussStatementParser.TIMESTAMP, 0); }
public TerminalNode UESCAPE() { return getToken(OpenGaussStatementParser.UESCAPE, 0); }
public TerminalNode UNBOUNDED() { return getToken(OpenGaussStatementParser.UNBOUNDED, 0); }
public TerminalNode UNCOMMITTED() { return getToken(OpenGaussStatementParser.UNCOMMITTED, 0); }
public TerminalNode UNENCRYPTED() { return getToken(OpenGaussStatementParser.UNENCRYPTED, 0); }
public TerminalNode UNKNOWN() { return getToken(OpenGaussStatementParser.UNKNOWN, 0); }
public TerminalNode UNLISTEN() { return getToken(OpenGaussStatementParser.UNLISTEN, 0); }
public TerminalNode UNLOGGED() { return getToken(OpenGaussStatementParser.UNLOGGED, 0); }
public TerminalNode UNTIL() { return getToken(OpenGaussStatementParser.UNTIL, 0); }
public TerminalNode UPDATE() { return getToken(OpenGaussStatementParser.UPDATE, 0); }
public TerminalNode VACUUM() { return getToken(OpenGaussStatementParser.VACUUM, 0); }
public TerminalNode VALID() { return getToken(OpenGaussStatementParser.VALID, 0); }
public TerminalNode VALIDATE() { return getToken(OpenGaussStatementParser.VALIDATE, 0); }
public TerminalNode VALIDATOR() { return getToken(OpenGaussStatementParser.VALIDATOR, 0); }
public TerminalNode VALUE() { return getToken(OpenGaussStatementParser.VALUE, 0); }
public TerminalNode VARYING() { return getToken(OpenGaussStatementParser.VARYING, 0); }
public TerminalNode VERSION() { return getToken(OpenGaussStatementParser.VERSION, 0); }
public TerminalNode VIEW() { return getToken(OpenGaussStatementParser.VIEW, 0); }
public TerminalNode VIEWS() { return getToken(OpenGaussStatementParser.VIEWS, 0); }
public TerminalNode VOLATILE() { return getToken(OpenGaussStatementParser.VOLATILE, 0); }
public TerminalNode WHITESPACE() { return getToken(OpenGaussStatementParser.WHITESPACE, 0); }
public TerminalNode WITHIN() { return getToken(OpenGaussStatementParser.WITHIN, 0); }
public TerminalNode WITHOUT() { return getToken(OpenGaussStatementParser.WITHOUT, 0); }
public TerminalNode WORK() { return getToken(OpenGaussStatementParser.WORK, 0); }
public TerminalNode WRAPPER() { return getToken(OpenGaussStatementParser.WRAPPER, 0); }
public TerminalNode WRITE() { return getToken(OpenGaussStatementParser.WRITE, 0); }
public TerminalNode XML() { return getToken(OpenGaussStatementParser.XML, 0); }
public TerminalNode YEAR() { return getToken(OpenGaussStatementParser.YEAR, 0); }
public TerminalNode YES() { return getToken(OpenGaussStatementParser.YES, 0); }
public TerminalNode ZONE() { return getToken(OpenGaussStatementParser.ZONE, 0); }
public TerminalNode JSON() { return getToken(OpenGaussStatementParser.JSON, 0); }
public UnreservedWordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unreservedWord; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitUnreservedWord(this);
else return visitor.visitChildren(this);
}
}
public final UnreservedWordContext unreservedWord() throws RecognitionException {
UnreservedWordContext _localctx = new UnreservedWordContext(_ctx, getState());
enterRule(_localctx, 238, RULE_unreservedWord);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2800);
_la = _input.LA(1);
if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (INSERT - 77)) | (1L << (UPDATE - 77)) | (1L << (DELETE - 77)) | (1L << (ALTER - 77)) | (1L << (DROP - 77)) | (1L << (TRUNCATE - 77)) | (1L << (SCHEMA - 77)) | (1L << (REVOKE - 77)) | (1L << (ADD - 77)) | (1L << (SET - 77)) | (1L << (INDEX - 77)) | (1L << (KEY - 77)) | (1L << (FUNCTION - 77)) | (1L << (TRIGGER - 77)) | (1L << (PROCEDURE - 77)) | (1L << (VIEW - 77)) | (1L << (IF - 77)))) != 0) || ((((_la - 147)) & ~0x3f) == 0 && ((1L << (_la - 147)) & ((1L << (BY - 147)) | (1L << (BEGIN - 147)) | (1L << (COMMIT - 147)) | (1L << (ROLLBACK - 147)) | (1L << (SAVEPOINT - 147)) | (1L << (DOUBLE - 147)) | (1L << (INTERVAL - 147)) | (1L << (TIME - 147)) | (1L << (TIMESTAMP - 147)) | (1L << (YEAR - 147)) | (1L << (MONTH - 147)) | (1L << (DAY - 147)) | (1L << (HOUR - 147)) | (1L << (MINUTE - 147)) | (1L << (SECOND - 147)) | (1L << (CURRENT - 147)) | (1L << (ENABLE - 147)) | (1L << (DISABLE - 147)) | (1L << (CALL - 147)) | (1L << (PRESERVE - 147)) | (1L << (DEFINER - 147)) | (1L << (SQL - 147)) | (1L << (CASCADED - 147)) | (1L << (LOCAL - 147)) | (1L << (CLOSE - 147)) | (1L << (NEXT - 147)) | (1L << (NAME - 147)) | (1L << (NAMES - 147)) | (1L << (TYPE - 147)) | (1L << (TEXT - 147)) | (1L << (REPEATABLE - 147)) | (1L << (VARYING - 147)) | (1L << (NATIONAL - 147)))) != 0) || ((((_la - 212)) & ~0x3f) == 0 && ((1L << (_la - 212)) & ((1L << (VALUE - 212)) | (1L << (TIES - 212)) | (1L << (CUBE - 212)) | (1L << (SETS - 212)) | (1L << (OTHERS - 212)) | (1L << (AT - 212)) | (1L << (MAXVALUE - 212)) | (1L << (ADMIN - 212)) | (1L << (ESCAPE - 212)) | (1L << (EXCLUDE - 212)) | (1L << (MOD - 212)) | (1L << (PARTITION - 212)) | (1L << (UNKNOWN - 212)) | (1L << (ALWAYS - 212)) | (1L << (CASCADE - 212)) | (1L << (GENERATED - 212)) | (1L << (ISOLATION - 212)) | (1L << (LEVEL - 212)) | (1L << (NO - 212)) | (1L << (OPTION - 212)) | (1L << (PRIVILEGES - 212)) | (1L << (READ - 212)) | (1L << (ROLE - 212)) | (1L << (ROWS - 212)) | (1L << (START - 212)) | (1L << (TRANSACTION - 212)) | (1L << (ACTION - 212)) | (1L << (CACHE - 212)) | (1L << (CHARACTERISTICS - 212)) | (1L << (CLUSTER - 212)) | (1L << (COMMENTS - 212)) | (1L << (CONSTRAINTS - 212)) | (1L << (CYCLE - 212)) | (1L << (DATA - 212)) | (1L << (DATABASE - 212)) | (1L << (DEFAULTS - 212)) | (1L << (DEFERRED - 212)))) != 0) || ((((_la - 276)) & ~0x3f) == 0 && ((1L << (_la - 276)) & ((1L << (DEPENDS - 276)) | (1L << (DOMAIN - 276)) | (1L << (EXCLUDING - 276)) | (1L << (EXECUTE - 276)) | (1L << (EXTENDED - 276)) | (1L << (EXTENSION - 276)) | (1L << (EXTERNAL - 276)) | (1L << (FILTER - 276)) | (1L << (FIRST - 276)) | (1L << (FOLLOWING - 276)) | (1L << (FORCE - 276)) | (1L << (GLOBAL - 276)) | (1L << (IDENTITY - 276)) | (1L << (IMMEDIATE - 276)) | (1L << (INCLUDING - 276)) | (1L << (INCREMENT - 276)) | (1L << (INDEXES - 276)) | (1L << (INHERIT - 276)) | (1L << (INHERITS - 276)) | (1L << (INCLUDE - 276)) | (1L << (LANGUAGE - 276)) | (1L << (LARGE - 276)) | (1L << (LAST - 276)) | (1L << (LOGGED - 276)) | (1L << (MAIN - 276)) | (1L << (MATCH - 276)) | (1L << (MINVALUE - 276)) | (1L << (NOTHING - 276)) | (1L << (NULLS - 276)) | (1L << (OBJECT - 276)) | (1L << (OIDS - 276)) | (1L << (OVER - 276)) | (1L << (OWNED - 276)) | (1L << (OWNER - 276)) | (1L << (PARTIAL - 276)) | (1L << (PLAIN - 276)) | (1L << (PRECEDING - 276)) | (1L << (RANGE - 276)) | (1L << (RENAME - 276)) | (1L << (REPLICA - 276)) | (1L << (RESET - 276)) | (1L << (RESTART - 276)) | (1L << (RESTRICT - 276)) | (1L << (ROUTINE - 276)) | (1L << (RULE - 276)) | (1L << (SECURITY - 276)) | (1L << (SEQUENCE - 276)) | (1L << (SESSION - 276)) | (1L << (SHOW - 276)) | (1L << (SIMPLE - 276)) | (1L << (STATISTICS - 276)) | (1L << (STORAGE - 276)) | (1L << (TABLESPACE - 276)) | (1L << (TEMP - 276)) | (1L << (TEMPORARY - 276)) | (1L << (UNBOUNDED - 276)) | (1L << (UNLOGGED - 276)) | (1L << (VALID - 276)))) != 0) || ((((_la - 340)) & ~0x3f) == 0 && ((1L << (_la - 340)) & ((1L << (VALIDATE - 340)) | (1L << (WITHIN - 340)) | (1L << (WITHOUT - 340)) | (1L << (ZONE - 340)) | (1L << (OF - 340)) | (1L << (UESCAPE - 340)) | (1L << (GROUPS - 340)) | (1L << (RECURSIVE - 340)) | (1L << (ENUM - 340)) | (1L << (POINT - 340)) | (1L << (LSEG - 340)) | (1L << (BOX - 340)) | (1L << (PATH - 340)) | (1L << (POLYGON - 340)) | (1L << (CIRCLE - 340)) | (1L << (XML - 340)) | (1L << (JSON - 340)) | (1L << (ORDINALITY - 340)) | (1L << (NFC - 340)) | (1L << (NFD - 340)) | (1L << (NFKC - 340)))) != 0) || ((((_la - 404)) & ~0x3f) == 0 && ((1L << (_la - 404)) & ((1L << (NFKD - 404)) | (1L << (REF - 404)) | (1L << (PASSING - 404)) | (1L << (VERSION - 404)) | (1L << (YES - 404)) | (1L << (STANDALONE - 404)) | (1L << (MATERIALIZED - 404)) | (1L << (OPERATOR - 404)) | (1L << (SHARE - 404)) | (1L << (ROLLUP - 404)) | (1L << (DOCUMENT - 404)) | (1L << (NORMALIZED - 404)) | (1L << (NOWAIT - 404)) | (1L << (LOCKED - 404)) | (1L << (COLUMNS - 404)) | (1L << (CONTENT - 404)) | (1L << (STRIP - 404)) | (1L << (WHITESPACE - 404)) | (1L << (CONFLICT - 404)) | (1L << (OVERRIDING - 404)) | (1L << (SYSTEM - 404)) | (1L << (ABORT - 404)) | (1L << (ABSOLUTE - 404)) | (1L << (ACCESS - 404)) | (1L << (AFTER - 404)) | (1L << (AGGREGATE - 404)) | (1L << (ALSO - 404)) | (1L << (ATTACH - 404)) | (1L << (ATTRIBUTE - 404)) | (1L << (BACKWARD - 404)) | (1L << (BEFORE - 404)) | (1L << (ASSERTION - 404)) | (1L << (ASSIGNMENT - 404)) | (1L << (CONTINUE - 404)) | (1L << (CONVERSION - 404)) | (1L << (COPY - 404)) | (1L << (COST - 404)) | (1L << (CSV - 404)) | (1L << (CALLED - 404)) | (1L << (CATALOG - 404)) | (1L << (CHAIN - 404)) | (1L << (CHECKPOINT - 404)) | (1L << (CLASS - 404)) | (1L << (CONFIGURATION - 404)) | (1L << (COMMENT - 404)) | (1L << (DETACH - 404)))) != 0) || ((((_la - 468)) & ~0x3f) == 0 && ((1L << (_la - 468)) & ((1L << (DICTIONARY - 468)) | (1L << (EXPRESSION - 468)) | (1L << (INSENSITIVE - 468)) | (1L << (DISCARD - 468)) | (1L << (OFF - 468)) | (1L << (INSTEAD - 468)) | (1L << (EXPLAIN - 468)) | (1L << (INPUT - 468)) | (1L << (INLINE - 468)) | (1L << (PARALLEL - 468)) | (1L << (LEAKPROOF - 468)) | (1L << (COMMITTED - 468)) | (1L << (ENCODING - 468)) | (1L << (IMPLICIT - 468)) | (1L << (DELIMITER - 468)) | (1L << (CURSOR - 468)) | (1L << (EACH - 468)) | (1L << (EVENT - 468)) | (1L << (DEALLOCATE - 468)) | (1L << (CONNECTION - 468)) | (1L << (DECLARE - 468)) | (1L << (FAMILY - 468)) | (1L << (FORWARD - 468)) | (1L << (EXCLUSIVE - 468)) | (1L << (FUNCTIONS - 468)) | (1L << (LOCATION - 468)) | (1L << (LABEL - 468)) | (1L << (DELIMITERS - 468)) | (1L << (HANDLER - 468)) | (1L << (HEADER - 468)) | (1L << (IMMUTABLE - 468)) | (1L << (GRANTED - 468)) | (1L << (HOLD - 468)) | (1L << (MAPPING - 468)) | (1L << (OLD - 468)) | (1L << (METHOD - 468)) | (1L << (LOAD - 468)) | (1L << (LISTEN - 468)) | (1L << (MODE - 468)) | (1L << (MOVE - 468)) | (1L << (PROCEDURAL - 468)) | (1L << (PARSER - 468)) | (1L << (PROCEDURES - 468)) | (1L << (ENCRYPTED - 468)) | (1L << (PUBLICATION - 468)) | (1L << (PROGRAM - 468)) | (1L << (REFERENCING - 468)) | (1L << (PLANS - 468)) | (1L << (REINDEX - 468)) | (1L << (PRIOR - 468)) | (1L << (PASSWORD - 468)) | (1L << (RELATIVE - 468)) | (1L << (QUOTE - 468)) | (1L << (ROUTINES - 468)) | (1L << (REPLACE - 468)) | (1L << (SNAPSHOT - 468)) | (1L << (REFRESH - 468)) | (1L << (PREPARE - 468)) | (1L << (OPTIONS - 468)) | (1L << (IMPORT - 468)) | (1L << (INVOKER - 468)) | (1L << (NEW - 468)) | (1L << (PREPARED - 468)))) != 0) || ((((_la - 532)) & ~0x3f) == 0 && ((1L << (_la - 532)) & ((1L << (SCROLL - 532)) | (1L << (SEQUENCES - 532)) | (1L << (SYSID - 532)) | (1L << (REASSIGN - 532)) | (1L << (SERVER - 532)) | (1L << (SUBSCRIPTION - 532)) | (1L << (SEARCH - 532)) | (1L << (SCHEMAS - 532)) | (1L << (RECHECK - 532)) | (1L << (POLICY - 532)) | (1L << (NOTIFY - 532)) | (1L << (LOCK - 532)) | (1L << (RELEASE - 532)) | (1L << (SERIALIZABLE - 532)) | (1L << (RETURNS - 532)) | (1L << (STATEMENT - 532)) | (1L << (STDIN - 532)) | (1L << (STDOUT - 532)) | (1L << (TABLES - 532)) | (1L << (SUPPORT - 532)) | (1L << (STABLE - 532)) | (1L << (TEMPLATE - 532)) | (1L << (UNENCRYPTED - 532)) | (1L << (VIEWS - 532)) | (1L << (UNCOMMITTED - 532)) | (1L << (TRANSFORM - 532)) | (1L << (UNLISTEN - 532)) | (1L << (TRUSTED - 532)) | (1L << (VALIDATOR - 532)) | (1L << (UNTIL - 532)) | (1L << (VACUUM - 532)) | (1L << (VOLATILE - 532)) | (1L << (STORED - 532)) | (1L << (WRITE - 532)) | (1L << (STRICT - 532)) | (1L << (TYPES - 532)) | (1L << (WRAPPER - 532)) | (1L << (WORK - 532)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeFuncNameKeywordContext extends ParserRuleContext {
public TerminalNode AUTHORIZATION() { return getToken(OpenGaussStatementParser.AUTHORIZATION, 0); }
public TerminalNode BINARY() { return getToken(OpenGaussStatementParser.BINARY, 0); }
public TerminalNode COLLATION() { return getToken(OpenGaussStatementParser.COLLATION, 0); }
public TerminalNode CONCURRENTLY() { return getToken(OpenGaussStatementParser.CONCURRENTLY, 0); }
public TerminalNode CROSS() { return getToken(OpenGaussStatementParser.CROSS, 0); }
public TerminalNode CURRENT_SCHEMA() { return getToken(OpenGaussStatementParser.CURRENT_SCHEMA, 0); }
public TerminalNode FREEZE() { return getToken(OpenGaussStatementParser.FREEZE, 0); }
public TerminalNode FULL() { return getToken(OpenGaussStatementParser.FULL, 0); }
public TerminalNode ILIKE() { return getToken(OpenGaussStatementParser.ILIKE, 0); }
public TerminalNode INNER() { return getToken(OpenGaussStatementParser.INNER, 0); }
public TerminalNode IS() { return getToken(OpenGaussStatementParser.IS, 0); }
public TerminalNode ISNULL() { return getToken(OpenGaussStatementParser.ISNULL, 0); }
public TerminalNode JOIN() { return getToken(OpenGaussStatementParser.JOIN, 0); }
public TerminalNode LEFT() { return getToken(OpenGaussStatementParser.LEFT, 0); }
public TerminalNode LIKE() { return getToken(OpenGaussStatementParser.LIKE, 0); }
public TerminalNode NATURAL() { return getToken(OpenGaussStatementParser.NATURAL, 0); }
public TerminalNode NOTNULL() { return getToken(OpenGaussStatementParser.NOTNULL, 0); }
public TerminalNode OUTER() { return getToken(OpenGaussStatementParser.OUTER, 0); }
public TerminalNode OVERLAPS() { return getToken(OpenGaussStatementParser.OVERLAPS, 0); }
public TerminalNode RIGHT() { return getToken(OpenGaussStatementParser.RIGHT, 0); }
public TerminalNode SIMILAR() { return getToken(OpenGaussStatementParser.SIMILAR, 0); }
public TerminalNode TABLESAMPLE() { return getToken(OpenGaussStatementParser.TABLESAMPLE, 0); }
public TerminalNode VERBOSE() { return getToken(OpenGaussStatementParser.VERBOSE, 0); }
public TypeFuncNameKeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeFuncNameKeyword; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitTypeFuncNameKeyword(this);
else return visitor.visitChildren(this);
}
}
public final TypeFuncNameKeywordContext typeFuncNameKeyword() throws RecognitionException {
TypeFuncNameKeywordContext _localctx = new TypeFuncNameKeywordContext(_ctx, getState());
enterRule(_localctx, 240, RULE_typeFuncNameKeyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2802);
_la = _input.LA(1);
if ( !(((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & ((1L << (NATURAL - 115)) | (1L << (JOIN - 115)) | (1L << (FULL - 115)) | (1L << (INNER - 115)) | (1L << (OUTER - 115)) | (1L << (LEFT - 115)) | (1L << (RIGHT - 115)) | (1L << (CROSS - 115)) | (1L << (IS - 115)) | (1L << (LIKE - 115)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (COLLATION - 194)) | (1L << (OVERLAPS - 194)) | (1L << (BINARY - 194)))) != 0) || _la==CONCURRENTLY || ((((_la - 384)) & ~0x3f) == 0 && ((1L << (_la - 384)) & ((1L << (TABLESAMPLE - 384)) | (1L << (CURRENT_SCHEMA - 384)) | (1L << (ILIKE - 384)) | (1L << (SIMILAR - 384)) | (1L << (ISNULL - 384)) | (1L << (NOTNULL - 384)))) != 0) || ((((_la - 570)) & ~0x3f) == 0 && ((1L << (_la - 570)) & ((1L << (FREEZE - 570)) | (1L << (AUTHORIZATION - 570)) | (1L << (VERBOSE - 570)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SchemaNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SchemaNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_schemaName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSchemaName(this);
else return visitor.visitChildren(this);
}
}
public final SchemaNameContext schemaName() throws RecognitionException {
SchemaNameContext _localctx = new SchemaNameContext(_ctx, getState());
enterRule(_localctx, 242, RULE_schemaName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2804);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SynonymNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SynonymNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_synonymName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSynonymName(this);
else return visitor.visitChildren(this);
}
}
public final SynonymNameContext synonymName() throws RecognitionException {
SynonymNameContext _localctx = new SynonymNameContext(_ctx, getState());
enterRule(_localctx, 244, RULE_synonymName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2806);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OwnerContext owner() {
return getRuleContext(OwnerContext.class,0);
}
public TerminalNode DOT_() { return getToken(OpenGaussStatementParser.DOT_, 0); }
public ObjectNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitObjectName(this);
else return visitor.visitChildren(this);
}
}
public final ObjectNameContext objectName() throws RecognitionException {
ObjectNameContext _localctx = new ObjectNameContext(_ctx, getState());
enterRule(_localctx, 246, RULE_objectName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2811);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
{
setState(2808);
owner();
setState(2809);
match(DOT_);
}
break;
}
setState(2813);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TableNameContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public OwnerContext owner() {
return getRuleContext(OwnerContext.class,0);
}
public TerminalNode DOT_() { return getToken(OpenGaussStatementParser.DOT_, 0); }
public TableNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitTableName(this);
else return visitor.visitChildren(this);
}
}
public final TableNameContext tableName() throws RecognitionException {
TableNameContext _localctx = new TableNameContext(_ctx, getState());
enterRule(_localctx, 248, RULE_tableName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2818);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
{
setState(2815);
owner();
setState(2816);
match(DOT_);
}
break;
}
setState(2820);
name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ColumnNameContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public OwnerContext owner() {
return getRuleContext(OwnerContext.class,0);
}
public TerminalNode DOT_() { return getToken(OpenGaussStatementParser.DOT_, 0); }
public ColumnNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitColumnName(this);
else return visitor.visitChildren(this);
}
}
public final ColumnNameContext columnName() throws RecognitionException {
ColumnNameContext _localctx = new ColumnNameContext(_ctx, getState());
enterRule(_localctx, 250, RULE_columnName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2825);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
setState(2822);
owner();
setState(2823);
match(DOT_);
}
break;
}
setState(2827);
name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OwnerContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OwnerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_owner; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOwner(this);
else return visitor.visitChildren(this);
}
}
public final OwnerContext owner() throws RecognitionException {
OwnerContext _localctx = new OwnerContext(_ctx, getState());
enterRule(_localctx, 252, RULE_owner);
try {
enterOuterAlt(_localctx, 1);
{
setState(2829);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public NameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_name; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitName(this);
else return visitor.visitChildren(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 254, RULE_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(2831);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TableNamesContext extends ParserRuleContext {
public List tableName() {
return getRuleContexts(TableNameContext.class);
}
public TableNameContext tableName(int i) {
return getRuleContext(TableNameContext.class,i);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TableNamesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableNames; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitTableNames(this);
else return visitor.visitChildren(this);
}
}
public final TableNamesContext tableNames() throws RecognitionException {
TableNamesContext _localctx = new TableNamesContext(_ctx, getState());
enterRule(_localctx, 256, RULE_tableNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2834);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP_) {
{
setState(2833);
match(LP_);
}
}
setState(2836);
tableName();
setState(2841);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2837);
match(COMMA_);
setState(2838);
tableName();
}
}
setState(2843);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2845);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RP_) {
{
setState(2844);
match(RP_);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ColumnNamesContext extends ParserRuleContext {
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public List columnName() {
return getRuleContexts(ColumnNameContext.class);
}
public ColumnNameContext columnName(int i) {
return getRuleContext(ColumnNameContext.class,i);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public ColumnNamesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnNames; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitColumnNames(this);
else return visitor.visitChildren(this);
}
}
public final ColumnNamesContext columnNames() throws RecognitionException {
ColumnNamesContext _localctx = new ColumnNamesContext(_ctx, getState());
enterRule(_localctx, 258, RULE_columnNames);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2847);
match(LP_);
setState(2848);
columnName();
setState(2853);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA_) {
{
{
setState(2849);
match(COMMA_);
setState(2850);
columnName();
}
}
setState(2855);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2856);
match(RP_);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CollationNameContext extends ParserRuleContext {
public TerminalNode STRING_() { return getToken(OpenGaussStatementParser.STRING_, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CollationNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collationName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCollationName(this);
else return visitor.visitChildren(this);
}
}
public final CollationNameContext collationName() throws RecognitionException {
CollationNameContext _localctx = new CollationNameContext(_ctx, getState());
enterRule(_localctx, 260, RULE_collationName);
try {
setState(2860);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_:
enterOuterAlt(_localctx, 1);
{
setState(2858);
match(STRING_);
}
break;
case UNICODE_ESCAPE:
case INSERT:
case UPDATE:
case DELETE:
case ALTER:
case DROP:
case TRUNCATE:
case SCHEMA:
case REVOKE:
case ADD:
case SET:
case INDEX:
case KEY:
case FUNCTION:
case TRIGGER:
case PROCEDURE:
case VIEW:
case IF:
case BY:
case BEGIN:
case COMMIT:
case ROLLBACK:
case SAVEPOINT:
case DOUBLE:
case INTERVAL:
case TIME:
case TIMESTAMP:
case YEAR:
case MONTH:
case DAY:
case HOUR:
case MINUTE:
case SECOND:
case CURRENT:
case ENABLE:
case DISABLE:
case CALL:
case PRESERVE:
case DEFINER:
case SQL:
case CASCADED:
case LOCAL:
case CLOSE:
case NEXT:
case NAME:
case NAMES:
case TYPE:
case TEXT:
case REPEATABLE:
case VARYING:
case NATIONAL:
case VALUE:
case TIES:
case CUBE:
case SETS:
case OTHERS:
case AT:
case MAXVALUE:
case ADMIN:
case ESCAPE:
case EXCLUDE:
case MOD:
case PARTITION:
case UNKNOWN:
case ALWAYS:
case CASCADE:
case GENERATED:
case ISOLATION:
case LEVEL:
case NO:
case OPTION:
case PRIVILEGES:
case READ:
case ROLE:
case ROWS:
case START:
case TRANSACTION:
case ACTION:
case CACHE:
case CHARACTERISTICS:
case CLUSTER:
case COMMENTS:
case CONSTRAINTS:
case CYCLE:
case DATA:
case DATABASE:
case DEFAULTS:
case DEFERRED:
case DEPENDS:
case DOMAIN:
case EXCLUDING:
case EXECUTE:
case EXTENDED:
case EXTENSION:
case EXTERNAL:
case FILTER:
case FIRST:
case FOLLOWING:
case FORCE:
case GLOBAL:
case IDENTITY:
case IMMEDIATE:
case INCLUDING:
case INCREMENT:
case INDEXES:
case INHERIT:
case INHERITS:
case INCLUDE:
case LANGUAGE:
case LARGE:
case LAST:
case LOGGED:
case MAIN:
case MATCH:
case MINVALUE:
case NOTHING:
case NULLS:
case OBJECT:
case OIDS:
case OVER:
case OWNED:
case OWNER:
case PARTIAL:
case PLAIN:
case PRECEDING:
case RANGE:
case RENAME:
case REPLICA:
case RESET:
case RESTART:
case RESTRICT:
case ROUTINE:
case RULE:
case SECURITY:
case SEQUENCE:
case SESSION:
case SHOW:
case SIMPLE:
case STATISTICS:
case STORAGE:
case TABLESPACE:
case TEMP:
case TEMPORARY:
case UNBOUNDED:
case UNLOGGED:
case VALID:
case VALIDATE:
case WITHIN:
case WITHOUT:
case ZONE:
case OF:
case UESCAPE:
case GROUPS:
case RECURSIVE:
case ENUM:
case POINT:
case LSEG:
case BOX:
case PATH:
case POLYGON:
case CIRCLE:
case XML:
case JSON:
case ORDINALITY:
case NFC:
case NFD:
case NFKC:
case NFKD:
case REF:
case PASSING:
case VERSION:
case YES:
case STANDALONE:
case MATERIALIZED:
case OPERATOR:
case SHARE:
case ROLLUP:
case DOCUMENT:
case NORMALIZED:
case NOWAIT:
case LOCKED:
case COLUMNS:
case CONTENT:
case STRIP:
case WHITESPACE:
case CONFLICT:
case OVERRIDING:
case SYSTEM:
case ABORT:
case ABSOLUTE:
case ACCESS:
case AFTER:
case AGGREGATE:
case ALSO:
case ATTACH:
case ATTRIBUTE:
case BACKWARD:
case BEFORE:
case ASSERTION:
case ASSIGNMENT:
case CONTINUE:
case CONVERSION:
case COPY:
case COST:
case CSV:
case CALLED:
case CATALOG:
case CHAIN:
case CHECKPOINT:
case CLASS:
case CONFIGURATION:
case COMMENT:
case DETACH:
case DICTIONARY:
case EXPRESSION:
case INSENSITIVE:
case DISCARD:
case OFF:
case INSTEAD:
case EXPLAIN:
case INPUT:
case INLINE:
case PARALLEL:
case LEAKPROOF:
case COMMITTED:
case ENCODING:
case IMPLICIT:
case DELIMITER:
case CURSOR:
case EACH:
case EVENT:
case DEALLOCATE:
case CONNECTION:
case DECLARE:
case FAMILY:
case FORWARD:
case EXCLUSIVE:
case FUNCTIONS:
case LOCATION:
case LABEL:
case DELIMITERS:
case HANDLER:
case HEADER:
case IMMUTABLE:
case GRANTED:
case HOLD:
case MAPPING:
case OLD:
case METHOD:
case LOAD:
case LISTEN:
case MODE:
case MOVE:
case PROCEDURAL:
case PARSER:
case PROCEDURES:
case ENCRYPTED:
case PUBLICATION:
case PROGRAM:
case REFERENCING:
case PLANS:
case REINDEX:
case PRIOR:
case PASSWORD:
case RELATIVE:
case QUOTE:
case ROUTINES:
case REPLACE:
case SNAPSHOT:
case REFRESH:
case PREPARE:
case OPTIONS:
case IMPORT:
case INVOKER:
case NEW:
case PREPARED:
case SCROLL:
case SEQUENCES:
case SYSID:
case REASSIGN:
case SERVER:
case SUBSCRIPTION:
case SEARCH:
case SCHEMAS:
case RECHECK:
case POLICY:
case NOTIFY:
case LOCK:
case RELEASE:
case SERIALIZABLE:
case RETURNS:
case STATEMENT:
case STDIN:
case STDOUT:
case TABLES:
case SUPPORT:
case STABLE:
case TEMPLATE:
case UNENCRYPTED:
case VIEWS:
case UNCOMMITTED:
case TRANSFORM:
case UNLISTEN:
case TRUSTED:
case VALIDATOR:
case UNTIL:
case VACUUM:
case VOLATILE:
case STORED:
case WRITE:
case STRICT:
case TYPES:
case WRAPPER:
case WORK:
case IDENTIFIER_:
enterOuterAlt(_localctx, 2);
{
setState(2859);
identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IndexNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public IndexNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitIndexName(this);
else return visitor.visitChildren(this);
}
}
public final IndexNameContext indexName() throws RecognitionException {
IndexNameContext _localctx = new IndexNameContext(_ctx, getState());
enterRule(_localctx, 262, RULE_indexName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2862);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ConstraintNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraintName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitConstraintName(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintNameContext constraintName() throws RecognitionException {
ConstraintNameContext _localctx = new ConstraintNameContext(_ctx, getState());
enterRule(_localctx, 264, RULE_constraintName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2864);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryKeyContext extends ParserRuleContext {
public TerminalNode KEY() { return getToken(OpenGaussStatementParser.KEY, 0); }
public TerminalNode PRIMARY() { return getToken(OpenGaussStatementParser.PRIMARY, 0); }
public PrimaryKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryKey; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitPrimaryKey(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryKeyContext primaryKey() throws RecognitionException {
PrimaryKeyContext _localctx = new PrimaryKeyContext(_ctx, getState());
enterRule(_localctx, 266, RULE_primaryKey);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2867);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PRIMARY) {
{
setState(2866);
match(PRIMARY);
}
}
setState(2869);
match(KEY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndOperatorContext extends ParserRuleContext {
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode AND_() { return getToken(OpenGaussStatementParser.AND_, 0); }
public AndOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andOperator; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitAndOperator(this);
else return visitor.visitChildren(this);
}
}
public final AndOperatorContext andOperator() throws RecognitionException {
AndOperatorContext _localctx = new AndOperatorContext(_ctx, getState());
enterRule(_localctx, 268, RULE_andOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2871);
_la = _input.LA(1);
if ( !(_la==AND_ || _la==AND) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrOperatorContext extends ParserRuleContext {
public TerminalNode OR() { return getToken(OpenGaussStatementParser.OR, 0); }
public TerminalNode OR_() { return getToken(OpenGaussStatementParser.OR_, 0); }
public OrOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orOperator; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOrOperator(this);
else return visitor.visitChildren(this);
}
}
public final OrOperatorContext orOperator() throws RecognitionException {
OrOperatorContext _localctx = new OrOperatorContext(_ctx, getState());
enterRule(_localctx, 270, RULE_orOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2873);
_la = _input.LA(1);
if ( !(_la==OR_ || _la==OR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ComparisonOperatorContext extends ParserRuleContext {
public TerminalNode EQ_() { return getToken(OpenGaussStatementParser.EQ_, 0); }
public TerminalNode GTE_() { return getToken(OpenGaussStatementParser.GTE_, 0); }
public TerminalNode GT_() { return getToken(OpenGaussStatementParser.GT_, 0); }
public TerminalNode LTE_() { return getToken(OpenGaussStatementParser.LTE_, 0); }
public TerminalNode LT_() { return getToken(OpenGaussStatementParser.LT_, 0); }
public TerminalNode NEQ_() { return getToken(OpenGaussStatementParser.NEQ_, 0); }
public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonOperator; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitComparisonOperator(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
enterRule(_localctx, 272, RULE_comparisonOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2875);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ_) | (1L << NEQ_) | (1L << GT_) | (1L << GTE_) | (1L << LT_) | (1L << LTE_))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternMatchingOperatorContext extends ParserRuleContext {
public TerminalNode LIKE() { return getToken(OpenGaussStatementParser.LIKE, 0); }
public TerminalNode TILDE_TILDE_() { return getToken(OpenGaussStatementParser.TILDE_TILDE_, 0); }
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public TerminalNode NOT_TILDE_TILDE_() { return getToken(OpenGaussStatementParser.NOT_TILDE_TILDE_, 0); }
public TerminalNode ILIKE() { return getToken(OpenGaussStatementParser.ILIKE, 0); }
public TerminalNode ILIKE_() { return getToken(OpenGaussStatementParser.ILIKE_, 0); }
public TerminalNode NOT_ILIKE_() { return getToken(OpenGaussStatementParser.NOT_ILIKE_, 0); }
public TerminalNode SIMILAR() { return getToken(OpenGaussStatementParser.SIMILAR, 0); }
public TerminalNode TO() { return getToken(OpenGaussStatementParser.TO, 0); }
public TerminalNode TILDE_() { return getToken(OpenGaussStatementParser.TILDE_, 0); }
public TerminalNode NOT_() { return getToken(OpenGaussStatementParser.NOT_, 0); }
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public PatternMatchingOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternMatchingOperator; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitPatternMatchingOperator(this);
else return visitor.visitChildren(this);
}
}
public final PatternMatchingOperatorContext patternMatchingOperator() throws RecognitionException {
PatternMatchingOperatorContext _localctx = new PatternMatchingOperatorContext(_ctx, getState());
enterRule(_localctx, 274, RULE_patternMatchingOperator);
try {
setState(2900);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2877);
match(LIKE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2878);
match(TILDE_TILDE_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2879);
match(NOT);
setState(2880);
match(LIKE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2881);
match(NOT_TILDE_TILDE_);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2882);
match(ILIKE);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2883);
match(ILIKE_);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2884);
match(NOT);
setState(2885);
match(ILIKE);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2886);
match(NOT_ILIKE_);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2887);
match(SIMILAR);
setState(2888);
match(TO);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2889);
match(NOT);
setState(2890);
match(SIMILAR);
setState(2891);
match(TO);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2892);
match(TILDE_);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2893);
match(NOT_);
setState(2894);
match(TILDE_);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2895);
match(TILDE_);
setState(2896);
match(ASTERISK_);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(2897);
match(NOT_);
setState(2898);
match(TILDE_);
setState(2899);
match(ASTERISK_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CursorNameContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public CursorNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cursorName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCursorName(this);
else return visitor.visitChildren(this);
}
}
public final CursorNameContext cursorName() throws RecognitionException {
CursorNameContext _localctx = new CursorNameContext(_ctx, getState());
enterRule(_localctx, 276, RULE_cursorName);
try {
enterOuterAlt(_localctx, 1);
{
setState(2902);
name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AExprContext extends ParserRuleContext {
public CExprContext cExpr() {
return getRuleContext(CExprContext.class,0);
}
public TerminalNode PLUS_() { return getToken(OpenGaussStatementParser.PLUS_, 0); }
public List aExpr() {
return getRuleContexts(AExprContext.class);
}
public AExprContext aExpr(int i) {
return getRuleContext(AExprContext.class,i);
}
public TerminalNode MINUS_() { return getToken(OpenGaussStatementParser.MINUS_, 0); }
public QualOpContext qualOp() {
return getRuleContext(QualOpContext.class,0);
}
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public List row() {
return getRuleContexts(RowContext.class);
}
public RowContext row(int i) {
return getRuleContext(RowContext.class,i);
}
public TerminalNode OVERLAPS() { return getToken(OpenGaussStatementParser.OVERLAPS, 0); }
public TerminalNode UNIQUE() { return getToken(OpenGaussStatementParser.UNIQUE, 0); }
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(OpenGaussStatementParser.DEFAULT, 0); }
public TerminalNode AT() { return getToken(OpenGaussStatementParser.AT, 0); }
public TerminalNode TIME() { return getToken(OpenGaussStatementParser.TIME, 0); }
public TerminalNode ZONE() { return getToken(OpenGaussStatementParser.ZONE, 0); }
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public TerminalNode SLASH_() { return getToken(OpenGaussStatementParser.SLASH_, 0); }
public TerminalNode MOD_() { return getToken(OpenGaussStatementParser.MOD_, 0); }
public TerminalNode CARET_() { return getToken(OpenGaussStatementParser.CARET_, 0); }
public TerminalNode AMPERSAND_() { return getToken(OpenGaussStatementParser.AMPERSAND_, 0); }
public TerminalNode VERTICAL_BAR_() { return getToken(OpenGaussStatementParser.VERTICAL_BAR_, 0); }
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public PatternMatchingOperatorContext patternMatchingOperator() {
return getRuleContext(PatternMatchingOperatorContext.class,0);
}
public TerminalNode ESCAPE() { return getToken(OpenGaussStatementParser.ESCAPE, 0); }
public TerminalNode IS() { return getToken(OpenGaussStatementParser.IS, 0); }
public TerminalNode DISTINCT() { return getToken(OpenGaussStatementParser.DISTINCT, 0); }
public TerminalNode FROM() { return getToken(OpenGaussStatementParser.FROM, 0); }
public TerminalNode BETWEEN() { return getToken(OpenGaussStatementParser.BETWEEN, 0); }
public BExprContext bExpr() {
return getRuleContext(BExprContext.class,0);
}
public TerminalNode AND() { return getToken(OpenGaussStatementParser.AND, 0); }
public TerminalNode ASYMMETRIC() { return getToken(OpenGaussStatementParser.ASYMMETRIC, 0); }
public TerminalNode SYMMETRIC() { return getToken(OpenGaussStatementParser.SYMMETRIC, 0); }
public AndOperatorContext andOperator() {
return getRuleContext(AndOperatorContext.class,0);
}
public OrOperatorContext orOperator() {
return getRuleContext(OrOperatorContext.class,0);
}
public TerminalNode TYPE_CAST_() { return getToken(OpenGaussStatementParser.TYPE_CAST_, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode COLLATE() { return getToken(OpenGaussStatementParser.COLLATE, 0); }
public AnyNameContext anyName() {
return getRuleContext(AnyNameContext.class,0);
}
public TerminalNode NULL() { return getToken(OpenGaussStatementParser.NULL, 0); }
public TerminalNode ISNULL() { return getToken(OpenGaussStatementParser.ISNULL, 0); }
public TerminalNode NOTNULL() { return getToken(OpenGaussStatementParser.NOTNULL, 0); }
public TerminalNode TRUE() { return getToken(OpenGaussStatementParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(OpenGaussStatementParser.FALSE, 0); }
public TerminalNode UNKNOWN() { return getToken(OpenGaussStatementParser.UNKNOWN, 0); }
public TerminalNode OF() { return getToken(OpenGaussStatementParser.OF, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TerminalNode IN() { return getToken(OpenGaussStatementParser.IN, 0); }
public InExprContext inExpr() {
return getRuleContext(InExprContext.class,0);
}
public SubqueryOpContext subqueryOp() {
return getRuleContext(SubqueryOpContext.class,0);
}
public SubTypeContext subType() {
return getRuleContext(SubTypeContext.class,0);
}
public TerminalNode DOCUMENT() { return getToken(OpenGaussStatementParser.DOCUMENT, 0); }
public TerminalNode NORMALIZED() { return getToken(OpenGaussStatementParser.NORMALIZED, 0); }
public UnicodeNormalFormContext unicodeNormalForm() {
return getRuleContext(UnicodeNormalFormContext.class,0);
}
public AExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitAExpr(this);
else return visitor.visitChildren(this);
}
}
public final AExprContext aExpr() throws RecognitionException {
return aExpr(0);
}
private AExprContext aExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AExprContext _localctx = new AExprContext(_ctx, _parentState);
AExprContext _prevctx = _localctx;
int _startState = 278;
enterRecursionRule(_localctx, 278, RULE_aExpr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2922);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
case 1:
{
setState(2905);
cExpr();
}
break;
case 2:
{
setState(2906);
match(PLUS_);
setState(2907);
aExpr(50);
}
break;
case 3:
{
setState(2908);
match(MINUS_);
setState(2909);
aExpr(49);
}
break;
case 4:
{
setState(2910);
qualOp();
setState(2911);
aExpr(39);
}
break;
case 5:
{
setState(2913);
match(NOT);
setState(2914);
aExpr(36);
}
break;
case 6:
{
setState(2915);
row();
setState(2916);
match(OVERLAPS);
setState(2917);
row();
}
break;
case 7:
{
setState(2919);
match(UNIQUE);
setState(2920);
selectWithParens();
}
break;
case 8:
{
setState(2921);
match(DEFAULT);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(3125);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,188,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(3123);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) {
case 1:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2924);
if (!(precpred(_ctx, 51))) throw new FailedPredicateException(this, "precpred(_ctx, 51)");
setState(2925);
match(AT);
setState(2926);
match(TIME);
setState(2927);
match(ZONE);
setState(2928);
aExpr(52);
}
break;
case 2:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2929);
if (!(precpred(_ctx, 48))) throw new FailedPredicateException(this, "precpred(_ctx, 48)");
setState(2930);
match(PLUS_);
setState(2931);
aExpr(49);
}
break;
case 3:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2932);
if (!(precpred(_ctx, 47))) throw new FailedPredicateException(this, "precpred(_ctx, 47)");
setState(2933);
match(MINUS_);
setState(2934);
aExpr(48);
}
break;
case 4:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2935);
if (!(precpred(_ctx, 46))) throw new FailedPredicateException(this, "precpred(_ctx, 46)");
setState(2936);
match(ASTERISK_);
setState(2937);
aExpr(47);
}
break;
case 5:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2938);
if (!(precpred(_ctx, 45))) throw new FailedPredicateException(this, "precpred(_ctx, 45)");
setState(2939);
match(SLASH_);
setState(2940);
aExpr(46);
}
break;
case 6:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2941);
if (!(precpred(_ctx, 44))) throw new FailedPredicateException(this, "precpred(_ctx, 44)");
setState(2942);
match(MOD_);
setState(2943);
aExpr(45);
}
break;
case 7:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2944);
if (!(precpred(_ctx, 43))) throw new FailedPredicateException(this, "precpred(_ctx, 43)");
setState(2945);
match(CARET_);
setState(2946);
aExpr(44);
}
break;
case 8:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2947);
if (!(precpred(_ctx, 42))) throw new FailedPredicateException(this, "precpred(_ctx, 42)");
setState(2948);
match(AMPERSAND_);
setState(2949);
aExpr(43);
}
break;
case 9:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2950);
if (!(precpred(_ctx, 41))) throw new FailedPredicateException(this, "precpred(_ctx, 41)");
setState(2951);
match(VERTICAL_BAR_);
setState(2952);
aExpr(42);
}
break;
case 10:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2953);
if (!(precpred(_ctx, 40))) throw new FailedPredicateException(this, "precpred(_ctx, 40)");
setState(2954);
qualOp();
setState(2955);
aExpr(41);
}
break;
case 11:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2957);
if (!(precpred(_ctx, 37))) throw new FailedPredicateException(this, "precpred(_ctx, 37)");
setState(2958);
comparisonOperator();
setState(2959);
aExpr(38);
}
break;
case 12:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2961);
if (!(precpred(_ctx, 35))) throw new FailedPredicateException(this, "precpred(_ctx, 35)");
setState(2962);
patternMatchingOperator();
setState(2963);
aExpr(0);
setState(2964);
match(ESCAPE);
setState(2965);
aExpr(36);
}
break;
case 13:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2967);
if (!(precpred(_ctx, 34))) throw new FailedPredicateException(this, "precpred(_ctx, 34)");
setState(2968);
patternMatchingOperator();
setState(2969);
aExpr(35);
}
break;
case 14:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2971);
if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
setState(2972);
match(IS);
setState(2973);
match(DISTINCT);
setState(2974);
match(FROM);
setState(2975);
aExpr(23);
}
break;
case 15:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2976);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(2977);
match(IS);
setState(2978);
match(NOT);
setState(2979);
match(DISTINCT);
setState(2980);
match(FROM);
setState(2981);
aExpr(22);
}
break;
case 16:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2982);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(2983);
match(BETWEEN);
setState(2985);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYMMETRIC) {
{
setState(2984);
match(ASYMMETRIC);
}
}
setState(2987);
bExpr(0);
setState(2988);
match(AND);
setState(2989);
aExpr(19);
}
break;
case 17:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(2991);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(2992);
match(NOT);
setState(2993);
match(BETWEEN);
setState(2995);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYMMETRIC) {
{
setState(2994);
match(ASYMMETRIC);
}
}
setState(2997);
bExpr(0);
setState(2998);
match(AND);
setState(2999);
aExpr(18);
}
break;
case 18:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3001);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(3002);
match(BETWEEN);
setState(3003);
match(SYMMETRIC);
setState(3004);
bExpr(0);
setState(3005);
match(AND);
setState(3006);
aExpr(17);
}
break;
case 19:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3008);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(3009);
match(NOT);
setState(3010);
match(BETWEEN);
setState(3011);
match(SYMMETRIC);
setState(3012);
bExpr(0);
setState(3013);
match(AND);
setState(3014);
aExpr(16);
}
break;
case 20:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3016);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(3017);
andOperator();
setState(3018);
aExpr(4);
}
break;
case 21:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3020);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(3021);
orOperator();
setState(3022);
aExpr(3);
}
break;
case 22:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3024);
if (!(precpred(_ctx, 53))) throw new FailedPredicateException(this, "precpred(_ctx, 53)");
setState(3025);
match(TYPE_CAST_);
setState(3026);
typeName();
}
break;
case 23:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3027);
if (!(precpred(_ctx, 52))) throw new FailedPredicateException(this, "precpred(_ctx, 52)");
setState(3028);
match(COLLATE);
setState(3029);
anyName();
}
break;
case 24:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3030);
if (!(precpred(_ctx, 38))) throw new FailedPredicateException(this, "precpred(_ctx, 38)");
setState(3031);
qualOp();
}
break;
case 25:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3032);
if (!(precpred(_ctx, 33))) throw new FailedPredicateException(this, "precpred(_ctx, 33)");
setState(3033);
match(IS);
setState(3034);
match(NULL);
}
break;
case 26:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3035);
if (!(precpred(_ctx, 32))) throw new FailedPredicateException(this, "precpred(_ctx, 32)");
setState(3036);
match(ISNULL);
}
break;
case 27:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3037);
if (!(precpred(_ctx, 31))) throw new FailedPredicateException(this, "precpred(_ctx, 31)");
setState(3038);
match(IS);
setState(3039);
match(NOT);
setState(3040);
match(NULL);
}
break;
case 28:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3041);
if (!(precpred(_ctx, 30))) throw new FailedPredicateException(this, "precpred(_ctx, 30)");
setState(3042);
match(NOTNULL);
}
break;
case 29:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3043);
if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)");
setState(3044);
match(IS);
setState(3045);
match(TRUE);
}
break;
case 30:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3046);
if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)");
setState(3047);
match(IS);
setState(3048);
match(NOT);
setState(3049);
match(TRUE);
}
break;
case 31:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3050);
if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)");
setState(3051);
match(IS);
setState(3052);
match(FALSE);
}
break;
case 32:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3053);
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
setState(3054);
match(IS);
setState(3055);
match(NOT);
setState(3056);
match(FALSE);
}
break;
case 33:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3057);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(3058);
match(IS);
setState(3059);
match(UNKNOWN);
}
break;
case 34:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3060);
if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
setState(3061);
match(IS);
setState(3062);
match(NOT);
setState(3063);
match(UNKNOWN);
}
break;
case 35:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3064);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(3065);
match(IS);
setState(3066);
match(OF);
setState(3067);
match(LP_);
setState(3068);
typeList();
setState(3069);
match(RP_);
}
break;
case 36:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3071);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(3072);
match(IS);
setState(3073);
match(NOT);
setState(3074);
match(OF);
setState(3075);
match(LP_);
setState(3076);
typeList();
setState(3077);
match(RP_);
}
break;
case 37:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3079);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(3080);
match(IN);
setState(3081);
inExpr();
}
break;
case 38:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3082);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(3083);
match(NOT);
setState(3084);
match(IN);
setState(3085);
inExpr();
}
break;
case 39:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3086);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(3087);
subqueryOp();
setState(3088);
subType();
setState(3089);
selectWithParens();
}
break;
case 40:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3091);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(3092);
subqueryOp();
setState(3093);
subType();
setState(3094);
match(LP_);
setState(3095);
aExpr(0);
setState(3096);
match(RP_);
}
break;
case 41:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3098);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(3099);
match(IS);
setState(3100);
match(DOCUMENT);
}
break;
case 42:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3101);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(3102);
match(IS);
setState(3103);
match(NOT);
setState(3104);
match(DOCUMENT);
}
break;
case 43:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3105);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(3106);
match(IS);
setState(3107);
match(NORMALIZED);
}
break;
case 44:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3108);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(3109);
match(IS);
setState(3110);
unicodeNormalForm();
setState(3111);
match(NORMALIZED);
}
break;
case 45:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3113);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(3114);
match(IS);
setState(3115);
match(NOT);
setState(3116);
match(NORMALIZED);
}
break;
case 46:
{
_localctx = new AExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_aExpr);
setState(3117);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(3118);
match(IS);
setState(3119);
match(NOT);
setState(3120);
unicodeNormalForm();
setState(3121);
match(NORMALIZED);
}
break;
}
}
}
setState(3127);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,188,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class BExprContext extends ParserRuleContext {
public CExprContext cExpr() {
return getRuleContext(CExprContext.class,0);
}
public TerminalNode PLUS_() { return getToken(OpenGaussStatementParser.PLUS_, 0); }
public List bExpr() {
return getRuleContexts(BExprContext.class);
}
public BExprContext bExpr(int i) {
return getRuleContext(BExprContext.class,i);
}
public TerminalNode MINUS_() { return getToken(OpenGaussStatementParser.MINUS_, 0); }
public QualOpContext qualOp() {
return getRuleContext(QualOpContext.class,0);
}
public TerminalNode IS() { return getToken(OpenGaussStatementParser.IS, 0); }
public TerminalNode DISTINCT() { return getToken(OpenGaussStatementParser.DISTINCT, 0); }
public TerminalNode FROM() { return getToken(OpenGaussStatementParser.FROM, 0); }
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public TerminalNode TYPE_CAST_() { return getToken(OpenGaussStatementParser.TYPE_CAST_, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode OF() { return getToken(OpenGaussStatementParser.OF, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TerminalNode DOCUMENT() { return getToken(OpenGaussStatementParser.DOCUMENT, 0); }
public BExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitBExpr(this);
else return visitor.visitChildren(this);
}
}
public final BExprContext bExpr() throws RecognitionException {
return bExpr(0);
}
private BExprContext bExpr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BExprContext _localctx = new BExprContext(_ctx, _parentState);
BExprContext _prevctx = _localctx;
int _startState = 280;
enterRecursionRule(_localctx, 280, RULE_bExpr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(3137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
{
setState(3129);
cExpr();
}
break;
case 2:
{
setState(3130);
match(PLUS_);
setState(3131);
bExpr(11);
}
break;
case 3:
{
setState(3132);
match(MINUS_);
setState(3133);
bExpr(10);
}
break;
case 4:
{
setState(3134);
qualOp();
setState(3135);
bExpr(8);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(3183);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,191,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(3181);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3139);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(3140);
qualOp();
setState(3141);
bExpr(10);
}
break;
case 2:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3143);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(3144);
match(IS);
setState(3145);
match(DISTINCT);
setState(3146);
match(FROM);
setState(3147);
bExpr(7);
}
break;
case 3:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3148);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(3149);
match(IS);
setState(3150);
match(NOT);
setState(3151);
match(DISTINCT);
setState(3152);
match(FROM);
setState(3153);
bExpr(6);
}
break;
case 4:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3154);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(3155);
match(TYPE_CAST_);
setState(3156);
typeName();
}
break;
case 5:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3157);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(3158);
qualOp();
}
break;
case 6:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3159);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(3160);
match(IS);
setState(3161);
match(OF);
setState(3162);
match(LP_);
setState(3163);
typeList();
setState(3164);
match(RP_);
}
break;
case 7:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3166);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(3167);
match(IS);
setState(3168);
match(NOT);
setState(3169);
match(OF);
setState(3170);
match(LP_);
setState(3171);
typeList();
setState(3172);
match(RP_);
}
break;
case 8:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3174);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(3175);
match(IS);
setState(3176);
match(DOCUMENT);
}
break;
case 9:
{
_localctx = new BExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_bExpr);
setState(3177);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(3178);
match(IS);
setState(3179);
match(NOT);
setState(3180);
match(DOCUMENT);
}
break;
}
}
}
setState(3185);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,191,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class CExprContext extends ParserRuleContext {
public ParameterMarkerContext parameterMarker() {
return getRuleContext(ParameterMarkerContext.class,0);
}
public ColumnrefContext columnref() {
return getRuleContext(ColumnrefContext.class,0);
}
public AexprConstContext aexprConst() {
return getRuleContext(AexprConstContext.class,0);
}
public TerminalNode PARAM() { return getToken(OpenGaussStatementParser.PARAM, 0); }
public IndirectionElContext indirectionEl() {
return getRuleContext(IndirectionElContext.class,0);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public OptIndirectionContext optIndirection() {
return getRuleContext(OptIndirectionContext.class,0);
}
public CaseExprContext caseExpr() {
return getRuleContext(CaseExprContext.class,0);
}
public FuncExprContext funcExpr() {
return getRuleContext(FuncExprContext.class,0);
}
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public IndirectionContext indirection() {
return getRuleContext(IndirectionContext.class,0);
}
public TerminalNode EXISTS() { return getToken(OpenGaussStatementParser.EXISTS, 0); }
public TerminalNode ARRAY() { return getToken(OpenGaussStatementParser.ARRAY, 0); }
public ArrayExprContext arrayExpr() {
return getRuleContext(ArrayExprContext.class,0);
}
public ExplicitRowContext explicitRow() {
return getRuleContext(ExplicitRowContext.class,0);
}
public ImplicitRowContext implicitRow() {
return getRuleContext(ImplicitRowContext.class,0);
}
public TerminalNode GROUPING() { return getToken(OpenGaussStatementParser.GROUPING, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public CExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCExpr(this);
else return visitor.visitChildren(this);
}
}
public final CExprContext cExpr() throws RecognitionException {
CExprContext _localctx = new CExprContext(_ctx, getState());
enterRule(_localctx, 282, RULE_cExpr);
try {
setState(3217);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3186);
parameterMarker();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3187);
columnref();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3188);
aexprConst();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(3189);
match(PARAM);
setState(3191);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(3190);
indirectionEl();
}
break;
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(3193);
match(LP_);
setState(3194);
aExpr(0);
setState(3195);
match(RP_);
setState(3196);
optIndirection(0);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(3198);
caseExpr();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(3199);
funcExpr();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(3200);
selectWithParens();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(3201);
selectWithParens();
setState(3202);
indirection(0);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(3204);
match(EXISTS);
setState(3205);
selectWithParens();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(3206);
match(ARRAY);
setState(3207);
selectWithParens();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(3208);
match(ARRAY);
setState(3209);
arrayExpr();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(3210);
explicitRow();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(3211);
implicitRow();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(3212);
match(GROUPING);
setState(3213);
match(LP_);
setState(3214);
exprList(0);
setState(3215);
match(RP_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IndirectionContext extends ParserRuleContext {
public IndirectionElContext indirectionEl() {
return getRuleContext(IndirectionElContext.class,0);
}
public IndirectionContext indirection() {
return getRuleContext(IndirectionContext.class,0);
}
public IndirectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indirection; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitIndirection(this);
else return visitor.visitChildren(this);
}
}
public final IndirectionContext indirection() throws RecognitionException {
return indirection(0);
}
private IndirectionContext indirection(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
IndirectionContext _localctx = new IndirectionContext(_ctx, _parentState);
IndirectionContext _prevctx = _localctx;
int _startState = 284;
enterRecursionRule(_localctx, 284, RULE_indirection, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(3220);
indirectionEl();
}
_ctx.stop = _input.LT(-1);
setState(3226);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,194,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new IndirectionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_indirection);
setState(3222);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(3223);
indirectionEl();
}
}
}
setState(3228);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,194,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class OptIndirectionContext extends ParserRuleContext {
public OptIndirectionContext optIndirection() {
return getRuleContext(OptIndirectionContext.class,0);
}
public IndirectionElContext indirectionEl() {
return getRuleContext(IndirectionElContext.class,0);
}
public OptIndirectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optIndirection; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitOptIndirection(this);
else return visitor.visitChildren(this);
}
}
public final OptIndirectionContext optIndirection() throws RecognitionException {
return optIndirection(0);
}
private OptIndirectionContext optIndirection(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
OptIndirectionContext _localctx = new OptIndirectionContext(_ctx, _parentState);
OptIndirectionContext _prevctx = _localctx;
int _startState = 286;
enterRecursionRule(_localctx, 286, RULE_optIndirection, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
}
_ctx.stop = _input.LT(-1);
setState(3234);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,195,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new OptIndirectionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_optIndirection);
setState(3230);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(3231);
indirectionEl();
}
}
}
setState(3236);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,195,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class IndirectionElContext extends ParserRuleContext {
public TerminalNode DOT_() { return getToken(OpenGaussStatementParser.DOT_, 0); }
public AttrNameContext attrName() {
return getRuleContext(AttrNameContext.class,0);
}
public TerminalNode ASTERISK_() { return getToken(OpenGaussStatementParser.ASTERISK_, 0); }
public TerminalNode LBT_() { return getToken(OpenGaussStatementParser.LBT_, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public TerminalNode RBT_() { return getToken(OpenGaussStatementParser.RBT_, 0); }
public TerminalNode COLON_() { return getToken(OpenGaussStatementParser.COLON_, 0); }
public List sliceBound() {
return getRuleContexts(SliceBoundContext.class);
}
public SliceBoundContext sliceBound(int i) {
return getRuleContext(SliceBoundContext.class,i);
}
public IndirectionElContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indirectionEl; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitIndirectionEl(this);
else return visitor.visitChildren(this);
}
}
public final IndirectionElContext indirectionEl() throws RecognitionException {
IndirectionElContext _localctx = new IndirectionElContext(_ctx, getState());
enterRule(_localctx, 288, RULE_indirectionEl);
int _la;
try {
setState(3254);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3237);
match(DOT_);
setState(3238);
attrName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3239);
match(DOT_);
setState(3240);
match(ASTERISK_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3241);
match(LBT_);
setState(3242);
aExpr(0);
setState(3243);
match(RBT_);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(3245);
match(LBT_);
setState(3247);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OR_) | (1L << SIGNED_LEFT_SHIFT_) | (1L << SIGNED_RIGHT_SHIFT_) | (1L << PLUS_) | (1L << MINUS_) | (1L << POUND_) | (1L << LP_) | (1L << QUESTION_) | (1L << DOLLAR_) | (1L << UNICODE_ESCAPE) | (1L << JSON_EXTRACT_) | (1L << JSON_EXTRACT_TEXT_) | (1L << JSON_PATH_EXTRACT_) | (1L << JSON_PATH_EXTRACT_TEXT_) | (1L << JSONB_CONTAIN_RIGHT_) | (1L << JSONB_CONTAIN_LEFT_) | (1L << JSONB_CONTAIN_ALL_TOP_KEY_) | (1L << JSONB_PATH_DELETE_) | (1L << JSONB_PATH_CONTAIN_ANY_VALUE_) | (1L << JSONB_PATH_PREDICATE_CHECK_) | (1L << GEOMETRIC_LENGTH_) | (1L << GEOMETRIC_DISTANCE_))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GEOMETRIC_EXTEND_RIGHT_ - 64)) | (1L << (GEOMETRIC_EXTEND_LEFT_ - 64)) | (1L << (GEOMETRIC_STRICT_BELOW_ - 64)) | (1L << (GEOMETRIC_STRICT_ABOVE_ - 64)) | (1L << (GEOMETRIC_EXTEND_ABOVE_ - 64)) | (1L << (GEOMETRIC_EXTEND_BELOW_ - 64)) | (1L << (GEOMETRIC_BELOW_ - 64)) | (1L << (GEOMETRIC_ABOVE_ - 64)) | (1L << (GEOMETRIC_INTERSECT_ - 64)) | (1L << (GEOMETRIC_PERPENDICULAR_ - 64)) | (1L << (GEOMETRIC_SAME_AS_ - 64)) | (1L << (INSERT - 64)) | (1L << (UPDATE - 64)) | (1L << (DELETE - 64)) | (1L << (ALTER - 64)) | (1L << (DROP - 64)) | (1L << (TRUNCATE - 64)) | (1L << (SCHEMA - 64)) | (1L << (REVOKE - 64)) | (1L << (ADD - 64)) | (1L << (SET - 64)) | (1L << (INDEX - 64)) | (1L << (UNIQUE - 64)) | (1L << (KEY - 64)) | (1L << (POSITION - 64)) | (1L << (FUNCTION - 64)) | (1L << (TRIGGER - 64)) | (1L << (PROCEDURE - 64)) | (1L << (VIEW - 64)) | (1L << (CASE - 64)) | (1L << (CAST - 64)) | (1L << (TRIM - 64)) | (1L << (SUBSTRING - 64)) | (1L << (NATURAL - 64)) | (1L << (JOIN - 64)) | (1L << (FULL - 64)) | (1L << (INNER - 64)) | (1L << (OUTER - 64)) | (1L << (LEFT - 64)) | (1L << (RIGHT - 64)) | (1L << (CROSS - 64)) | (1L << (IF - 64)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (IS - 134)) | (1L << (NOT - 134)) | (1L << (NULL - 134)) | (1L << (TRUE - 134)) | (1L << (FALSE - 134)) | (1L << (EXISTS - 134)) | (1L << (LIKE - 134)) | (1L << (BY - 134)) | (1L << (BEGIN - 134)) | (1L << (COMMIT - 134)) | (1L << (ROLLBACK - 134)) | (1L << (SAVEPOINT - 134)) | (1L << (BOOLEAN - 134)) | (1L << (DOUBLE - 134)) | (1L << (CHAR - 134)) | (1L << (CHARACTER - 134)) | (1L << (ARRAY - 134)) | (1L << (INTERVAL - 134)) | (1L << (DATE - 134)) | (1L << (TIME - 134)) | (1L << (TIMESTAMP - 134)) | (1L << (LOCALTIME - 134)) | (1L << (LOCALTIMESTAMP - 134)) | (1L << (YEAR - 134)) | (1L << (MONTH - 134)) | (1L << (DAY - 134)) | (1L << (HOUR - 134)) | (1L << (MINUTE - 134)) | (1L << (SECOND - 134)) | (1L << (DEFAULT - 134)) | (1L << (CURRENT - 134)) | (1L << (ENABLE - 134)) | (1L << (DISABLE - 134)) | (1L << (CALL - 134)) | (1L << (PRESERVE - 134)) | (1L << (DEFINER - 134)) | (1L << (CURRENT_USER - 134)) | (1L << (SQL - 134)) | (1L << (CASCADED - 134)) | (1L << (LOCAL - 134)) | (1L << (CLOSE - 134)) | (1L << (NEXT - 134)) | (1L << (NAME - 134)) | (1L << (COLLATION - 134)) | (1L << (NAMES - 134)) | (1L << (INTEGER - 134)) | (1L << (REAL - 134)))) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & ((1L << (DECIMAL - 198)) | (1L << (TYPE - 198)) | (1L << (SMALLINT - 198)) | (1L << (BIGINT - 198)) | (1L << (NUMERIC - 198)) | (1L << (TEXT - 198)) | (1L << (REPEATABLE - 198)) | (1L << (CURRENT_DATE - 198)) | (1L << (CURRENT_TIME - 198)) | (1L << (CURRENT_TIMESTAMP - 198)) | (1L << (NULLIF - 198)) | (1L << (VARYING - 198)) | (1L << (NATIONAL - 198)) | (1L << (NCHAR - 198)) | (1L << (VALUE - 198)) | (1L << (COALESCE - 198)) | (1L << (TIES - 198)) | (1L << (CUBE - 198)) | (1L << (GROUPING - 198)) | (1L << (SETS - 198)) | (1L << (OTHERS - 198)) | (1L << (OVERLAPS - 198)) | (1L << (AT - 198)) | (1L << (DEC - 198)) | (1L << (MAXVALUE - 198)) | (1L << (ADMIN - 198)) | (1L << (BINARY - 198)) | (1L << (ESCAPE - 198)) | (1L << (EXCLUDE - 198)) | (1L << (MOD - 198)) | (1L << (PARTITION - 198)) | (1L << (ROW - 198)) | (1L << (UNKNOWN - 198)) | (1L << (ALWAYS - 198)) | (1L << (CASCADE - 198)) | (1L << (GENERATED - 198)) | (1L << (ISOLATION - 198)) | (1L << (LEVEL - 198)) | (1L << (NO - 198)) | (1L << (OPTION - 198)) | (1L << (PRIVILEGES - 198)) | (1L << (READ - 198)) | (1L << (ROLE - 198)) | (1L << (ROWS - 198)) | (1L << (START - 198)) | (1L << (TRANSACTION - 198)) | (1L << (USER - 198)) | (1L << (ACTION - 198)))) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & ((1L << (CACHE - 262)) | (1L << (CHARACTERISTICS - 262)) | (1L << (CLUSTER - 262)) | (1L << (COMMENTS - 262)) | (1L << (CONCURRENTLY - 262)) | (1L << (CONSTRAINTS - 262)) | (1L << (CYCLE - 262)) | (1L << (DATA - 262)) | (1L << (DATABASE - 262)) | (1L << (DEFAULTS - 262)) | (1L << (DEFERRED - 262)) | (1L << (DEPENDS - 262)) | (1L << (DOMAIN - 262)) | (1L << (EXCLUDING - 262)) | (1L << (EXECUTE - 262)) | (1L << (EXTENDED - 262)) | (1L << (EXTENSION - 262)) | (1L << (EXTERNAL - 262)) | (1L << (EXTRACT - 262)) | (1L << (FILTER - 262)) | (1L << (FIRST - 262)) | (1L << (FOLLOWING - 262)) | (1L << (FORCE - 262)) | (1L << (GLOBAL - 262)) | (1L << (IDENTITY - 262)) | (1L << (IMMEDIATE - 262)) | (1L << (INCLUDING - 262)) | (1L << (INCREMENT - 262)) | (1L << (INDEXES - 262)) | (1L << (INHERIT - 262)) | (1L << (INHERITS - 262)) | (1L << (INCLUDE - 262)) | (1L << (LANGUAGE - 262)) | (1L << (LARGE - 262)) | (1L << (LAST - 262)) | (1L << (LOGGED - 262)) | (1L << (MAIN - 262)) | (1L << (MATCH - 262)) | (1L << (MINVALUE - 262)) | (1L << (NOTHING - 262)) | (1L << (NULLS - 262)) | (1L << (OBJECT - 262)) | (1L << (OIDS - 262)) | (1L << (OVER - 262)) | (1L << (OWNED - 262)) | (1L << (OWNER - 262)) | (1L << (PARTIAL - 262)) | (1L << (PLAIN - 262)) | (1L << (PRECEDING - 262)) | (1L << (RANGE - 262)) | (1L << (RENAME - 262)) | (1L << (REPLICA - 262)) | (1L << (RESET - 262)) | (1L << (RESTART - 262)) | (1L << (RESTRICT - 262)) | (1L << (ROUTINE - 262)) | (1L << (RULE - 262)) | (1L << (SECURITY - 262)))) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & ((1L << (SEQUENCE - 326)) | (1L << (SESSION - 326)) | (1L << (SESSION_USER - 326)) | (1L << (SHOW - 326)) | (1L << (SIMPLE - 326)) | (1L << (STATISTICS - 326)) | (1L << (STORAGE - 326)) | (1L << (TABLESPACE - 326)) | (1L << (TEMP - 326)) | (1L << (TEMPORARY - 326)) | (1L << (UNBOUNDED - 326)) | (1L << (UNLOGGED - 326)) | (1L << (VALID - 326)) | (1L << (VALIDATE - 326)) | (1L << (WITHIN - 326)) | (1L << (WITHOUT - 326)) | (1L << (ZONE - 326)) | (1L << (OF - 326)) | (1L << (UESCAPE - 326)) | (1L << (GROUPS - 326)) | (1L << (RECURSIVE - 326)) | (1L << (INT - 326)) | (1L << (INT2 - 326)) | (1L << (INT4 - 326)) | (1L << (INT8 - 326)) | (1L << (FLOAT - 326)) | (1L << (FLOAT4 - 326)) | (1L << (FLOAT8 - 326)) | (1L << (VARCHAR - 326)) | (1L << (ENUM - 326)) | (1L << (POINT - 326)) | (1L << (LSEG - 326)) | (1L << (BOX - 326)) | (1L << (PATH - 326)) | (1L << (POLYGON - 326)) | (1L << (CIRCLE - 326)) | (1L << (BIT - 326)) | (1L << (XML - 326)) | (1L << (JSON - 326)) | (1L << (TABLESAMPLE - 326)) | (1L << (ORDINALITY - 326)) | (1L << (CURRENT_ROLE - 326)) | (1L << (CURRENT_CATALOG - 326)) | (1L << (CURRENT_SCHEMA - 326)) | (1L << (NORMALIZE - 326)))) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & ((1L << (OVERLAY - 390)) | (1L << (XMLCONCAT - 390)) | (1L << (XMLELEMENT - 390)) | (1L << (XMLEXISTS - 390)) | (1L << (XMLFOREST - 390)) | (1L << (XMLPARSE - 390)) | (1L << (XMLPI - 390)) | (1L << (XMLROOT - 390)) | (1L << (XMLSERIALIZE - 390)) | (1L << (TREAT - 390)) | (1L << (NFC - 390)) | (1L << (NFD - 390)) | (1L << (NFKC - 390)) | (1L << (NFKD - 390)) | (1L << (REF - 390)) | (1L << (PASSING - 390)) | (1L << (VERSION - 390)) | (1L << (YES - 390)) | (1L << (STANDALONE - 390)) | (1L << (GREATEST - 390)) | (1L << (LEAST - 390)) | (1L << (MATERIALIZED - 390)) | (1L << (OPERATOR - 390)) | (1L << (SHARE - 390)) | (1L << (ROLLUP - 390)) | (1L << (ILIKE - 390)) | (1L << (SIMILAR - 390)) | (1L << (ISNULL - 390)) | (1L << (NOTNULL - 390)) | (1L << (DOCUMENT - 390)) | (1L << (NORMALIZED - 390)) | (1L << (NOWAIT - 390)) | (1L << (LOCKED - 390)) | (1L << (COLUMNS - 390)) | (1L << (CONTENT - 390)) | (1L << (STRIP - 390)) | (1L << (WHITESPACE - 390)) | (1L << (CONFLICT - 390)) | (1L << (OVERRIDING - 390)) | (1L << (SYSTEM - 390)) | (1L << (ABORT - 390)) | (1L << (ABSOLUTE - 390)) | (1L << (ACCESS - 390)) | (1L << (AFTER - 390)) | (1L << (AGGREGATE - 390)) | (1L << (ALSO - 390)) | (1L << (ATTACH - 390)) | (1L << (ATTRIBUTE - 390)) | (1L << (BACKWARD - 390)) | (1L << (BEFORE - 390)) | (1L << (ASSERTION - 390)))) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & ((1L << (ASSIGNMENT - 454)) | (1L << (CONTINUE - 454)) | (1L << (CONVERSION - 454)) | (1L << (COPY - 454)) | (1L << (COST - 454)) | (1L << (CSV - 454)) | (1L << (CALLED - 454)) | (1L << (CATALOG - 454)) | (1L << (CHAIN - 454)) | (1L << (CHECKPOINT - 454)) | (1L << (CLASS - 454)) | (1L << (CONFIGURATION - 454)) | (1L << (COMMENT - 454)) | (1L << (DETACH - 454)) | (1L << (DICTIONARY - 454)) | (1L << (EXPRESSION - 454)) | (1L << (INSENSITIVE - 454)) | (1L << (DISCARD - 454)) | (1L << (OFF - 454)) | (1L << (INSTEAD - 454)) | (1L << (EXPLAIN - 454)) | (1L << (INPUT - 454)) | (1L << (INLINE - 454)) | (1L << (PARALLEL - 454)) | (1L << (LEAKPROOF - 454)) | (1L << (COMMITTED - 454)) | (1L << (ENCODING - 454)) | (1L << (IMPLICIT - 454)) | (1L << (DELIMITER - 454)) | (1L << (CURSOR - 454)) | (1L << (EACH - 454)) | (1L << (EVENT - 454)) | (1L << (DEALLOCATE - 454)) | (1L << (CONNECTION - 454)) | (1L << (DECLARE - 454)) | (1L << (FAMILY - 454)) | (1L << (FORWARD - 454)) | (1L << (EXCLUSIVE - 454)) | (1L << (FUNCTIONS - 454)) | (1L << (LOCATION - 454)) | (1L << (LABEL - 454)) | (1L << (DELIMITERS - 454)) | (1L << (HANDLER - 454)) | (1L << (HEADER - 454)) | (1L << (IMMUTABLE - 454)) | (1L << (GRANTED - 454)) | (1L << (HOLD - 454)) | (1L << (MAPPING - 454)) | (1L << (OLD - 454)) | (1L << (METHOD - 454)) | (1L << (LOAD - 454)) | (1L << (LISTEN - 454)) | (1L << (MODE - 454)) | (1L << (MOVE - 454)) | (1L << (PROCEDURAL - 454)) | (1L << (PARSER - 454)) | (1L << (PROCEDURES - 454)) | (1L << (ENCRYPTED - 454)) | (1L << (PUBLICATION - 454)) | (1L << (PROGRAM - 454)) | (1L << (REFERENCING - 454)) | (1L << (PLANS - 454)) | (1L << (REINDEX - 454)))) != 0) || ((((_la - 518)) & ~0x3f) == 0 && ((1L << (_la - 518)) & ((1L << (PRIOR - 518)) | (1L << (PASSWORD - 518)) | (1L << (RELATIVE - 518)) | (1L << (QUOTE - 518)) | (1L << (ROUTINES - 518)) | (1L << (REPLACE - 518)) | (1L << (SNAPSHOT - 518)) | (1L << (REFRESH - 518)) | (1L << (PREPARE - 518)) | (1L << (OPTIONS - 518)) | (1L << (IMPORT - 518)) | (1L << (INVOKER - 518)) | (1L << (NEW - 518)) | (1L << (PREPARED - 518)) | (1L << (SCROLL - 518)) | (1L << (SEQUENCES - 518)) | (1L << (SYSID - 518)) | (1L << (REASSIGN - 518)) | (1L << (SERVER - 518)) | (1L << (SUBSCRIPTION - 518)) | (1L << (SEARCH - 518)) | (1L << (SCHEMAS - 518)) | (1L << (RECHECK - 518)) | (1L << (POLICY - 518)) | (1L << (NOTIFY - 518)) | (1L << (LOCK - 518)) | (1L << (RELEASE - 518)) | (1L << (SERIALIZABLE - 518)) | (1L << (RETURNS - 518)) | (1L << (STATEMENT - 518)) | (1L << (STDIN - 518)) | (1L << (STDOUT - 518)) | (1L << (TABLES - 518)) | (1L << (SUPPORT - 518)) | (1L << (STABLE - 518)) | (1L << (TEMPLATE - 518)) | (1L << (UNENCRYPTED - 518)) | (1L << (VIEWS - 518)) | (1L << (UNCOMMITTED - 518)) | (1L << (TRANSFORM - 518)) | (1L << (UNLISTEN - 518)) | (1L << (TRUSTED - 518)) | (1L << (VALIDATOR - 518)) | (1L << (UNTIL - 518)) | (1L << (VACUUM - 518)) | (1L << (VOLATILE - 518)) | (1L << (STORED - 518)) | (1L << (WRITE - 518)) | (1L << (STRICT - 518)) | (1L << (TYPES - 518)) | (1L << (WRAPPER - 518)) | (1L << (WORK - 518)) | (1L << (FREEZE - 518)) | (1L << (AUTHORIZATION - 518)) | (1L << (VERBOSE - 518)) | (1L << (PARAM - 518)) | (1L << (IDENTIFIER_ - 518)) | (1L << (STRING_ - 518)) | (1L << (NUMBER_ - 518)))) != 0)) {
{
setState(3246);
sliceBound();
}
}
setState(3249);
match(COLON_);
setState(3251);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OR_) | (1L << SIGNED_LEFT_SHIFT_) | (1L << SIGNED_RIGHT_SHIFT_) | (1L << PLUS_) | (1L << MINUS_) | (1L << POUND_) | (1L << LP_) | (1L << QUESTION_) | (1L << DOLLAR_) | (1L << UNICODE_ESCAPE) | (1L << JSON_EXTRACT_) | (1L << JSON_EXTRACT_TEXT_) | (1L << JSON_PATH_EXTRACT_) | (1L << JSON_PATH_EXTRACT_TEXT_) | (1L << JSONB_CONTAIN_RIGHT_) | (1L << JSONB_CONTAIN_LEFT_) | (1L << JSONB_CONTAIN_ALL_TOP_KEY_) | (1L << JSONB_PATH_DELETE_) | (1L << JSONB_PATH_CONTAIN_ANY_VALUE_) | (1L << JSONB_PATH_PREDICATE_CHECK_) | (1L << GEOMETRIC_LENGTH_) | (1L << GEOMETRIC_DISTANCE_))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GEOMETRIC_EXTEND_RIGHT_ - 64)) | (1L << (GEOMETRIC_EXTEND_LEFT_ - 64)) | (1L << (GEOMETRIC_STRICT_BELOW_ - 64)) | (1L << (GEOMETRIC_STRICT_ABOVE_ - 64)) | (1L << (GEOMETRIC_EXTEND_ABOVE_ - 64)) | (1L << (GEOMETRIC_EXTEND_BELOW_ - 64)) | (1L << (GEOMETRIC_BELOW_ - 64)) | (1L << (GEOMETRIC_ABOVE_ - 64)) | (1L << (GEOMETRIC_INTERSECT_ - 64)) | (1L << (GEOMETRIC_PERPENDICULAR_ - 64)) | (1L << (GEOMETRIC_SAME_AS_ - 64)) | (1L << (INSERT - 64)) | (1L << (UPDATE - 64)) | (1L << (DELETE - 64)) | (1L << (ALTER - 64)) | (1L << (DROP - 64)) | (1L << (TRUNCATE - 64)) | (1L << (SCHEMA - 64)) | (1L << (REVOKE - 64)) | (1L << (ADD - 64)) | (1L << (SET - 64)) | (1L << (INDEX - 64)) | (1L << (UNIQUE - 64)) | (1L << (KEY - 64)) | (1L << (POSITION - 64)) | (1L << (FUNCTION - 64)) | (1L << (TRIGGER - 64)) | (1L << (PROCEDURE - 64)) | (1L << (VIEW - 64)) | (1L << (CASE - 64)) | (1L << (CAST - 64)) | (1L << (TRIM - 64)) | (1L << (SUBSTRING - 64)) | (1L << (NATURAL - 64)) | (1L << (JOIN - 64)) | (1L << (FULL - 64)) | (1L << (INNER - 64)) | (1L << (OUTER - 64)) | (1L << (LEFT - 64)) | (1L << (RIGHT - 64)) | (1L << (CROSS - 64)) | (1L << (IF - 64)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (IS - 134)) | (1L << (NOT - 134)) | (1L << (NULL - 134)) | (1L << (TRUE - 134)) | (1L << (FALSE - 134)) | (1L << (EXISTS - 134)) | (1L << (LIKE - 134)) | (1L << (BY - 134)) | (1L << (BEGIN - 134)) | (1L << (COMMIT - 134)) | (1L << (ROLLBACK - 134)) | (1L << (SAVEPOINT - 134)) | (1L << (BOOLEAN - 134)) | (1L << (DOUBLE - 134)) | (1L << (CHAR - 134)) | (1L << (CHARACTER - 134)) | (1L << (ARRAY - 134)) | (1L << (INTERVAL - 134)) | (1L << (DATE - 134)) | (1L << (TIME - 134)) | (1L << (TIMESTAMP - 134)) | (1L << (LOCALTIME - 134)) | (1L << (LOCALTIMESTAMP - 134)) | (1L << (YEAR - 134)) | (1L << (MONTH - 134)) | (1L << (DAY - 134)) | (1L << (HOUR - 134)) | (1L << (MINUTE - 134)) | (1L << (SECOND - 134)) | (1L << (DEFAULT - 134)) | (1L << (CURRENT - 134)) | (1L << (ENABLE - 134)) | (1L << (DISABLE - 134)) | (1L << (CALL - 134)) | (1L << (PRESERVE - 134)) | (1L << (DEFINER - 134)) | (1L << (CURRENT_USER - 134)) | (1L << (SQL - 134)) | (1L << (CASCADED - 134)) | (1L << (LOCAL - 134)) | (1L << (CLOSE - 134)) | (1L << (NEXT - 134)) | (1L << (NAME - 134)) | (1L << (COLLATION - 134)) | (1L << (NAMES - 134)) | (1L << (INTEGER - 134)) | (1L << (REAL - 134)))) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & ((1L << (DECIMAL - 198)) | (1L << (TYPE - 198)) | (1L << (SMALLINT - 198)) | (1L << (BIGINT - 198)) | (1L << (NUMERIC - 198)) | (1L << (TEXT - 198)) | (1L << (REPEATABLE - 198)) | (1L << (CURRENT_DATE - 198)) | (1L << (CURRENT_TIME - 198)) | (1L << (CURRENT_TIMESTAMP - 198)) | (1L << (NULLIF - 198)) | (1L << (VARYING - 198)) | (1L << (NATIONAL - 198)) | (1L << (NCHAR - 198)) | (1L << (VALUE - 198)) | (1L << (COALESCE - 198)) | (1L << (TIES - 198)) | (1L << (CUBE - 198)) | (1L << (GROUPING - 198)) | (1L << (SETS - 198)) | (1L << (OTHERS - 198)) | (1L << (OVERLAPS - 198)) | (1L << (AT - 198)) | (1L << (DEC - 198)) | (1L << (MAXVALUE - 198)) | (1L << (ADMIN - 198)) | (1L << (BINARY - 198)) | (1L << (ESCAPE - 198)) | (1L << (EXCLUDE - 198)) | (1L << (MOD - 198)) | (1L << (PARTITION - 198)) | (1L << (ROW - 198)) | (1L << (UNKNOWN - 198)) | (1L << (ALWAYS - 198)) | (1L << (CASCADE - 198)) | (1L << (GENERATED - 198)) | (1L << (ISOLATION - 198)) | (1L << (LEVEL - 198)) | (1L << (NO - 198)) | (1L << (OPTION - 198)) | (1L << (PRIVILEGES - 198)) | (1L << (READ - 198)) | (1L << (ROLE - 198)) | (1L << (ROWS - 198)) | (1L << (START - 198)) | (1L << (TRANSACTION - 198)) | (1L << (USER - 198)) | (1L << (ACTION - 198)))) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & ((1L << (CACHE - 262)) | (1L << (CHARACTERISTICS - 262)) | (1L << (CLUSTER - 262)) | (1L << (COMMENTS - 262)) | (1L << (CONCURRENTLY - 262)) | (1L << (CONSTRAINTS - 262)) | (1L << (CYCLE - 262)) | (1L << (DATA - 262)) | (1L << (DATABASE - 262)) | (1L << (DEFAULTS - 262)) | (1L << (DEFERRED - 262)) | (1L << (DEPENDS - 262)) | (1L << (DOMAIN - 262)) | (1L << (EXCLUDING - 262)) | (1L << (EXECUTE - 262)) | (1L << (EXTENDED - 262)) | (1L << (EXTENSION - 262)) | (1L << (EXTERNAL - 262)) | (1L << (EXTRACT - 262)) | (1L << (FILTER - 262)) | (1L << (FIRST - 262)) | (1L << (FOLLOWING - 262)) | (1L << (FORCE - 262)) | (1L << (GLOBAL - 262)) | (1L << (IDENTITY - 262)) | (1L << (IMMEDIATE - 262)) | (1L << (INCLUDING - 262)) | (1L << (INCREMENT - 262)) | (1L << (INDEXES - 262)) | (1L << (INHERIT - 262)) | (1L << (INHERITS - 262)) | (1L << (INCLUDE - 262)) | (1L << (LANGUAGE - 262)) | (1L << (LARGE - 262)) | (1L << (LAST - 262)) | (1L << (LOGGED - 262)) | (1L << (MAIN - 262)) | (1L << (MATCH - 262)) | (1L << (MINVALUE - 262)) | (1L << (NOTHING - 262)) | (1L << (NULLS - 262)) | (1L << (OBJECT - 262)) | (1L << (OIDS - 262)) | (1L << (OVER - 262)) | (1L << (OWNED - 262)) | (1L << (OWNER - 262)) | (1L << (PARTIAL - 262)) | (1L << (PLAIN - 262)) | (1L << (PRECEDING - 262)) | (1L << (RANGE - 262)) | (1L << (RENAME - 262)) | (1L << (REPLICA - 262)) | (1L << (RESET - 262)) | (1L << (RESTART - 262)) | (1L << (RESTRICT - 262)) | (1L << (ROUTINE - 262)) | (1L << (RULE - 262)) | (1L << (SECURITY - 262)))) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & ((1L << (SEQUENCE - 326)) | (1L << (SESSION - 326)) | (1L << (SESSION_USER - 326)) | (1L << (SHOW - 326)) | (1L << (SIMPLE - 326)) | (1L << (STATISTICS - 326)) | (1L << (STORAGE - 326)) | (1L << (TABLESPACE - 326)) | (1L << (TEMP - 326)) | (1L << (TEMPORARY - 326)) | (1L << (UNBOUNDED - 326)) | (1L << (UNLOGGED - 326)) | (1L << (VALID - 326)) | (1L << (VALIDATE - 326)) | (1L << (WITHIN - 326)) | (1L << (WITHOUT - 326)) | (1L << (ZONE - 326)) | (1L << (OF - 326)) | (1L << (UESCAPE - 326)) | (1L << (GROUPS - 326)) | (1L << (RECURSIVE - 326)) | (1L << (INT - 326)) | (1L << (INT2 - 326)) | (1L << (INT4 - 326)) | (1L << (INT8 - 326)) | (1L << (FLOAT - 326)) | (1L << (FLOAT4 - 326)) | (1L << (FLOAT8 - 326)) | (1L << (VARCHAR - 326)) | (1L << (ENUM - 326)) | (1L << (POINT - 326)) | (1L << (LSEG - 326)) | (1L << (BOX - 326)) | (1L << (PATH - 326)) | (1L << (POLYGON - 326)) | (1L << (CIRCLE - 326)) | (1L << (BIT - 326)) | (1L << (XML - 326)) | (1L << (JSON - 326)) | (1L << (TABLESAMPLE - 326)) | (1L << (ORDINALITY - 326)) | (1L << (CURRENT_ROLE - 326)) | (1L << (CURRENT_CATALOG - 326)) | (1L << (CURRENT_SCHEMA - 326)) | (1L << (NORMALIZE - 326)))) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & ((1L << (OVERLAY - 390)) | (1L << (XMLCONCAT - 390)) | (1L << (XMLELEMENT - 390)) | (1L << (XMLEXISTS - 390)) | (1L << (XMLFOREST - 390)) | (1L << (XMLPARSE - 390)) | (1L << (XMLPI - 390)) | (1L << (XMLROOT - 390)) | (1L << (XMLSERIALIZE - 390)) | (1L << (TREAT - 390)) | (1L << (NFC - 390)) | (1L << (NFD - 390)) | (1L << (NFKC - 390)) | (1L << (NFKD - 390)) | (1L << (REF - 390)) | (1L << (PASSING - 390)) | (1L << (VERSION - 390)) | (1L << (YES - 390)) | (1L << (STANDALONE - 390)) | (1L << (GREATEST - 390)) | (1L << (LEAST - 390)) | (1L << (MATERIALIZED - 390)) | (1L << (OPERATOR - 390)) | (1L << (SHARE - 390)) | (1L << (ROLLUP - 390)) | (1L << (ILIKE - 390)) | (1L << (SIMILAR - 390)) | (1L << (ISNULL - 390)) | (1L << (NOTNULL - 390)) | (1L << (DOCUMENT - 390)) | (1L << (NORMALIZED - 390)) | (1L << (NOWAIT - 390)) | (1L << (LOCKED - 390)) | (1L << (COLUMNS - 390)) | (1L << (CONTENT - 390)) | (1L << (STRIP - 390)) | (1L << (WHITESPACE - 390)) | (1L << (CONFLICT - 390)) | (1L << (OVERRIDING - 390)) | (1L << (SYSTEM - 390)) | (1L << (ABORT - 390)) | (1L << (ABSOLUTE - 390)) | (1L << (ACCESS - 390)) | (1L << (AFTER - 390)) | (1L << (AGGREGATE - 390)) | (1L << (ALSO - 390)) | (1L << (ATTACH - 390)) | (1L << (ATTRIBUTE - 390)) | (1L << (BACKWARD - 390)) | (1L << (BEFORE - 390)) | (1L << (ASSERTION - 390)))) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & ((1L << (ASSIGNMENT - 454)) | (1L << (CONTINUE - 454)) | (1L << (CONVERSION - 454)) | (1L << (COPY - 454)) | (1L << (COST - 454)) | (1L << (CSV - 454)) | (1L << (CALLED - 454)) | (1L << (CATALOG - 454)) | (1L << (CHAIN - 454)) | (1L << (CHECKPOINT - 454)) | (1L << (CLASS - 454)) | (1L << (CONFIGURATION - 454)) | (1L << (COMMENT - 454)) | (1L << (DETACH - 454)) | (1L << (DICTIONARY - 454)) | (1L << (EXPRESSION - 454)) | (1L << (INSENSITIVE - 454)) | (1L << (DISCARD - 454)) | (1L << (OFF - 454)) | (1L << (INSTEAD - 454)) | (1L << (EXPLAIN - 454)) | (1L << (INPUT - 454)) | (1L << (INLINE - 454)) | (1L << (PARALLEL - 454)) | (1L << (LEAKPROOF - 454)) | (1L << (COMMITTED - 454)) | (1L << (ENCODING - 454)) | (1L << (IMPLICIT - 454)) | (1L << (DELIMITER - 454)) | (1L << (CURSOR - 454)) | (1L << (EACH - 454)) | (1L << (EVENT - 454)) | (1L << (DEALLOCATE - 454)) | (1L << (CONNECTION - 454)) | (1L << (DECLARE - 454)) | (1L << (FAMILY - 454)) | (1L << (FORWARD - 454)) | (1L << (EXCLUSIVE - 454)) | (1L << (FUNCTIONS - 454)) | (1L << (LOCATION - 454)) | (1L << (LABEL - 454)) | (1L << (DELIMITERS - 454)) | (1L << (HANDLER - 454)) | (1L << (HEADER - 454)) | (1L << (IMMUTABLE - 454)) | (1L << (GRANTED - 454)) | (1L << (HOLD - 454)) | (1L << (MAPPING - 454)) | (1L << (OLD - 454)) | (1L << (METHOD - 454)) | (1L << (LOAD - 454)) | (1L << (LISTEN - 454)) | (1L << (MODE - 454)) | (1L << (MOVE - 454)) | (1L << (PROCEDURAL - 454)) | (1L << (PARSER - 454)) | (1L << (PROCEDURES - 454)) | (1L << (ENCRYPTED - 454)) | (1L << (PUBLICATION - 454)) | (1L << (PROGRAM - 454)) | (1L << (REFERENCING - 454)) | (1L << (PLANS - 454)) | (1L << (REINDEX - 454)))) != 0) || ((((_la - 518)) & ~0x3f) == 0 && ((1L << (_la - 518)) & ((1L << (PRIOR - 518)) | (1L << (PASSWORD - 518)) | (1L << (RELATIVE - 518)) | (1L << (QUOTE - 518)) | (1L << (ROUTINES - 518)) | (1L << (REPLACE - 518)) | (1L << (SNAPSHOT - 518)) | (1L << (REFRESH - 518)) | (1L << (PREPARE - 518)) | (1L << (OPTIONS - 518)) | (1L << (IMPORT - 518)) | (1L << (INVOKER - 518)) | (1L << (NEW - 518)) | (1L << (PREPARED - 518)) | (1L << (SCROLL - 518)) | (1L << (SEQUENCES - 518)) | (1L << (SYSID - 518)) | (1L << (REASSIGN - 518)) | (1L << (SERVER - 518)) | (1L << (SUBSCRIPTION - 518)) | (1L << (SEARCH - 518)) | (1L << (SCHEMAS - 518)) | (1L << (RECHECK - 518)) | (1L << (POLICY - 518)) | (1L << (NOTIFY - 518)) | (1L << (LOCK - 518)) | (1L << (RELEASE - 518)) | (1L << (SERIALIZABLE - 518)) | (1L << (RETURNS - 518)) | (1L << (STATEMENT - 518)) | (1L << (STDIN - 518)) | (1L << (STDOUT - 518)) | (1L << (TABLES - 518)) | (1L << (SUPPORT - 518)) | (1L << (STABLE - 518)) | (1L << (TEMPLATE - 518)) | (1L << (UNENCRYPTED - 518)) | (1L << (VIEWS - 518)) | (1L << (UNCOMMITTED - 518)) | (1L << (TRANSFORM - 518)) | (1L << (UNLISTEN - 518)) | (1L << (TRUSTED - 518)) | (1L << (VALIDATOR - 518)) | (1L << (UNTIL - 518)) | (1L << (VACUUM - 518)) | (1L << (VOLATILE - 518)) | (1L << (STORED - 518)) | (1L << (WRITE - 518)) | (1L << (STRICT - 518)) | (1L << (TYPES - 518)) | (1L << (WRAPPER - 518)) | (1L << (WORK - 518)) | (1L << (FREEZE - 518)) | (1L << (AUTHORIZATION - 518)) | (1L << (VERBOSE - 518)) | (1L << (PARAM - 518)) | (1L << (IDENTIFIER_ - 518)) | (1L << (STRING_ - 518)) | (1L << (NUMBER_ - 518)))) != 0)) {
{
setState(3250);
sliceBound();
}
}
setState(3253);
match(RBT_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SliceBoundContext extends ParserRuleContext {
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public SliceBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sliceBound; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSliceBound(this);
else return visitor.visitChildren(this);
}
}
public final SliceBoundContext sliceBound() throws RecognitionException {
SliceBoundContext _localctx = new SliceBoundContext(_ctx, getState());
enterRule(_localctx, 290, RULE_sliceBound);
try {
enterOuterAlt(_localctx, 1);
{
setState(3256);
aExpr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InExprContext extends ParserRuleContext {
public SelectWithParensContext selectWithParens() {
return getRuleContext(SelectWithParensContext.class,0);
}
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public InExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitInExpr(this);
else return visitor.visitChildren(this);
}
}
public final InExprContext inExpr() throws RecognitionException {
InExprContext _localctx = new InExprContext(_ctx, getState());
enterRule(_localctx, 292, RULE_inExpr);
try {
setState(3263);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3258);
selectWithParens();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3259);
match(LP_);
setState(3260);
exprList(0);
setState(3261);
match(RP_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseExprContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(OpenGaussStatementParser.CASE, 0); }
public WhenClauseListContext whenClauseList() {
return getRuleContext(WhenClauseListContext.class,0);
}
public TerminalNode END() { return getToken(OpenGaussStatementParser.END, 0); }
public CaseArgContext caseArg() {
return getRuleContext(CaseArgContext.class,0);
}
public CaseDefaultContext caseDefault() {
return getRuleContext(CaseDefaultContext.class,0);
}
public CaseExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCaseExpr(this);
else return visitor.visitChildren(this);
}
}
public final CaseExprContext caseExpr() throws RecognitionException {
CaseExprContext _localctx = new CaseExprContext(_ctx, getState());
enterRule(_localctx, 294, RULE_caseExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3265);
match(CASE);
setState(3267);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OR_) | (1L << SIGNED_LEFT_SHIFT_) | (1L << SIGNED_RIGHT_SHIFT_) | (1L << PLUS_) | (1L << MINUS_) | (1L << POUND_) | (1L << LP_) | (1L << QUESTION_) | (1L << DOLLAR_) | (1L << UNICODE_ESCAPE) | (1L << JSON_EXTRACT_) | (1L << JSON_EXTRACT_TEXT_) | (1L << JSON_PATH_EXTRACT_) | (1L << JSON_PATH_EXTRACT_TEXT_) | (1L << JSONB_CONTAIN_RIGHT_) | (1L << JSONB_CONTAIN_LEFT_) | (1L << JSONB_CONTAIN_ALL_TOP_KEY_) | (1L << JSONB_PATH_DELETE_) | (1L << JSONB_PATH_CONTAIN_ANY_VALUE_) | (1L << JSONB_PATH_PREDICATE_CHECK_) | (1L << GEOMETRIC_LENGTH_) | (1L << GEOMETRIC_DISTANCE_))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GEOMETRIC_EXTEND_RIGHT_ - 64)) | (1L << (GEOMETRIC_EXTEND_LEFT_ - 64)) | (1L << (GEOMETRIC_STRICT_BELOW_ - 64)) | (1L << (GEOMETRIC_STRICT_ABOVE_ - 64)) | (1L << (GEOMETRIC_EXTEND_ABOVE_ - 64)) | (1L << (GEOMETRIC_EXTEND_BELOW_ - 64)) | (1L << (GEOMETRIC_BELOW_ - 64)) | (1L << (GEOMETRIC_ABOVE_ - 64)) | (1L << (GEOMETRIC_INTERSECT_ - 64)) | (1L << (GEOMETRIC_PERPENDICULAR_ - 64)) | (1L << (GEOMETRIC_SAME_AS_ - 64)) | (1L << (INSERT - 64)) | (1L << (UPDATE - 64)) | (1L << (DELETE - 64)) | (1L << (ALTER - 64)) | (1L << (DROP - 64)) | (1L << (TRUNCATE - 64)) | (1L << (SCHEMA - 64)) | (1L << (REVOKE - 64)) | (1L << (ADD - 64)) | (1L << (SET - 64)) | (1L << (INDEX - 64)) | (1L << (UNIQUE - 64)) | (1L << (KEY - 64)) | (1L << (POSITION - 64)) | (1L << (FUNCTION - 64)) | (1L << (TRIGGER - 64)) | (1L << (PROCEDURE - 64)) | (1L << (VIEW - 64)) | (1L << (CASE - 64)) | (1L << (CAST - 64)) | (1L << (TRIM - 64)) | (1L << (SUBSTRING - 64)) | (1L << (NATURAL - 64)) | (1L << (JOIN - 64)) | (1L << (FULL - 64)) | (1L << (INNER - 64)) | (1L << (OUTER - 64)) | (1L << (LEFT - 64)) | (1L << (RIGHT - 64)) | (1L << (CROSS - 64)) | (1L << (IF - 64)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (IS - 134)) | (1L << (NOT - 134)) | (1L << (NULL - 134)) | (1L << (TRUE - 134)) | (1L << (FALSE - 134)) | (1L << (EXISTS - 134)) | (1L << (LIKE - 134)) | (1L << (BY - 134)) | (1L << (BEGIN - 134)) | (1L << (COMMIT - 134)) | (1L << (ROLLBACK - 134)) | (1L << (SAVEPOINT - 134)) | (1L << (BOOLEAN - 134)) | (1L << (DOUBLE - 134)) | (1L << (CHAR - 134)) | (1L << (CHARACTER - 134)) | (1L << (ARRAY - 134)) | (1L << (INTERVAL - 134)) | (1L << (DATE - 134)) | (1L << (TIME - 134)) | (1L << (TIMESTAMP - 134)) | (1L << (LOCALTIME - 134)) | (1L << (LOCALTIMESTAMP - 134)) | (1L << (YEAR - 134)) | (1L << (MONTH - 134)) | (1L << (DAY - 134)) | (1L << (HOUR - 134)) | (1L << (MINUTE - 134)) | (1L << (SECOND - 134)) | (1L << (DEFAULT - 134)) | (1L << (CURRENT - 134)) | (1L << (ENABLE - 134)) | (1L << (DISABLE - 134)) | (1L << (CALL - 134)) | (1L << (PRESERVE - 134)) | (1L << (DEFINER - 134)) | (1L << (CURRENT_USER - 134)) | (1L << (SQL - 134)) | (1L << (CASCADED - 134)) | (1L << (LOCAL - 134)) | (1L << (CLOSE - 134)) | (1L << (NEXT - 134)) | (1L << (NAME - 134)) | (1L << (COLLATION - 134)) | (1L << (NAMES - 134)) | (1L << (INTEGER - 134)) | (1L << (REAL - 134)))) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & ((1L << (DECIMAL - 198)) | (1L << (TYPE - 198)) | (1L << (SMALLINT - 198)) | (1L << (BIGINT - 198)) | (1L << (NUMERIC - 198)) | (1L << (TEXT - 198)) | (1L << (REPEATABLE - 198)) | (1L << (CURRENT_DATE - 198)) | (1L << (CURRENT_TIME - 198)) | (1L << (CURRENT_TIMESTAMP - 198)) | (1L << (NULLIF - 198)) | (1L << (VARYING - 198)) | (1L << (NATIONAL - 198)) | (1L << (NCHAR - 198)) | (1L << (VALUE - 198)) | (1L << (COALESCE - 198)) | (1L << (TIES - 198)) | (1L << (CUBE - 198)) | (1L << (GROUPING - 198)) | (1L << (SETS - 198)) | (1L << (OTHERS - 198)) | (1L << (OVERLAPS - 198)) | (1L << (AT - 198)) | (1L << (DEC - 198)) | (1L << (MAXVALUE - 198)) | (1L << (ADMIN - 198)) | (1L << (BINARY - 198)) | (1L << (ESCAPE - 198)) | (1L << (EXCLUDE - 198)) | (1L << (MOD - 198)) | (1L << (PARTITION - 198)) | (1L << (ROW - 198)) | (1L << (UNKNOWN - 198)) | (1L << (ALWAYS - 198)) | (1L << (CASCADE - 198)) | (1L << (GENERATED - 198)) | (1L << (ISOLATION - 198)) | (1L << (LEVEL - 198)) | (1L << (NO - 198)) | (1L << (OPTION - 198)) | (1L << (PRIVILEGES - 198)) | (1L << (READ - 198)) | (1L << (ROLE - 198)) | (1L << (ROWS - 198)) | (1L << (START - 198)) | (1L << (TRANSACTION - 198)) | (1L << (USER - 198)) | (1L << (ACTION - 198)))) != 0) || ((((_la - 262)) & ~0x3f) == 0 && ((1L << (_la - 262)) & ((1L << (CACHE - 262)) | (1L << (CHARACTERISTICS - 262)) | (1L << (CLUSTER - 262)) | (1L << (COMMENTS - 262)) | (1L << (CONCURRENTLY - 262)) | (1L << (CONSTRAINTS - 262)) | (1L << (CYCLE - 262)) | (1L << (DATA - 262)) | (1L << (DATABASE - 262)) | (1L << (DEFAULTS - 262)) | (1L << (DEFERRED - 262)) | (1L << (DEPENDS - 262)) | (1L << (DOMAIN - 262)) | (1L << (EXCLUDING - 262)) | (1L << (EXECUTE - 262)) | (1L << (EXTENDED - 262)) | (1L << (EXTENSION - 262)) | (1L << (EXTERNAL - 262)) | (1L << (EXTRACT - 262)) | (1L << (FILTER - 262)) | (1L << (FIRST - 262)) | (1L << (FOLLOWING - 262)) | (1L << (FORCE - 262)) | (1L << (GLOBAL - 262)) | (1L << (IDENTITY - 262)) | (1L << (IMMEDIATE - 262)) | (1L << (INCLUDING - 262)) | (1L << (INCREMENT - 262)) | (1L << (INDEXES - 262)) | (1L << (INHERIT - 262)) | (1L << (INHERITS - 262)) | (1L << (INCLUDE - 262)) | (1L << (LANGUAGE - 262)) | (1L << (LARGE - 262)) | (1L << (LAST - 262)) | (1L << (LOGGED - 262)) | (1L << (MAIN - 262)) | (1L << (MATCH - 262)) | (1L << (MINVALUE - 262)) | (1L << (NOTHING - 262)) | (1L << (NULLS - 262)) | (1L << (OBJECT - 262)) | (1L << (OIDS - 262)) | (1L << (OVER - 262)) | (1L << (OWNED - 262)) | (1L << (OWNER - 262)) | (1L << (PARTIAL - 262)) | (1L << (PLAIN - 262)) | (1L << (PRECEDING - 262)) | (1L << (RANGE - 262)) | (1L << (RENAME - 262)) | (1L << (REPLICA - 262)) | (1L << (RESET - 262)) | (1L << (RESTART - 262)) | (1L << (RESTRICT - 262)) | (1L << (ROUTINE - 262)) | (1L << (RULE - 262)) | (1L << (SECURITY - 262)))) != 0) || ((((_la - 326)) & ~0x3f) == 0 && ((1L << (_la - 326)) & ((1L << (SEQUENCE - 326)) | (1L << (SESSION - 326)) | (1L << (SESSION_USER - 326)) | (1L << (SHOW - 326)) | (1L << (SIMPLE - 326)) | (1L << (STATISTICS - 326)) | (1L << (STORAGE - 326)) | (1L << (TABLESPACE - 326)) | (1L << (TEMP - 326)) | (1L << (TEMPORARY - 326)) | (1L << (UNBOUNDED - 326)) | (1L << (UNLOGGED - 326)) | (1L << (VALID - 326)) | (1L << (VALIDATE - 326)) | (1L << (WITHIN - 326)) | (1L << (WITHOUT - 326)) | (1L << (ZONE - 326)) | (1L << (OF - 326)) | (1L << (UESCAPE - 326)) | (1L << (GROUPS - 326)) | (1L << (RECURSIVE - 326)) | (1L << (INT - 326)) | (1L << (INT2 - 326)) | (1L << (INT4 - 326)) | (1L << (INT8 - 326)) | (1L << (FLOAT - 326)) | (1L << (FLOAT4 - 326)) | (1L << (FLOAT8 - 326)) | (1L << (VARCHAR - 326)) | (1L << (ENUM - 326)) | (1L << (POINT - 326)) | (1L << (LSEG - 326)) | (1L << (BOX - 326)) | (1L << (PATH - 326)) | (1L << (POLYGON - 326)) | (1L << (CIRCLE - 326)) | (1L << (BIT - 326)) | (1L << (XML - 326)) | (1L << (JSON - 326)) | (1L << (TABLESAMPLE - 326)) | (1L << (ORDINALITY - 326)) | (1L << (CURRENT_ROLE - 326)) | (1L << (CURRENT_CATALOG - 326)) | (1L << (CURRENT_SCHEMA - 326)) | (1L << (NORMALIZE - 326)))) != 0) || ((((_la - 390)) & ~0x3f) == 0 && ((1L << (_la - 390)) & ((1L << (OVERLAY - 390)) | (1L << (XMLCONCAT - 390)) | (1L << (XMLELEMENT - 390)) | (1L << (XMLEXISTS - 390)) | (1L << (XMLFOREST - 390)) | (1L << (XMLPARSE - 390)) | (1L << (XMLPI - 390)) | (1L << (XMLROOT - 390)) | (1L << (XMLSERIALIZE - 390)) | (1L << (TREAT - 390)) | (1L << (NFC - 390)) | (1L << (NFD - 390)) | (1L << (NFKC - 390)) | (1L << (NFKD - 390)) | (1L << (REF - 390)) | (1L << (PASSING - 390)) | (1L << (VERSION - 390)) | (1L << (YES - 390)) | (1L << (STANDALONE - 390)) | (1L << (GREATEST - 390)) | (1L << (LEAST - 390)) | (1L << (MATERIALIZED - 390)) | (1L << (OPERATOR - 390)) | (1L << (SHARE - 390)) | (1L << (ROLLUP - 390)) | (1L << (ILIKE - 390)) | (1L << (SIMILAR - 390)) | (1L << (ISNULL - 390)) | (1L << (NOTNULL - 390)) | (1L << (DOCUMENT - 390)) | (1L << (NORMALIZED - 390)) | (1L << (NOWAIT - 390)) | (1L << (LOCKED - 390)) | (1L << (COLUMNS - 390)) | (1L << (CONTENT - 390)) | (1L << (STRIP - 390)) | (1L << (WHITESPACE - 390)) | (1L << (CONFLICT - 390)) | (1L << (OVERRIDING - 390)) | (1L << (SYSTEM - 390)) | (1L << (ABORT - 390)) | (1L << (ABSOLUTE - 390)) | (1L << (ACCESS - 390)) | (1L << (AFTER - 390)) | (1L << (AGGREGATE - 390)) | (1L << (ALSO - 390)) | (1L << (ATTACH - 390)) | (1L << (ATTRIBUTE - 390)) | (1L << (BACKWARD - 390)) | (1L << (BEFORE - 390)) | (1L << (ASSERTION - 390)))) != 0) || ((((_la - 454)) & ~0x3f) == 0 && ((1L << (_la - 454)) & ((1L << (ASSIGNMENT - 454)) | (1L << (CONTINUE - 454)) | (1L << (CONVERSION - 454)) | (1L << (COPY - 454)) | (1L << (COST - 454)) | (1L << (CSV - 454)) | (1L << (CALLED - 454)) | (1L << (CATALOG - 454)) | (1L << (CHAIN - 454)) | (1L << (CHECKPOINT - 454)) | (1L << (CLASS - 454)) | (1L << (CONFIGURATION - 454)) | (1L << (COMMENT - 454)) | (1L << (DETACH - 454)) | (1L << (DICTIONARY - 454)) | (1L << (EXPRESSION - 454)) | (1L << (INSENSITIVE - 454)) | (1L << (DISCARD - 454)) | (1L << (OFF - 454)) | (1L << (INSTEAD - 454)) | (1L << (EXPLAIN - 454)) | (1L << (INPUT - 454)) | (1L << (INLINE - 454)) | (1L << (PARALLEL - 454)) | (1L << (LEAKPROOF - 454)) | (1L << (COMMITTED - 454)) | (1L << (ENCODING - 454)) | (1L << (IMPLICIT - 454)) | (1L << (DELIMITER - 454)) | (1L << (CURSOR - 454)) | (1L << (EACH - 454)) | (1L << (EVENT - 454)) | (1L << (DEALLOCATE - 454)) | (1L << (CONNECTION - 454)) | (1L << (DECLARE - 454)) | (1L << (FAMILY - 454)) | (1L << (FORWARD - 454)) | (1L << (EXCLUSIVE - 454)) | (1L << (FUNCTIONS - 454)) | (1L << (LOCATION - 454)) | (1L << (LABEL - 454)) | (1L << (DELIMITERS - 454)) | (1L << (HANDLER - 454)) | (1L << (HEADER - 454)) | (1L << (IMMUTABLE - 454)) | (1L << (GRANTED - 454)) | (1L << (HOLD - 454)) | (1L << (MAPPING - 454)) | (1L << (OLD - 454)) | (1L << (METHOD - 454)) | (1L << (LOAD - 454)) | (1L << (LISTEN - 454)) | (1L << (MODE - 454)) | (1L << (MOVE - 454)) | (1L << (PROCEDURAL - 454)) | (1L << (PARSER - 454)) | (1L << (PROCEDURES - 454)) | (1L << (ENCRYPTED - 454)) | (1L << (PUBLICATION - 454)) | (1L << (PROGRAM - 454)) | (1L << (REFERENCING - 454)) | (1L << (PLANS - 454)) | (1L << (REINDEX - 454)))) != 0) || ((((_la - 518)) & ~0x3f) == 0 && ((1L << (_la - 518)) & ((1L << (PRIOR - 518)) | (1L << (PASSWORD - 518)) | (1L << (RELATIVE - 518)) | (1L << (QUOTE - 518)) | (1L << (ROUTINES - 518)) | (1L << (REPLACE - 518)) | (1L << (SNAPSHOT - 518)) | (1L << (REFRESH - 518)) | (1L << (PREPARE - 518)) | (1L << (OPTIONS - 518)) | (1L << (IMPORT - 518)) | (1L << (INVOKER - 518)) | (1L << (NEW - 518)) | (1L << (PREPARED - 518)) | (1L << (SCROLL - 518)) | (1L << (SEQUENCES - 518)) | (1L << (SYSID - 518)) | (1L << (REASSIGN - 518)) | (1L << (SERVER - 518)) | (1L << (SUBSCRIPTION - 518)) | (1L << (SEARCH - 518)) | (1L << (SCHEMAS - 518)) | (1L << (RECHECK - 518)) | (1L << (POLICY - 518)) | (1L << (NOTIFY - 518)) | (1L << (LOCK - 518)) | (1L << (RELEASE - 518)) | (1L << (SERIALIZABLE - 518)) | (1L << (RETURNS - 518)) | (1L << (STATEMENT - 518)) | (1L << (STDIN - 518)) | (1L << (STDOUT - 518)) | (1L << (TABLES - 518)) | (1L << (SUPPORT - 518)) | (1L << (STABLE - 518)) | (1L << (TEMPLATE - 518)) | (1L << (UNENCRYPTED - 518)) | (1L << (VIEWS - 518)) | (1L << (UNCOMMITTED - 518)) | (1L << (TRANSFORM - 518)) | (1L << (UNLISTEN - 518)) | (1L << (TRUSTED - 518)) | (1L << (VALIDATOR - 518)) | (1L << (UNTIL - 518)) | (1L << (VACUUM - 518)) | (1L << (VOLATILE - 518)) | (1L << (STORED - 518)) | (1L << (WRITE - 518)) | (1L << (STRICT - 518)) | (1L << (TYPES - 518)) | (1L << (WRAPPER - 518)) | (1L << (WORK - 518)) | (1L << (FREEZE - 518)) | (1L << (AUTHORIZATION - 518)) | (1L << (VERBOSE - 518)) | (1L << (PARAM - 518)) | (1L << (IDENTIFIER_ - 518)) | (1L << (STRING_ - 518)) | (1L << (NUMBER_ - 518)))) != 0)) {
{
setState(3266);
caseArg();
}
}
setState(3269);
whenClauseList();
setState(3271);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(3270);
caseDefault();
}
}
setState(3273);
match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhenClauseListContext extends ParserRuleContext {
public List whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public WhenClauseListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whenClauseList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWhenClauseList(this);
else return visitor.visitChildren(this);
}
}
public final WhenClauseListContext whenClauseList() throws RecognitionException {
WhenClauseListContext _localctx = new WhenClauseListContext(_ctx, getState());
enterRule(_localctx, 296, RULE_whenClauseList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(3276);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(3275);
whenClause();
}
}
setState(3278);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhenClauseContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(OpenGaussStatementParser.WHEN, 0); }
public List aExpr() {
return getRuleContexts(AExprContext.class);
}
public AExprContext aExpr(int i) {
return getRuleContext(AExprContext.class,i);
}
public TerminalNode THEN() { return getToken(OpenGaussStatementParser.THEN, 0); }
public WhenClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whenClause; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitWhenClause(this);
else return visitor.visitChildren(this);
}
}
public final WhenClauseContext whenClause() throws RecognitionException {
WhenClauseContext _localctx = new WhenClauseContext(_ctx, getState());
enterRule(_localctx, 298, RULE_whenClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(3280);
match(WHEN);
setState(3281);
aExpr(0);
setState(3282);
match(THEN);
setState(3283);
aExpr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseDefaultContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(OpenGaussStatementParser.ELSE, 0); }
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public CaseDefaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseDefault; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCaseDefault(this);
else return visitor.visitChildren(this);
}
}
public final CaseDefaultContext caseDefault() throws RecognitionException {
CaseDefaultContext _localctx = new CaseDefaultContext(_ctx, getState());
enterRule(_localctx, 300, RULE_caseDefault);
try {
enterOuterAlt(_localctx, 1);
{
setState(3285);
match(ELSE);
setState(3286);
aExpr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseArgContext extends ParserRuleContext {
public AExprContext aExpr() {
return getRuleContext(AExprContext.class,0);
}
public CaseArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseArg; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitCaseArg(this);
else return visitor.visitChildren(this);
}
}
public final CaseArgContext caseArg() throws RecognitionException {
CaseArgContext _localctx = new CaseArgContext(_ctx, getState());
enterRule(_localctx, 302, RULE_caseArg);
try {
enterOuterAlt(_localctx, 1);
{
setState(3288);
aExpr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ColumnrefContext extends ParserRuleContext {
public ColIdContext colId() {
return getRuleContext(ColIdContext.class,0);
}
public IndirectionContext indirection() {
return getRuleContext(IndirectionContext.class,0);
}
public ColumnrefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnref; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitColumnref(this);
else return visitor.visitChildren(this);
}
}
public final ColumnrefContext columnref() throws RecognitionException {
ColumnrefContext _localctx = new ColumnrefContext(_ctx, getState());
enterRule(_localctx, 304, RULE_columnref);
try {
setState(3294);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3290);
colId();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3291);
colId();
setState(3292);
indirection(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualOpContext extends ParserRuleContext {
public JsonOperatorContext jsonOperator() {
return getRuleContext(JsonOperatorContext.class,0);
}
public GeometricOperatorContext geometricOperator() {
return getRuleContext(GeometricOperatorContext.class,0);
}
public TerminalNode OPERATOR() { return getToken(OpenGaussStatementParser.OPERATOR, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public AnyOperatorContext anyOperator() {
return getRuleContext(AnyOperatorContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public QualOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitQualOp(this);
else return visitor.visitChildren(this);
}
}
public final QualOpContext qualOp() throws RecognitionException {
QualOpContext _localctx = new QualOpContext(_ctx, getState());
enterRule(_localctx, 306, RULE_qualOp);
try {
setState(3303);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3296);
jsonOperator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3297);
geometricOperator();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3298);
match(OPERATOR);
setState(3299);
match(LP_);
setState(3300);
anyOperator();
setState(3301);
match(RP_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubqueryOpContext extends ParserRuleContext {
public AllOpContext allOp() {
return getRuleContext(AllOpContext.class,0);
}
public TerminalNode OPERATOR() { return getToken(OpenGaussStatementParser.OPERATOR, 0); }
public TerminalNode LP_() { return getToken(OpenGaussStatementParser.LP_, 0); }
public AnyOperatorContext anyOperator() {
return getRuleContext(AnyOperatorContext.class,0);
}
public TerminalNode RP_() { return getToken(OpenGaussStatementParser.RP_, 0); }
public TerminalNode LIKE() { return getToken(OpenGaussStatementParser.LIKE, 0); }
public TerminalNode NOT() { return getToken(OpenGaussStatementParser.NOT, 0); }
public TerminalNode TILDE_() { return getToken(OpenGaussStatementParser.TILDE_, 0); }
public TerminalNode NOT_() { return getToken(OpenGaussStatementParser.NOT_, 0); }
public SubqueryOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subqueryOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitSubqueryOp(this);
else return visitor.visitChildren(this);
}
}
public final SubqueryOpContext subqueryOp() throws RecognitionException {
SubqueryOpContext _localctx = new SubqueryOpContext(_ctx, getState());
enterRule(_localctx, 308, RULE_subqueryOp);
try {
setState(3317);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3305);
allOp();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3306);
match(OPERATOR);
setState(3307);
match(LP_);
setState(3308);
anyOperator();
setState(3309);
match(RP_);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(3311);
match(LIKE);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(3312);
match(NOT);
setState(3313);
match(LIKE);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(3314);
match(TILDE_);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(3315);
match(NOT_);
setState(3316);
match(TILDE_);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AllOpContext extends ParserRuleContext {
public OpContext op() {
return getRuleContext(OpContext.class,0);
}
public MathOperatorContext mathOperator() {
return getRuleContext(MathOperatorContext.class,0);
}
public AllOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_allOp; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OpenGaussStatementVisitor ) return ((OpenGaussStatementVisitor)visitor).visitAllOp(this);
else return visitor.visitChildren(this);
}
}
public final AllOpContext allOp() throws RecognitionException {
AllOpContext _localctx = new AllOpContext(_ctx, getState());
enterRule(_localctx, 310, RULE_allOp);
try {
setState(3321);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(3319);
op();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(3320);
mathOperator();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OpContext extends ParserRuleContext {
public List AND_() { return getTokens(OpenGaussStatementParser.AND_); }
public TerminalNode AND_(int i) {
return getToken(OpenGaussStatementParser.AND_, i);
}
public List OR_() { return getTokens(OpenGaussStatementParser.OR_); }
public TerminalNode OR_(int i) {
return getToken(OpenGaussStatementParser.OR_, i);
}
public List NOT_() { return getTokens(OpenGaussStatementParser.NOT_); }
public TerminalNode NOT_(int i) {
return getToken(OpenGaussStatementParser.NOT_, i);
}
public List TILDE_() { return getTokens(OpenGaussStatementParser.TILDE_); }
public TerminalNode TILDE_(int i) {
return getToken(OpenGaussStatementParser.TILDE_, i);
}
public List VERTICAL_BAR_() { return getTokens(OpenGaussStatementParser.VERTICAL_BAR_); }
public TerminalNode VERTICAL_BAR_(int i) {
return getToken(OpenGaussStatementParser.VERTICAL_BAR_, i);
}
public List AMPERSAND_() { return getTokens(OpenGaussStatementParser.AMPERSAND_); }
public TerminalNode AMPERSAND_(int i) {
return getToken(OpenGaussStatementParser.AMPERSAND_, i);
}
public List SIGNED_LEFT_SHIFT_() { return getTokens(OpenGaussStatementParser.SIGNED_LEFT_SHIFT_); }
public TerminalNode SIGNED_LEFT_SHIFT_(int i) {
return getToken(OpenGaussStatementParser.SIGNED_LEFT_SHIFT_, i);
}
public List SIGNED_RIGHT_SHIFT_() { return getTokens(OpenGaussStatementParser.SIGNED_RIGHT_SHIFT_); }
public TerminalNode SIGNED_RIGHT_SHIFT_(int i) {
return getToken(OpenGaussStatementParser.SIGNED_RIGHT_SHIFT_, i);
}
public List CARET_() { return getTokens(OpenGaussStatementParser.CARET_); }
public TerminalNode CARET_(int i) {
return getToken(OpenGaussStatementParser.CARET_, i);
}
public List MOD_() { return getTokens(OpenGaussStatementParser.MOD_); }
public TerminalNode MOD_(int i) {
return getToken(OpenGaussStatementParser.MOD_, i);
}
public List COLON_() { return getTokens(OpenGaussStatementParser.COLON_); }
public TerminalNode COLON_(int i) {
return getToken(OpenGaussStatementParser.COLON_, i);
}
public List PLUS_() { return getTokens(OpenGaussStatementParser.PLUS_); }
public TerminalNode PLUS_(int i) {
return getToken(OpenGaussStatementParser.PLUS_, i);
}
public List MINUS_() { return getTokens(OpenGaussStatementParser.MINUS_); }
public TerminalNode MINUS_(int i) {
return getToken(OpenGaussStatementParser.MINUS_, i);
}
public List ASTERISK_() { return getTokens(OpenGaussStatementParser.ASTERISK_); }
public TerminalNode ASTERISK_(int i) {
return getToken(OpenGaussStatementParser.ASTERISK_, i);
}
public List SLASH_() { return getTokens(OpenGaussStatementParser.SLASH_); }
public TerminalNode SLASH_(int i) {
return getToken(OpenGaussStatementParser.SLASH_, i);
}
public List BACKSLASH_() { return getTokens(OpenGaussStatementParser.BACKSLASH_); }
public TerminalNode BACKSLASH_(int i) {
return getToken(OpenGaussStatementParser.BACKSLASH_, i);
}
public List DOT_() { return getTokens(OpenGaussStatementParser.DOT_); }
public TerminalNode DOT_(int i) {
return getToken(OpenGaussStatementParser.DOT_, i);
}
public List DOT_ASTERISK_() { return getTokens(OpenGaussStatementParser.DOT_ASTERISK_); }
public TerminalNode DOT_ASTERISK_(int i) {
return getToken(OpenGaussStatementParser.DOT_ASTERISK_, i);
}
public List SAFE_EQ_() { return getTokens(OpenGaussStatementParser.SAFE_EQ_); }
public TerminalNode SAFE_EQ_(int i) {
return getToken(OpenGaussStatementParser.SAFE_EQ_, i);
}
public List DEQ_() { return getTokens(OpenGaussStatementParser.DEQ_); }
public TerminalNode DEQ_(int i) {
return getToken(OpenGaussStatementParser.DEQ_, i);
}
public List EQ_() { return getTokens(OpenGaussStatementParser.EQ_); }
public TerminalNode EQ_(int i) {
return getToken(OpenGaussStatementParser.EQ_, i);
}
public List CQ_() { return getTokens(OpenGaussStatementParser.CQ_); }
public TerminalNode CQ_(int i) {
return getToken(OpenGaussStatementParser.CQ_, i);
}
public List NEQ_() { return getTokens(OpenGaussStatementParser.NEQ_); }
public TerminalNode NEQ_(int i) {
return getToken(OpenGaussStatementParser.NEQ_, i);
}
public List GT_() { return getTokens(OpenGaussStatementParser.GT_); }
public TerminalNode GT_(int i) {
return getToken(OpenGaussStatementParser.GT_, i);
}
public List GTE_() { return getTokens(OpenGaussStatementParser.GTE_); }
public TerminalNode GTE_(int i) {
return getToken(OpenGaussStatementParser.GTE_, i);
}
public List LT_() { return getTokens(OpenGaussStatementParser.LT_); }
public TerminalNode LT_(int i) {
return getToken(OpenGaussStatementParser.LT_, i);
}
public List LTE_() { return getTokens(OpenGaussStatementParser.LTE_); }
public TerminalNode LTE_(int i) {
return getToken(OpenGaussStatementParser.LTE_, i);
}
public List POUND_() { return getTokens(OpenGaussStatementParser.POUND_); }
public TerminalNode POUND_(int i) {
return getToken(OpenGaussStatementParser.POUND_, i);
}
public List LP_() { return getTokens(OpenGaussStatementParser.LP_); }
public TerminalNode LP_(int i) {
return getToken(OpenGaussStatementParser.LP_, i);
}
public List RP_() { return getTokens(OpenGaussStatementParser.RP_); }
public TerminalNode RP_(int i) {
return getToken(OpenGaussStatementParser.RP_, i);
}
public List LBE_() { return getTokens(OpenGaussStatementParser.LBE_); }
public TerminalNode LBE_(int i) {
return getToken(OpenGaussStatementParser.LBE_, i);
}
public List RBE_() { return getTokens(OpenGaussStatementParser.RBE_); }
public TerminalNode RBE_(int i) {
return getToken(OpenGaussStatementParser.RBE_, i);
}
public List LBT_() { return getTokens(OpenGaussStatementParser.LBT_); }
public TerminalNode LBT_(int i) {
return getToken(OpenGaussStatementParser.LBT_, i);
}
public List RBT_() { return getTokens(OpenGaussStatementParser.RBT_); }
public TerminalNode RBT_(int i) {
return getToken(OpenGaussStatementParser.RBT_, i);
}
public List COMMA_() { return getTokens(OpenGaussStatementParser.COMMA_); }
public TerminalNode COMMA_(int i) {
return getToken(OpenGaussStatementParser.COMMA_, i);
}
public List DQ_() { return getTokens(OpenGaussStatementParser.DQ_); }
public TerminalNode DQ_(int i) {
return getToken(OpenGaussStatementParser.DQ_, i);
}
public List SQ_() { return getTokens(OpenGaussStatementParser.SQ_); }
public TerminalNode SQ_(int i) {
return getToken(OpenGaussStatementParser.SQ_, i);
}
public List BQ_() { return getTokens(OpenGaussStatementParser.BQ_); }
public TerminalNode BQ_(int i) {
return getToken(OpenGaussStatementParser.BQ_, i);
}
public List QUESTION_() { return getTokens(OpenGaussStatementParser.QUESTION_); }
public TerminalNode QUESTION_(int i) {
return getToken(OpenGaussStatementParser.QUESTION_, i);
}
public List DOLLAR_() { return getTokens(OpenGaussStatementParser.DOLLAR_); }
public TerminalNode DOLLAR_(int i) {
return getToken(OpenGaussStatementParser.DOLLAR_, i);
}
public List AT_() { return getTokens(OpenGaussStatementParser.AT_); }
public TerminalNode AT_(int i) {
return getToken(OpenGaussStatementParser.AT_, i);
}
public List SEMI_() { return getTokens(OpenGaussStatementParser.SEMI_); }
public TerminalNode SEMI_(int i) {
return getToken(OpenGaussStatementParser.SEMI_, i);
}
public List TILDE_TILDE_() { return getTokens(OpenGaussStatementParser.TILDE_TILDE_); }
public TerminalNode TILDE_TILDE_(int i) {
return getToken(OpenGaussStatementParser.TILDE_TILDE_, i);
}
public List NOT_TILDE_TILDE_() { return getTokens(OpenGaussStatementParser.NOT_TILDE_TILDE_); }
public TerminalNode NOT_TILDE_TILDE_(int i) {
return getToken(OpenGaussStatementParser.NOT_TILDE_TILDE_, i);
}
public List TYPE_CAST_() { return getTokens(OpenGaussStatementParser.TYPE_CAST_); }
public TerminalNode TYPE_CAST_(int i) {
return getToken(OpenGaussStatementParser.TYPE_CAST_, i);
}
public List ILIKE_() { return getTokens(OpenGaussStatementParser.ILIKE_); }
public TerminalNode ILIKE_(int i) {
return getToken(OpenGaussStatementParser.ILIKE_, i);
}
public List NOT_ILIKE_() { return getTokens(OpenGaussStatementParser.NOT_ILIKE_); }
public TerminalNode NOT_ILIKE_(int i) {
return getToken(OpenGaussStatementParser.NOT_ILIKE_, i);
}
public List UNICODE_ESCAPE() { return getTokens(OpenGaussStatementParser.UNICODE_ESCAPE); }
public TerminalNode UNICODE_ESCAPE(int i) {
return getToken(OpenGaussStatementParser.UNICODE_ESCAPE, i);
}
public List JSON_EXTRACT_() { return getTokens(OpenGaussStatementParser.JSON_EXTRACT_); }
public TerminalNode JSON_EXTRACT_(int i) {
return getToken(OpenGaussStatementParser.JSON_EXTRACT_, i);
}
public List JSON_EXTRACT_TEXT_() { return getTokens(OpenGaussStatementParser.JSON_EXTRACT_TEXT_); }
public TerminalNode JSON_EXTRACT_TEXT_(int i) {
return getToken(OpenGaussStatementParser.JSON_EXTRACT_TEXT_, i);
}
public List JSON_PATH_EXTRACT_() { return getTokens(OpenGaussStatementParser.JSON_PATH_EXTRACT_); }
public TerminalNode JSON_PATH_EXTRACT_(int i) {
return getToken(OpenGaussStatementParser.JSON_PATH_EXTRACT_, i);
}
public List JSON_PATH_EXTRACT_TEXT_() { return getTokens(OpenGaussStatementParser.JSON_PATH_EXTRACT_TEXT_); }
public TerminalNode JSON_PATH_EXTRACT_TEXT_(int i) {
return getToken(OpenGaussStatementParser.JSON_PATH_EXTRACT_TEXT_, i);
}
public List JSONB_CONTAIN_RIGHT_() { return getTokens(OpenGaussStatementParser.JSONB_CONTAIN_RIGHT_); }
public TerminalNode JSONB_CONTAIN_RIGHT_(int i) {
return getToken(OpenGaussStatementParser.JSONB_CONTAIN_RIGHT_, i);
}
public List JSONB_CONTAIN_LEFT_() { return getTokens(OpenGaussStatementParser.JSONB_CONTAIN_LEFT_); }
public TerminalNode JSONB_CONTAIN_LEFT_(int i) {
return getToken(OpenGaussStatementParser.JSONB_CONTAIN_LEFT_, i);
}
public List JSONB_CONTAIN_ALL_TOP_KEY_() { return getTokens(OpenGaussStatementParser.JSONB_CONTAIN_ALL_TOP_KEY_); }
public TerminalNode JSONB_CONTAIN_ALL_TOP_KEY_(int i) {
return getToken(OpenGaussStatementParser.JSONB_CONTAIN_ALL_TOP_KEY_, i);
}
public List JSONB_PATH_DELETE_() { return getTokens(OpenGaussStatementParser.JSONB_PATH_DELETE_); }
public TerminalNode JSONB_PATH_DELETE_(int i) {
return getToken(OpenGaussStatementParser.JSONB_PATH_DELETE_, i);
}
public List JSONB_PATH_CONTAIN_ANY_VALUE_() { return getTokens(OpenGaussStatementParser.JSONB_PATH_CONTAIN_ANY_VALUE_); }
public TerminalNode JSONB_PATH_CONTAIN_ANY_VALUE_(int i) {
return getToken(OpenGaussStatementParser.JSONB_PATH_CONTAIN_ANY_VALUE_, i);
}
public List JSONB_PATH_PREDICATE_CHECK_() { return getTokens(OpenGaussStatementParser.JSONB_PATH_PREDICATE_CHECK_); }
public TerminalNode JSONB_PATH_PREDICATE_CHECK_(int i) {
return getToken(OpenGaussStatementParser.JSONB_PATH_PREDICATE_CHECK_, i);
}
public List GEOMETRIC_LENGTH_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_LENGTH_); }
public TerminalNode GEOMETRIC_LENGTH_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_LENGTH_, i);
}
public List GEOMETRIC_DISTANCE_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_DISTANCE_); }
public TerminalNode GEOMETRIC_DISTANCE_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_DISTANCE_, i);
}
public List GEOMETRIC_EXTEND_RIGHT_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_EXTEND_RIGHT_); }
public TerminalNode GEOMETRIC_EXTEND_RIGHT_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_EXTEND_RIGHT_, i);
}
public List GEOMETRIC_EXTEND_LEFT_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_EXTEND_LEFT_); }
public TerminalNode GEOMETRIC_EXTEND_LEFT_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_EXTEND_LEFT_, i);
}
public List GEOMETRIC_STRICT_BELOW_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_STRICT_BELOW_); }
public TerminalNode GEOMETRIC_STRICT_BELOW_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_STRICT_BELOW_, i);
}
public List GEOMETRIC_STRICT_ABOVE_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_STRICT_ABOVE_); }
public TerminalNode GEOMETRIC_STRICT_ABOVE_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_STRICT_ABOVE_, i);
}
public List GEOMETRIC_EXTEND_ABOVE_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_EXTEND_ABOVE_); }
public TerminalNode GEOMETRIC_EXTEND_ABOVE_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_EXTEND_ABOVE_, i);
}
public List GEOMETRIC_EXTEND_BELOW_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_EXTEND_BELOW_); }
public TerminalNode GEOMETRIC_EXTEND_BELOW_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_EXTEND_BELOW_, i);
}
public List GEOMETRIC_BELOW_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_BELOW_); }
public TerminalNode GEOMETRIC_BELOW_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_BELOW_, i);
}
public List GEOMETRIC_ABOVE_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_ABOVE_); }
public TerminalNode GEOMETRIC_ABOVE_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_ABOVE_, i);
}
public List GEOMETRIC_INTERSECT_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_INTERSECT_); }
public TerminalNode GEOMETRIC_INTERSECT_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_INTERSECT_, i);
}
public List GEOMETRIC_PERPENDICULAR_() { return getTokens(OpenGaussStatementParser.GEOMETRIC_PERPENDICULAR_); }
public TerminalNode GEOMETRIC_PERPENDICULAR_(int i) {
return getToken(OpenGaussStatementParser.GEOMETRIC_PERPENDICULAR_, i);
}
public List 